src/testbitboard.c

   1 /**
   2
   3 Copyright (c) Scott Gasch
   4
   5 Module Name:
   6
   7     testbitboard.c
   8
   9 Abstract:
  10
  11     Unit test for the bitboard code.
  12
  13 Author:
  14
  15     Scott Gasch ([email protected]) 19 Oct 2004
  16
  17 Revision History:
  18
  19 **/
  20
  21 #ifdef TEST
  22 #include "chess.h"
  23
  24 void TestBitboards(void)
  25 /**
  26
  27 Routine description:
  28
  29     Sanity check bitboard code and benchmark the different ways to
  30     twiddle bits.
  31
  32 Parameters:
  33
  34     void
  35
  36 Return value:
  37
  38     void
  39
  40 **/
  41 {
  42     COOR c;
  43     ULONG b;
  44     BITBOARD bb;
  45     BITBOARD bbSpeed[1000];
  46     ULONG u, v, w, z;
  47     UINT64 u64;
  48
  49     Trace("Testing bitboard operations...\n");
  50
  51     //
  52     // Make a table of 1000 random bitboards
  53     //
  54     for (u = 0;
  55          u < 1000;
  56          u++)
  57     {
  58         bbSpeed[u] = 0;
  59         w = rand() % 24;
  60         for (v = 0; v < w; v++)
  61         {
  62             z = RANDOM_COOR;
  63             ASSERT(SLOWCOOR_TO_BB(z) == COOR_TO_BB(z));
  64             bb = COOR_TO_BB(z);
  65             bbSpeed[u] |= bb;
  66         }
  67     }
  68
  69 #if 1
  70     //
  71     // Various benchmaring code.
  72     //
  73     u64 = SystemReadTimeStampCounter();
  74     for (u = 0; u < 1000000; u++)
  75     {
  76         b = u % 64;
  77         bb = SLOWCOOR_TO_BB(b);
  78     }
  79     printf(" SLOWCOOR_TO_BB:   %" COMPILER_LONGLONG_UNSIGNED_FORMAT
  80            " cycles/op\n",
  81            (SystemReadTimeStampCounter() - u64) / 1000000);
  82     u64 = SystemReadTimeStampCounter();
  83     for (u = 0; u < 1000000; u++)
  84     {
  85         b = u % 64;
  86         bb = COOR_TO_BB(b);
  87     }
  88     printf(" COOR_TO_BB:       %" COMPILER_LONGLONG_UNSIGNED_FORMAT
  89            " cycles/op\n",
  90            (SystemReadTimeStampCounter() - u64) / 1000000);
  91
  92     u64 = SystemReadTimeStampCounter();
  93     for (v = 1; v < 1000; v++)
  94     {
  95         for (u = 0; u < 1000; u++)
  96         {
  97             b = SlowCountBits(bbSpeed[u]);
  98         }
  99     }
 100     printf(" SlowCountBits:    %" COMPILER_LONGLONG_UNSIGNED_FORMAT
 101            " cycles/op\n",
 102            (SystemReadTimeStampCounter() - u64) / (1000 * 1000));
 103
 104     u64 = SystemReadTimeStampCounter();
 105     for (v = 0; v < 1000; v++)
 106     {
 107         for (u = 0; u < 1000; u++)
 108         {
 109             b = CountBits(bbSpeed[u]);
 110         }
 111     }
 112     printf(" CountBits:        %" COMPILER_LONGLONG_UNSIGNED_FORMAT
 113            " cycles/op\n",
 114            (SystemReadTimeStampCounter() - u64) / (1000 * 1000));
 115
 116     u64 = SystemReadTimeStampCounter();
 117     for (v = 0; v < 1000; v++)
 118     {
 119         for (u = 0; u < 1000; u++)
 120         {
 121             b = SlowLastBit(bbSpeed[u]);
 122         }
 123     }
 124     printf(" SlowLastBit:      %" COMPILER_LONGLONG_UNSIGNED_FORMAT
 125            " cycles/op\n",
 126            (SystemReadTimeStampCounter() - u64) / (1000 * 1000));
 127
 128     u64 = SystemReadTimeStampCounter();
 129     for (v = 0; v < 1000; v++)
 130     {
 131         for (u = 0; u < 1000; u++)
 132         {
 133             b = LastBit(bbSpeed[u]);
 134         }
 135     }
 136     printf(" LastBit:          %" COMPILER_LONGLONG_UNSIGNED_FORMAT
 137            " cycles/op\n",
 138            (SystemReadTimeStampCounter() - u64) / (1000 * 1000));
 139
 140     u64 = SystemReadTimeStampCounter();
 141     for (v = 0; v < 1000; v++)
 142     {
 143         for (u = 0; u < 1000; u++)
 144         {
 145             b = SlowFirstBit(bbSpeed[u]);
 146         }
 147     }
 148     printf(" SlowFirstBit:     %" COMPILER_LONGLONG_UNSIGNED_FORMAT
 149            " cycles/op\n",
 150            (SystemReadTimeStampCounter() - u64) / (1000 * 1000));
 151
 152     u64 = SystemReadTimeStampCounter();
 153     for (v = 0; v < 1000; v++)
 154     {
 155         for (u = 0; u < 1000; u++)
 156         {
 157             b = DeBruijnFirstBit(bbSpeed[u]);
 158         }
 159     }
 160     printf(" DeBruijnFirstBit: %" COMPILER_LONGLONG_UNSIGNED_FORMAT
 161            " cycles/op\n",
 162            (SystemReadTimeStampCounter() - u64) / (1000 * 1000));
 163
 164     u64 = SystemReadTimeStampCounter();
 165     for (v = 0; v < 1000; v++)
 166     {
 167         for (u = 0; u < 1000; u++)
 168         {
 169             b = FirstBit(bbSpeed[u]);
 170         }
 171     }
 172     printf(" FirstBit:         %" COMPILER_LONGLONG_UNSIGNED_FORMAT
 173            " cycles/op\n",
 174            (SystemReadTimeStampCounter() - u64) / (1000 * 1000));
 175 #endif
 176
 177     FOREACH_SQUARE(c)
 178     {
 179         if (!IS_ON_BOARD(c)) continue;
 180
 181         if (BIT_NUMBER_TO_COOR(COOR_TO_BIT_NUMBER(c)) != c)
 182         {
 183             UtilPanic(TESTCASE_FAILURE,
 184                       NULL,
 185                       "bit number to coor / coor to bit number",
 186                       NULL,
 187                       NULL,
 188                       __FILE__, __LINE__);
 189         }
 190
 191         if (SLOW_BIT_NUMBER_TO_COOR(COOR_TO_BIT_NUMBER(c)) != c)
 192         {
 193             UtilPanic(TESTCASE_FAILURE,
 194                       NULL,
 195                       "slow bit number to coor / coor to bit number",
 196                       NULL,
 197                       NULL,
 198                       __FILE__, __LINE__);
 199         }
 200
 201         if (BIT_NUMBER_TO_COOR(COOR_TO_BIT_NUMBER(c)) !=
 202             SLOW_BIT_NUMBER_TO_COOR(COOR_TO_BIT_NUMBER(c)))
 203         {
 204             UtilPanic(TESTCASE_FAILURE,
 205                       NULL,
 206                       "bit number to coor / slow bit number to coor",
 207                       NULL,
 208                       NULL,
 209                       __FILE__, __LINE__);
 210         }
 211     }
 212
 213     for (b = 1;
 214          b < 64;
 215          b++)
 216     {
 217         if (COOR_TO_BIT_NUMBER(BIT_NUMBER_TO_COOR(b)) != (b))
 218         {
 219             UtilPanic(TESTCASE_FAILURE,
 220                       NULL,
 221                       "coor to bit number / bit number to coor",
 222                       NULL,
 223                       NULL,
 224                       __FILE__, __LINE__);
 225         }
 226     }
 227
 228     bb = COOR_TO_BB(A4);
 229     bb |= COOR_TO_BB(A6);
 230     bb |= COOR_TO_BB(A8);
 231     bb |= COOR_TO_BB(B6);
 232     bb |= COOR_TO_BB(H2);
 233     if (CountBits(bb) != 5)
 234     {
 235         UtilPanic(TESTCASE_FAILURE,
 236                   NULL, "CountBits", NULL, NULL,
 237                   __FILE__, __LINE__);
 238     }
 239     bb &= BBFILE[A];
 240     if (CountBits(bb) != 3)
 241     {
 242         UtilPanic(TESTCASE_FAILURE,
 243                   NULL, "CountBits", NULL, NULL,
 244                   __FILE__, __LINE__);
 245     }
 246     b = 0;
 247     while(IS_ON_BOARD(c = CoorFromBitBoardRank8ToRank1(&bb)))
 248     {
 249         b++;
 250         if ((c != A4) && (c != A6) && (c != A8))
 251         {
 252             UtilPanic(TESTCASE_FAILURE,
 253                       NULL, "CoorFromBitBoardRank8ToRank1", NULL, NULL,
 254                       __FILE__, __LINE__);
 255         }
 256     }
 257
 258     if (b != 3)
 259     {
 260         UtilPanic(TESTCASE_FAILURE,
 261                   NULL, "CoorFromBitBoardRank8ToRank1", NULL, NULL,
 262                   __FILE__, __LINE__);
 263     }
 264
 265     bb = SLOWCOOR_TO_BB(A4) | SLOWCOOR_TO_BB(H2);
 266     bb |= SLOWCOOR_TO_BB(D4) | SLOWCOOR_TO_BB(F6) | SLOWCOOR_TO_BB(F4);
 267     if (CountBits(bb) != 5)
 268     {
 269         UtilPanic(TESTCASE_FAILURE,
 270                   NULL, "CountBits", NULL, NULL,
 271                   __FILE__, __LINE__);
 272     }
 273     bb &= BBRANK[4];
 274     if (CountBits(bb) != 3)
 275     {
 276         UtilPanic(TESTCASE_FAILURE,
 277                   NULL, "CountBits", NULL, NULL,
 278                   __FILE__, __LINE__);
 279     }
 280     b = 0;
 281     while(IS_ON_BOARD(c = CoorFromBitBoardRank1ToRank8(&bb)))
 282     {
 283         b++;
 284         if ((c != A4) && (c != D4) && (c != F4))
 285         {
 286             UtilPanic(TESTCASE_FAILURE,
 287                       NULL, "CoorFromBitBoardRank1ToRank8", NULL, NULL,
 288                       __FILE__, __LINE__);
 289         }
 290     }
 291
 292     if (b != 3)
 293     {
 294         UtilPanic(TESTCASE_FAILURE,
 295                   NULL, "CoorFromBitBoardRank1ToRank8", NULL, NULL,
 296                   __FILE__, __LINE__);
 297     }
 298 }
 299 #endif