My Project
bench.c
Go to the documentation of this file.
1
9#include "bit.h"
10#include "board.h"
11#include "move.h"
12#include "options.h"
13#include "search.h"
14#include "util.h"
15
16#include <math.h>
17
18/*
19 * @brief return a CPU clock tick.
20 *
21 * @return a CPU clock tick.
22 */
23static unsigned long long click()
24{
25#if defined(USE_GAS_X64)
26
27 unsigned int a, d;
28 __asm__ volatile (
29 "rdtsc" : "=a" (a), "=d" (d));
30 return a | (((unsigned long long)d) << 32);
31
32#elif defined(USE_GAS_X86)
33 unsigned long long a;
34 __asm__ volatile (
35 "rdtsc" : "=A" (a));
36 return a;
37#elif defined(_WIN32)
38 return __rdtsc();
39#else
40 return cpu_clock();
41#endif
42}
43
44/*
45 * @brief Move generator performance test.
46 */
47static void bench_move_generator()
48{
49 const char *b = "OOOOOOOOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOOOOOOOO O";
50 char m[4];
51 Board board;
52 Move move;
53 int i, x;
54 const int N_WARMUP = 1000;
55 const int N_REPEAT = 1000000;
56 unsigned long long c, overhead;
57 double t, t_mean, t_var, t_min, t_max;
58
59 c = -click();
60 for (i = 0; i < N_WARMUP; ++i) {
61 }
62 c += click();
63
64 c = -click();
65 for (i = 0; i < N_REPEAT; ++i) {
66 }
67 c += click();
68 overhead = c;
69
70 t_mean = t_var = 0.0;
71 t_max = 0;
72 t_min = 1e30;
73
74 for (x = A1; x < PASS; ++x) {
75 board_set(&board, b);
76 board.player &= ~x_to_bit(x);
77 board.opponent &= ~x_to_bit(x);
78
79 c = -click();
80 for (i = 0; i < N_WARMUP; ++i) {
81 board_get_move(&board, x, &move);
82 }
83 c += click();
84
85 c = -click();
86 for (i = 0; i < N_REPEAT; ++i) {
87 board_get_move(&board, x, &move);
88 }
89 c += click();
90
91 t = ((double)(c - overhead)) / N_REPEAT;
92 t_mean += t;
93 t_var += t * t;
94 if (t < t_min) t_min = t;
95 if (t > t_max) t_max = t;
96
97 if (options.verbosity >= 2) printf("board_get_move: %s %.1f clicks;\n", move_to_string(x, WHITE, m), t);
98
99 }
100
101 t_mean /= x;
102 t_var = t_var / x - (t_mean * t_mean);
103
104 printf("board_get_move: %.2f < %.2f +/- %.2f < %.2f\n", t_min, t_mean, sqrt(t_var), t_max);
105}
106
107/*
108 * @brief Last Move performance test.
109 */
110static void bench_count_last_flip()
111{
112 const char *b = "OOOOOOOOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOOOOOOOO O";
113 char m[4];
114 Board board;
115 int i, x;
116 const int N_WARMUP = 1000;
117 const int N_REPEAT = 1000000;
118 unsigned long long c, overhead;
119 double t, t_mean, t_var, t_min, t_max;
120
121 c = -click();
122 for (i = 0; i < N_WARMUP; ++i) {
123 }
124 c += click();
125
126 c = -click();
127 for (i = 0; i < N_REPEAT; ++i) {
128 }
129 c += click();
130 overhead = c;
131
132 t_mean = t_var = 0.0;
133 t_max = 0;
134 t_min = 1e30;
135
136 for (x = A1; x < PASS; ++x) {
137 board_set(&board, b);
138 board.player &= ~x_to_bit(x);
139 board.opponent &= ~x_to_bit(x);
140
141 c = -click();
142 for (i = 0; i < N_WARMUP; ++i) {
143 count_last_flip(x, board.player);
144 }
145 c += click();
146
147 c = -click();
148 for (i = 0; i < N_REPEAT; ++i) {
149 count_last_flip(x, board.player);
150 }
151 c += click();
152
153 t = ((double)(c - overhead)) / N_REPEAT;
154 t_mean += t;
155 t_var += t * t;
156 if (t < t_min) t_min = t;
157 if (t > t_max) t_max = t;
158
159 if (options.verbosity >= 2) printf("count_last_flip: %s %.1f clicks;\n", move_to_string(x, WHITE, m), t);
160
161 }
162
163 t_mean /= x;
164 t_var = t_var / x - (t_mean * t_mean);
165
166 printf("count_last_flip: %.2f < %.2f +/- %.2f < %.2f\n", t_min, t_mean, sqrt(t_var), t_max);
167}
168
169/*
170 * @brief Scoring performance test.
171 */
172static void bench_board_score_1()
173{
174 const char *b = "OOOOOOOOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOOOOOOOO O";
175 char m[4];
176 Board board;
177 int i, x;
178 const int N_WARMUP = 1000;
179 const int N_REPEAT = 1000000;
180 unsigned long long c, overhead;
181 double t, t_mean, t_var, t_min, t_max;
182
183
184 c = -click();
185 for (i = 0; i < N_WARMUP; ++i) {
186 }
187 c += click();
188
189 c = -click();
190 for (i = 0; i < N_REPEAT; ++i) {
191 }
192 c += click();
193 overhead = c;
194
195 t_mean = t_var = 0.0;
196 t_max = 0;
197 t_min = 1e30;
198
199 for (x = A1; x < PASS; ++x) {
200 board_set(&board, b);
201 board.player &= ~x_to_bit(x);
202 board.opponent &= ~x_to_bit(x);
203
204 c = -click();
205 for (i = 0; i < N_WARMUP; ++i) {
206 board_score_1(&board, SCORE_MAX, x);
207 }
208 c += click();
209
210 c = -click();
211 for (i = 0; i < N_REPEAT; ++i) {
212 board_score_1(&board, SCORE_MAX, x);
213 }
214 c += click();
215
216 t = ((double)(c - overhead)) / N_REPEAT;
217 t_mean += t;
218 t_var += t * t;
219 if (t < t_min) t_min = t;
220 if (t > t_max) t_max = t;
221
222 if (options.verbosity >= 2) printf("board_score_1: %s %.1f clicks;\n", move_to_string(x, WHITE, m), t);
223
224 }
225
226 t_mean /= x;
227 t_var = t_var / x - (t_mean * t_mean);
228
229 printf("board_score_1: %.2f < %.2f +/- %.2f < %.2f\n", t_min, t_mean, sqrt(t_var), t_max);
230}
231
232/*
233 * @brief Mobility performance test.
234 */
235static void bench_mobility()
236{
237 const char *b = "OOOOOOOOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOOOOOOOO O";
238 char m[4];
239 Board board;
240 int i, x, v;
241 const int N_WARMUP = 1000;
242 const int N_REPEAT = 1000000;
243 unsigned long long c, overhead;
244 double t, t_mean, t_var, t_min, t_max;
245
246 board_set(&board, b);
247
248 x = A1;
249 c = -click();
250 for (i = 0; i < N_WARMUP; ++i) {
251 board.player &= ~x_to_bit(x);
252 board.opponent &= ~x_to_bit(x);
253 }
254 c += click();
255
256 c = -click();
257 for (i = 0; i < N_REPEAT; ++i) {
258 board.player &= ~x_to_bit(x);
259 board.opponent &= ~x_to_bit(x);
260 }
261 c += click();
262 overhead = 0;
263
264 t_mean = t_var = 0.0;
265 t_max = 0;
266 t_min = 1e30;
267
268 for (x = A1; x < PASS; ++x) {
269 board_set(&board, b);
270
271 v = 0;
272 c = -click();
273 for (i = 0; i < N_WARMUP; ++i) {
274 board.player &= ~x_to_bit(x);
275 board.opponent &= ~x_to_bit(x);
276 v += get_mobility(board.player, board.opponent);
277 v -= get_mobility(board.opponent, board.player);
278 }
279 c += click();
280
281 c = -click();
282 for (i = 0; i < N_REPEAT; ++i) {
283 board.player &= ~x_to_bit(x);
284 board.opponent &= ~x_to_bit(x);
285 v += get_mobility(board.player, board.opponent);
286 v -= get_mobility(board.opponent, board.player);
287 }
288 c += click();
289
290 t = ((double)(c - overhead)) / N_REPEAT / 2;
291 t_mean += t;
292 t_var += t * t;
293 if (t < t_min) t_min = t;
294 if (t > t_max) t_max = t;
295
296 if (options.verbosity >= 2) printf("v = %d\n", v);
297 if (options.verbosity >= 2) printf("mobility: %s %.1f clicks;\n", move_to_string(x, WHITE, m), t);
298 }
299
300 t_mean /= x;
301 t_var = t_var / x - (t_mean * t_mean);
302
303 printf("mobility: %.2f < %.2f +/- %.2f < %.2f\n", t_min, t_mean, sqrt(t_var), t_max);
304}
305
306/*
307 * @brief Stability performance test.
308 */
309static void bench_stability()
310{
311 const char *b = "OOOOOOOOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOXXXXXXOOOOOOOOO O";
312 char m[4];
313 Board board;
314 int i, x, v;
315 const int N_WARMUP = 1000;
316 const int N_REPEAT = 1000000;
317 unsigned long long c, overhead;
318 double t, t_mean, t_var, t_min, t_max;
319
320 board_init(&board);
321
322 x = A1;
323 c = -click();
324 for (i = 0; i < N_WARMUP; ++i) {
325 board.player &= ~x_to_bit(x);
326 board.opponent &= ~x_to_bit(x);
327 }
328 c += click();
329
330 c = -click();
331 for (i = 0; i < N_REPEAT; ++i) {
332 board.player &= ~x_to_bit(x);
333 board.opponent &= ~x_to_bit(x);
334 }
335 c += click();
336 overhead = c;
337
338 t_mean = t_var = 0.0;
339 t_max = 0;
340 t_min = 1e30;
341
342 for (x = A1; x < PASS; ++x) {
343 board_set(&board, b);
344
345 v = 0;
346 c = -click();
347 for (i = 0; i < N_WARMUP; ++i) {
348 board.player &= ~x_to_bit(x);
349 board.opponent &= ~x_to_bit(x);
350 v += get_stability(board.player, board.opponent);
351 }
352 c += click();
353
354 c = -click();
355 for (i = 0; i < N_REPEAT; ++i) {
356 board.player &= ~x_to_bit(x);
357 board.opponent &= ~x_to_bit(x);
358 v += get_stability(board.player, board.opponent);
359 }
360 c += click();
361
362 t = ((double)(c - overhead)) / N_REPEAT;
363 t_mean += t;
364 t_var += t * t;
365 if (t < t_min) t_min = t;
366 if (t > t_max) t_max = t;
367
368 if (options.verbosity >= 2) printf("v = %d\n", v);
369 if (options.verbosity >= 2) printf("stability: %s %.1f clicks;\n", move_to_string(x, WHITE, m), t);
370 }
371
372 t_mean /= x;
373 t_var = t_var / x - (t_mean * t_mean);
374
375 printf("stability: %.2f < %.2f +/- %.2f < %.2f\n", t_min, t_mean, sqrt(t_var), t_max);
376}
377
381void bench(void)
382{
383 printf("The unit of the results is CPU cycles\n");
384 bench_move_generator();
385 bench_count_last_flip();
386 bench_board_score_1();
387 bench_mobility();
388 bench_stability();
389}
390
391
392
bench
void bench(void)
perform various performance tests.
Definition bench.c:381
bench_stability
static void bench_stability()
Definition bench.c:309
bench_mobility
static void bench_mobility()
Definition bench.c:235
bench_move_generator
static void bench_move_generator()
Definition bench.c:47
bench_count_last_flip
static void bench_count_last_flip()
Definition bench.c:110
click
static unsigned long long click()
Definition bench.c:23
bench_board_score_1
static void bench_board_score_1()
Definition bench.c:172
board_get_move
unsigned long long board_get_move(const Board *board, const int x, Move *move)
Compute a move.
Definition board.c:438
get_stability
int get_stability(const unsigned long long P, const unsigned long long O)
Estimate the stability.
Definition board.c:1067
board_init
void board_init(Board *board)
Set a board to the starting position.
Definition board.c:280
get_mobility
int get_mobility(const unsigned long long P, const unsigned long long O)
Count legal moves.
Definition board.c:833
board_set
int board_set(Board *board, const char *string)
Set a board from a string description.
Definition board.c:154
SCORE_MAX
#define SCORE_MAX
Definition const.h:58
PASS
@ PASS
Definition const.h:37
A1
@ A1
Definition const.h:29
WHITE
@ WHITE
Definition const.h:43
count_last_flip
int(* count_last_flip[])(const unsigned long long)
Definition count_flip.c:1234
board_score_1
int board_score_1(const Board *board, const int beta, const int x)
Get the final score.
Definition endgame.c:96
move_to_string
char * move_to_string(const int x, const int player, char *s)
Print out a move.
Definition move.c:76
options
Options options
Definition options.c:22
Board
Definition board.h:26
Board::player
unsigned long long player
Definition board.h:27
Board::opponent
unsigned long long opponent
Definition board.h:27
Move
Definition move.h:20
Options::verbosity
int verbosity
Definition options.h:32
util.h
Miscellaneous utilities header.
cpu_clock
long long cpu_clock(void)
Generated by doxygen 1.12.0