perft-test: option to run perft/perft2/both

perft: normal "get_next_legal()" before movegen
perft2: is_in_check() after movegen

Makefile

@@ -89,10 +89,10 @@ CFLAGS    := -std=gnu11
 
 ### dev OR release
 # dev
-CFLAGS    += -O1
+#CFLAGS    += -O1
 #CFLAGS    += -g
 # release
-#CFLAGS    += -Ofast
+CFLAGS    += -Ofast
 
 CFLAGS    += -march=native
 CFLAGS    += -flto
@@ -100,7 +100,7 @@ CFLAGS    += -Wall
 CFLAGS    += -Wextra
 CFLAGS    += -Wmissing-declarations
 # for gprof
-CFLAGS += -pg
+#CFLAGS += -pg
 # Next one may be useful for valgrind (when invalid instructions)
 # CFLAGS += -mno-tbm
 
@@ -309,7 +309,7 @@ BB_OBJS       := $(FEN_OBJS)
 MOVEGEN_OBJS  := $(BB_OBJS) move.o move-gen.o
 ATTACK_OBJS   := $(MOVEGEN_OBJS)
 MOVEDO_OBJS   := $(ATTACK_OBJS) move-do.o
-PERFT_OBJS    := $(MOVEDO_OBJS) search.o
+PERFT_OBJS    := $(MOVEDO_OBJS) search.o misc.o
 
 TEST          := $(addprefix $(BINDIR)/,$(TEST))
 

src/chessdefs.h

@@ -134,5 +134,35 @@ typedef enum {
     NORTH_WEST = (NORTH + WEST),
 } dir_t;
 
+#include <time.h>
+
+typedef struct mclock {
+    clockid_t clocktype;
+    ulong elapsed_l;
+    double elapsed_f;
+    struct timespec start;
+} mclock_t;
+
+#define CLOCK_WALL    CLOCK_REALTIME
+#define CLOCK_SYSTEM  CLOCK_MONOTONIC_RAW
+#define CLOCK_PROCESS CLOCK_PROCESS_CPUTIME_ID
+#define CLOCK_THREAD  CLOCK_THREAD_CPUTIME_ID
+
+/**
+ * CLOCK_DEFINE - define a clock type.
+ * @name: clock name
+ * @type: clock type
+ *
+ * This macro is equivalent to:
+ *   mclock_t name;
+ *   clock_init(&name, type);
+ */
+#define CLOCK_DEFINE(name, type) struct mclock name = { .clocktype = type }
+
+void clock_init(mclock_t *clock, clockid_t type);
+void clock_start(mclock_t *clock);
+s64 clock_elapsed_μs(mclock_t *clock);
+s64 clock_elapsed_ms(mclock_t *clock);
+double clock_elapsed_sec(mclock_t *clock);
 
 #endif  /* _CHESSDEFS_H */

src/misc.c

@@ -0,0 +1,112 @@
+/* misc.c - generic/catchall functions.
+ *
+ * Copyright (C) 2024 Bruno Raoult ("br")
+ * Licensed under the GNU General Public License v3.0 or later.
+ * Some rights reserved. See COPYING.
+ *
+ * You should have received a copy of the GNU General Public License along with this
+ * program. If not, see <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
+ *
+ */
+
+#include <time.h>
+
+#include "chessdefs.h"
+
+/*
+ * 1 sec      = 1000 millisec
+ * 1 millisec = 1000 microsec
+ * 1 microsec = 1000 nanosec
+ * milli = sec * 1000 + nanosec / 1000000
+ *
+ */
+
+/* We use microsec for all intermediate calcluation */
+#define NANO_IN_MICRO  1000ll                     /* nanosecond in millisecond */
+#define MICRO_IN_SEC   1000000ll                  /* millisecond in second */
+
+#define MILLI_IN_SEC   1000ll                     /* millisecond in second */
+
+#define MICRO_IN_MILLI 1000ll
+
+//#define NANO_IN_MILLI  1000000ll                         /* nanosecond in millisecond */
+//#define NANO_IN_SEC    (NANOS_IN_MS * MS_IN_SEC)
+
+
+/**
+ * clock_start - start or restart a clock.
+ * @clock: &mclock_t clock
+ *
+ * Save current time according to @clock type.
+ */
+void clock_start(mclock_t *clock)
+{
+    clock_gettime(clock->clocktype, &clock->start);
+}
+
+/**
+ * clock_init - initializes a clock type.
+ * @clock: &mclock_t clock
+ * @type: clock type
+ *
+ * See the clock_gettime(2) for details.
+ * CLOCK_WALL (a.k.a CLOCK_REALTIME): Wall clock.
+ * CLOCK_SYSTEM (a.k.a CLOCK_MONOTONIC_RAW): System clock.
+ * CLOCK_PROCESS (a.k.a CLOCK_PROCESS_CPUTIME_ID): Process CPU clock (incl. threads).
+ * CLOCK_THREAD  (a.k.a CLOCK_THREAD_CPUTIME_ID): Thread CPU clock.
+ */
+void clock_init(mclock_t *clock, clockid_t type)
+{
+    clock->clocktype = type;
+    clock_start(clock);
+}
+
+/**
+ * clock_elapsed_μs - return a mclock_t elapsed time in microseconds.
+ * @clock: &mclock_t clock
+ *
+ * The elapsed time is calculated between current time and last clock_start(@clock)
+ * call time.
+ *
+ * @return: microseconds elapsed since last clock_start().
+ */
+s64 clock_elapsed_μs(mclock_t *clock)
+{
+    struct timespec current;
+    s64 μs;
+
+    clock_gettime(clock->clocktype, &current);
+    μs = ((s64)current.tv_sec - (s64)clock->start.tv_sec) * MICRO_IN_SEC +
+        ((s64)current.tv_nsec - (s64)clock->start.tv_nsec) / NANO_IN_MICRO ;
+    return μs;
+}
+
+/**
+ * clock_elapsed_ms - return a mclock_t elapsed time in milliseconds.
+ * @clock: &mclock_t clock
+ *
+ * The elapsed time is calculated between current time and last clock_start(@clock)
+ * call time.
+ *
+ * @return: milliseconds elapsed since last clock_start().
+ */
+s64 clock_elapsed_ms(mclock_t *clock)
+{
+    return clock_elapsed_μs(clock) / MICRO_IN_MILLI;
+}
+
+/**
+ * clock_elapsed_sec - return a mclock_t elapsed time in seconds.
+ * @clock: &mclock_t clock
+ *
+ * The elapsed time is calculated between current time and last clock_start(@clock)
+ * call time.
+ *
+ * @return: seconds elapsed since last clock_start().
+ */
+double clock_elapsed_sec(mclock_t *clock)
+{
+    return (double) clock_elapsed_μs(clock) / (double) MICRO_IN_SEC;
+}

src/move-do.h

@@ -1,6 +1,6 @@
 /* move-do.h - move do/undo.
  *
- * Copyright (C) 2021 Bruno Raoult ("br")
+ * Copyright (C) 2021-2024 Bruno Raoult ("br")
  * Licensed under the GNU General Public License v3.0 or later.
  * Some rights reserved. See COPYING.
  *

src/move.c

@@ -1,6 +1,6 @@
 /* move.c - move management.
  *
- * Copyright (C) 2021 Bruno Raoult ("br")
+ * Copyright (C) 2021-2024 Bruno Raoult ("br")
  * Licensed under the GNU General Public License v3.0 or later.
  * Some rights reserved. See COPYING.
  *

src/move.h

@@ -1,6 +1,6 @@
 /* move.h - move management.
  *
- * Copyright (C) 2021 Bruno Raoult ("br")
+ * Copyright (C) 2021-2024 Bruno Raoult ("br")
  * Licensed under the GNU General Public License v3.0 or later.
  * Some rights reserved. See COPYING.
  *

src/search.c

@@ -21,19 +21,25 @@
 #include "search.h"
 #include "attack.h"
 
-//#include "move.h"
-//#include "eval.h"
-
 /**
  * perft() - Perform perft on position
  * @pos:   &position to search
  * @depth: Wanted depth.
- * @ply:   Depth level where perft is consolidated.
+ * @ply:   perft depth level.
  *
- * Print perftCalculate the negamax value of @pos. This is an extensive search, with
- * absolutely no cutoff.
+ * Run perft on a position. This function displays the available moves at @depth
+ * level for each possible first move, and the total of moves.
  *
- * @return: The @pos negamax evaluation.
+ * This version uses the algorithm:
+ *    if last depth
+ *      return 1;
+ *    gen pseudo-legal moves
+ *    loop for each legal move
+ *      do-move
+ *      perft (depth -1)
+ *      undo-move
+ *
+ * @return: total moves found at @depth level.
  */
 u64 perft(pos_t *pos, int depth, int ply)
 {
@@ -63,10 +69,29 @@ u64 perft(pos_t *pos, int depth, int ply)
     }
 
     if (ply == 1)
-        printf("\nTotal: %lu\n", nodes);
+        printf("Total: %lu\n", nodes);
     return nodes;
 }
 
+/**
+ * perft2() - Perform perft on position
+ * @pos:   &position to search
+ * @depth: Wanted depth.
+ * @ply:   perft depth level.
+ *
+ * Run perft on a position. This function displays the available moves at @depth
+ * level for each possible first move, and the total of moves.
+ *
+ * This version uses the algorithm:
+ *    if (king in check)
+ *      finish;
+ *    if last depth
+ *      return 1;
+ *    gen pseudo-legal moves
+ *    foreach pseudo-legal move...
+ *
+ * @return: total moves found at @depth level.
+ */
 u64 perft2(pos_t *pos, int depth, int ply)
 {
     int subnodes, nmove = 0;
@@ -75,8 +100,6 @@ u64 perft2(pos_t *pos, int depth, int ply)
     move_t move;
     state_t state;
 
-    if (is_in_check(pos, OPPONENT(pos->turn)))
-        return 0;
     if (depth == 0)
         return 1;
     pos->checkers = pos_checkers(pos, pos->turn);
@@ -88,19 +111,19 @@ u64 perft2(pos_t *pos, int depth, int ply)
     for (nmove = 0; nmove < pseudo.nmoves; ++nmove ) {
         move = pseudo.move[nmove];
         move_do(pos, move);
-        //if (!is_in_check(pos, OPPONENT(pos->turn))) {
-        subnodes = perft2(pos, depth - 1, ply + 1);
-        nodes += subnodes;
-        if (ply == 1) {
-            char movestr[8];
-            printf("%s: %d\n", move_str(movestr, move, 0), subnodes);
+        if (!is_in_check(pos, OPPONENT(pos->turn))) {
+            subnodes = perft2(pos, depth - 1, ply + 1);
+            nodes += subnodes;
+            if (ply == 1) {
+                char movestr[8];
+                printf("%s: %d\n", move_str(movestr, move, 0), subnodes);
+            }
         }
-            //}
         move_undo(pos, move);
         pos->state = state;
     }
     if (ply == 1)
-        printf("\nTotal: %lu\n", nodes);
+        printf("Total: %lu\n", nodes);
     return nodes;
 }
 

test/perft-test.c

@@ -233,11 +233,17 @@ int main(int __unused ac, __unused char**av)
     //move_t move;
     FILE *outfd;
     int depth = 6;
+    s64 ms1 = 0, ms1_total = 0,  ms2 = 0, ms2_total = 0;
+    int run = 3;
 
     if (ac > 1)
         depth = atoi(av[1]);
-    printf("depth = %d\n", depth);
+    if (ac > 2)
+        run =  atoi(av[2]);
+    printf("depth = %d run=%d\n", depth, run);
 
+    if (!run)
+        exit(0);
     setlocale(LC_NUMERIC, "");
     setlinebuf(stdout);                           /* line-buffered stdout */
     outfd = open_stockfish();
@@ -245,6 +251,8 @@ int main(int __unused ac, __unused char**av)
     bitboard_init();
     hyperbola_init();
 
+
+    CLOCK_DEFINE(clock, CLOCK_PROCESS);
     while ((fen = next_fen(PERFT | MOVEDO))) {
         test_line = cur_line();
         if (!(pos = fen2pos(NULL, fen))) {
@@ -256,48 +264,46 @@ int main(int __unused ac, __unused char**av)
         savepos = pos_dup(pos);
         //int j = 0;
 
-#define NANOSEC  1000000000                       /* nano sec in sec */
-#define MILLISEC 1000000                          /* milli sec in sec */
+        if (run & 1) {
+            clock_start(&clock);
+            my_count = perft(pos, depth, 1);
+            ms1 = clock_elapsed_ms(&clock);
+            ms1_total += ms1;
 
-        // 1 sec = 1000 millisec
-        // 1 millisec = 1000 microsec
-        // 1 microsec = 1000 nanosec
-        // milli = sec * 1000 + nanosec / 1000000
-        struct timespec ts1, ts2;
-        s64 microsecs;
-
-        clock_gettime(CLOCK_MONOTONIC_RAW, &ts1);
-        my_count = perft(pos, depth, 1);
-        clock_gettime(CLOCK_MONOTONIC_RAW, &ts2);
-
-        microsecs = ((s64)ts2.tv_sec - (s64)ts1.tv_sec) * 1000000l
-            + ((s64)ts2.tv_nsec - (s64)ts1.tv_nsec) / 1000l ;
-        if (sf_count == my_count) {
-            printf("pt1 OK : line=%03d perft=%lu ms=%'ldms lps=%'lu \"%s\"\n",
-                   test_line, my_count, microsecs/1000l,
-                   my_count*1000000l/microsecs, fen);
-        } else  {
-            printf("pt1 ERR: line=%03d sf=%lu me=%lu \"%s\"\n",
-                   test_line, sf_count, my_count, fen);
+            if (sf_count == my_count) {
+                printf("pt1 OK : line=%03d perft=%lu %'ldms lps=%'lu \"%s\"\n",
+                       test_line, my_count, ms1,
+                       ms1? my_count*1000l/ms1: 0,
+                       fen);
+            } else  {
+                printf("pt1 ERR: line=%03d sf=%lu me=%lu \"%s\"\n",
+                       test_line, sf_count, my_count, fen);
+            }
         }
 
-        clock_gettime(CLOCK_MONOTONIC_RAW, &ts1);
-        my_count = perft2(pos, depth, 1);
-        clock_gettime(CLOCK_MONOTONIC_RAW, &ts2);
+        if (run & 2) {
+            clock_start(&clock);
+            my_count = perft2(pos, depth, 1);
+            ms2 = clock_elapsed_ms(&clock);
+            ms2_total += ms2;
 
-        microsecs = ((s64)ts2.tv_sec - (s64)ts1.tv_sec) * 1000000l
-            + ((s64)ts2.tv_nsec - (s64)ts1.tv_nsec) / 1000l ;
-        if (sf_count == my_count) {
-            printf("pt2 OK : line=%03d perft=%lu ms=%'ldms lps=%'lu \"%s\"\n\n",
-                   test_line, my_count, microsecs/1000l,
-                   my_count*1000000l/microsecs, fen);
-        } else  {
-            printf("pt2 ERR: line=%03d sf=%lu me=%lu \"%s\"\n\n",
-                   test_line, sf_count, my_count, fen);
+            if (sf_count == my_count) {
+                printf("pt2 OK : line=%03d perft=%lu %'ldms lps=%'lu \"%s\"\n\n",
+                       test_line, my_count, ms2,
+                       ms2? my_count*1000l/ms2: 0,
+                       fen);
+            } else  {
+                printf("pt2 ERR: line=%03d sf=%lu me=%lu \"%s\"\n\n",
+                       test_line, sf_count, my_count, fen);
+            }
         }
         pos_del(savepos);
         pos_del(pos);
         i++;
     }
+    if (run & 1)
+        printf("total perft  %'ldms\n", ms1_total);
+    if (run & 2)
+        printf("total perft2 %'ldms\n", ms2_total);
     return 0;
 }