Speedup with bitboards on 64-bit CPUs

Discussion of chess software programming and technical issues.

Moderators: bob, hgm, Harvey Williamson

Forum rules
This textbox is used to restore diagrams posted with the [d] tag before the upgrade.
Gerd Isenberg
Posts: 2127
Joined: Wed Mar 08, 2006 7:47 pm
Location: Hattingen, Germany

Re: post gone??

Post by Gerd Isenberg » Wed May 02, 2007 6:08 pm

hgm wrote:Depending on how you obtain that prior knowledge, you might arrange it such that it is also guaranteed that sq1 and sq2 are not neighboring squares on an anti-diagonal either, as in that case there are no in-between squares anyway. There is thus no reason to treat it differently from cases where sq1 and sq2 are not aligned on a ray. The disambiguation of that and the same-rank case would then no longer be needed.

Also here the 'rotate' instructions could be useful, as you don't rely on bits being clipped off as the tabulated templates are shifted in position. That would save you ordering the squares. You would need twice as large a table, though.
Sounds great, you mean something like this?

Code: Select all

u64 inbetweenBySignedDiff[2*64];

u64 inBetweenWithDistanceGr1(u32 sq1, u32 sq2)
{
    return _rotl64(inbetweenBySignedDiff[sq2-sq1+64], sq1);
} 

sub rdx, rcx ; sq2-sq1
mov rax, [...+64*8+edx*8]
rol rax, cl
But assuming there is no prior knowledge related to sq1, sq2, like a condition if distance(sq1,sq2) > 1 or the ray-type (rank, file, (anti-)diagonal), it becomes hard to use the rotate trick, due to the +-7 ambiguity. For instance to check (pseudo-)legality of queen-moves like Qh4-a4 or Qh4-g5.

The ambiguity disappears with 0x88-coordiates and one more double sized array...

Code: Select all

u64 inbetweenBy0x88Diff[2*2*64];

u64 inBetweenWithDistanceGr1(u32 sq1, u32 sq2)
{
    return _rotl64(inbetweenBySignedDiff[sq2+(sq2&56)-sq1-(sq1&56)+127], sq1);
} 
... and it looks like a good compromize, specially if you already have 0x88.

Tord Romstad
Posts: 1808
Joined: Wed Mar 08, 2006 8:19 pm
Location: Oslo, Norway

Re: Speedup with bitboards on 64-bit CPUs

Post by Tord Romstad » Fri May 11, 2007 8:16 am

Tord Romstad wrote:I've been using bitboards for a while, and I am somewhat disappointed with the performance. On my 32-bit Core Duo, they are about 20-30% slower than my old mailbox board, it is therefore tempting to revert to the old board representation. Before I do so, I would like to know: How much of a speedup do bitboard programs usually see when running on a 64-bit CPU? Can I expect bitboards to be competitive with a mailbox board for my program if I upgrade to the 64-bit Core 2 Duo?
Now I know the answer to these questions for my own engine: The recently released Glaurung 2-ε/2 gains about 30% in 64-bit mode. This means that bitboards should be just as fast as mailbox for Glaurung on 64-bit machines, at least until I add king safety, which I still have no idea how to do with bitboards.

I'll keep using bitboards a bit longer.

Tord

diep
Posts: 1780
Joined: Thu Mar 09, 2006 10:54 pm
Location: The Netherlands
Contact:

Re: Speedup with bitboards on 64-bit CPUs

Post by diep » Sat May 19, 2007 5:20 pm

CRoberson wrote:Telepath (bitboard) is slower than NoonianChess in NPS by about 2x using a 32 bit complier (g++) for both on a Core2Duo and an AMD 4400+.
Both machines using a 32 bit version of windows.

When I went to the newer version of MSVC, Telepath gained a 33% speedup and it still was a 32 bit compile running on a 32 bit OS.

When I recompiled Telepath with g++ (64 bit version) and ran on the AMD with a 64 bit version of Linux, Telepath was 20% faster than NoonianChess was.

Telepath is bitboard (nonrotated) and NoonianChess uses a 64 element array and two piecelists.
Try using THIS datastructure & move generator for noonianchess and you kick the hell out of your bitboard program with a MORE generic approach:

Code: Select all

/*
Gnu public license here.
See copy of it at FSF (free software foundation)
*/

const int
 nunmap[144] = {
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1,  0,  1,  2,  3,  4,  5,  6,  7, -1, -1,
  -1, -1,  8,  9, 10, 11, 12, 13, 14, 15, -1, -1,
  -1, -1, 16, 17, 18, 19, 20, 21, 22, 23, -1, -1,
  -1, -1, 24, 25, 26, 27, 28, 29, 30, 31, -1, -1,
  -1, -1, 32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
  -1, -1, 40, 41, 42, 43, 44, 45, 46, 47, -1, -1,
  -1, -1, 48, 49, 50, 51, 52, 53, 54, 55, -1, -1,
  -1, -1, 56, 57, 58, 59, 60, 61, 62, 63, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
 };


int
  color[64], // having 0 = white, 1 = black, 2 = neutral
  board[64], // having 0 = empty, pawn=1,knight=2,bishop=3,rook=4,queen=5,king=6
  snelbord[64], // for white same as board[64], for black same as white but with a +8 for each piece
                // like whitepawn = 1, blackpawn = 9


  gentable[3][64][128], //* 24k loper, toren, dame *
  iskippos[64][64],     /*      l t d */
  ipiecepos[7][64][32], /* 0 = witte pion, 1 = zwarte pion, 2 = knight ... 6 = koning */
  ipawndir[2][64][4];   /* slagzetten */


void QuickFullMoveList(int side,struct Move *EP) {
/* Generate semi-legal moves in fast manner
*/
  int to,xside,*psq,sq,*t;

  xside = side^1;
  to    = EP->zet&63;
  if( board[to] == pawn ) { /* for enpassant */
    int from = (EP->zet>>6)&63;
    if( to-from == 16 || from-to == 16 ) {
      int f,*w,u;
      f = (to+from)>>1;
      w = ipawndir[xside][f];
      u = *w++;
      if( color[u] == side && board[u] == pawn ) {
        genindex->score = 1000;
        QuickLink&#40;&#40;u<<6&#41;|f|move_captures|move_enpassant&#41;;
      &#125;

      if&#40; &#40;u=*w&#41; != 128 && color&#91;u&#93; == side && board&#91;u&#93; == pawn ) &#123;
        genindex->score = 1000;
        QuickLink&#40;&#40;u<<6&#41;|f|move_captures|move_enpassant&#41;;
      &#125;
    &#125;
  &#125;

  if&#40; !castld&#91;side&#93; ) &#123;
    int u = PieceList&#91;side&#93;&#91;0&#93;;
    if&#40; quickcastle&#40;side,u,u+2&#41; ) &#123;
      genindex->score = 0;
      QuickLink&#40;&#40;u<<6&#41;|&#40;u+2&#41;|move_castles&#41;;
    &#125;
    if&#40; quickcastle&#40;side,u,u-2&#41; ) &#123;
      genindex->score = 0;
      QuickLink&#40;&#40;u<<6&#41;|&#40;u-2&#41;|move_castles&#41;;
    &#125;
  &#125;

  t    = cancapside&#91;side&#93;;
  psq  = &quickpiecelist&#91;side&#93;&#91;12&#93;; /* Q R B */
  while&#40; &#40;sq=*psq++) != 128 ) &#123;
    int SRsq  = &#40;sq<<6&#41;;
    int piece = board&#91;sq&#93;;
    int *s,*v,*w,u;

    s = andscan&#91;0&#93;;
    v = ipiecepos&#91;piece&#93;&#91;sq&#93;;
    w = iskippos&#91;sq&#93;;
    u = *v++;
    do &#123;
      int p1=snelbord&#91;u&#93;,sh=w&#91;u&#93;;
      v += &#40;s&#91;p1&#93;&sh&#41;;
      if&#40; (&#40;p1-1&#41;>>3&#41; != side ) &#123;
        genindex->score = pvals&#91;p1&#93;;
        QuickLink&#40;SRsq|u|t&#91;p1&#93;);
      &#125;
    &#125; while&#40; &#40;u=*v++) != 128 );
  &#125;

  psq  = &quickpiecelist&#91;side&#93;&#91;26&#93;; /* pawns */
  while&#40; &#40;sq=*psq++) != 128 ) &#123;
    int SRsq  = &#40;sq<<6&#41;;
    int u,*v,*w;
    v = ipiecepos&#91;side&#93;&#91;sq&#93;;
    w = ipawndir&#91;side&#93;&#91;sq&#93;;
    u = *v++;
    if&#40; row&#40;u&#41; != 0 && row&#40;u&#41; != 7 ) &#123;
      if&#40; color&#91;u&#93; == neutral&#41; &#123;
        genindex->score = 0;
        QuickLink&#40;SRsq|u&#41;;
        if&#40; &#40;u=*v&#41; != 128 && color&#91;u&#93; == neutral ) &#123; /* indien u == sq dan false */
          genindex->score = 0;
          QuickLink&#40;SRsq|u&#41;;
        &#125;
      &#125;

      u = *w++;
      if&#40; color&#91;u&#93; == xside ) &#123; /* ppos bevat geen 100, maar sq. */
        genindex->score = pvals&#91;snelbord&#91;u&#93;&#93;;
        QuickLink&#40;SRsq|u|move_captures&#41;;
      &#125;
      if&#40; &#40;u=*w&#41; != 128 && color&#91;u&#93; == xside ) &#123; /* zelf ben je per definitie side */
        genindex->score = pvals&#91;snelbord&#91;u&#93;&#93;;
        QuickLink&#40;SRsq|u|move_captures&#41;;
      &#125;
    &#125;
    else &#123;
      if&#40; color&#91;u&#93; == neutral&#41; &#123;
        genindex->score = pvals&#91;queen&#93;;
        QuickLink&#40;SRsq|u|move_pqueen&#41;;
        genindex->score = 0;
        QuickLink&#40;SRsq|u|move_pknight&#41;;
        genindex->score = 0;
        QuickLink&#40;SRsq|u|move_prook&#41;;
        genindex->score = 0;
        QuickLink&#40;SRsq|u|move_pbishop&#41;;
      &#125;
      u = *w++;
      if&#40; color&#91;u&#93; == xside&#41; &#123;/* captures */
        genindex->score = pvals&#91;queen&#93;;
        QuickLink&#40;SRsq|u|move_captures|move_pqueen&#41;;
        genindex->score = 0;
        QuickLink&#40;SRsq|u|move_captures|move_pknight&#41;;
        genindex->score = 0;
        QuickLink&#40;SRsq|u|move_captures|move_prook&#41;;
        genindex->score = 0;
        QuickLink&#40;SRsq|u|move_captures|move_pbishop&#41;;
      &#125;

      if&#40; &#40;u=*w&#41; != 128 && color&#91;u&#93; == xside&#41; &#123;
        genindex->score = pvals&#91;queen&#93;;
        QuickLink&#40;SRsq|u|move_captures|move_pqueen&#41;;
        genindex->score = 0;
        QuickLink&#40;SRsq|u|move_captures|move_pknight&#41;;
        genindex->score = 0;
        QuickLink&#40;SRsq|u|move_captures|move_prook&#41;;
        genindex->score = 0;
        QuickLink&#40;SRsq|u|move_captures|move_pbishop&#41;;
      &#125;
    &#125;
  &#125;

  psq = quickpiecelist&#91;side&#93;; /* K N */
  while&#40; &#40;sq=*psq++) != 128 ) &#123;
    int SRsq  = &#40;sq<<6&#41;;
    int piece = board&#91;sq&#93;;

    int u,*v;
    v = ipiecepos&#91;piece&#93;&#91;sq&#93;;
    u = *v++;
    do &#123;
      int p1 = snelbord&#91;u&#93;;
      if&#40; (&#40;p1-1&#41;>>3&#41; != side ) &#123;
        genindex->score = pvals&#91;p1&#93;;
        QuickLink&#40;SRsq|u|t&#91;p1&#93;);
      &#125;
    &#125; while&#40; &#40;u=*v++) != 128 );
  &#125;

&#125; /* End QuickFullMoveList&#40;) */

void InitGens&#40;void&#41; &#123;
  /* vul tabellen voor een 8x8 bord */
  int
    paardspring&#91;8&#93;  = &#123;15,-15,17,-17,6,-6,10,-10&#125;,
    koningvlucht&#91;8&#93; = &#123;7,-7,9,-9,8,-8,1,-1&#125;,
    alldirec&#91;3&#93;&#91;8&#93;  = &#123; /* delta richtingen op een 8x8 bord */
      &#123;7,-7,9,-9,0,0,0,0&#125;,
      &#123;8,-8,1,-1,0,0,0,0&#125;,
      &#123;7,-7,9,-9,8,-8,1,-1&#125;
    &#125;,
    nsq,sq,flag,i,j,next_sq,rij,piece,np,lijn,m,ms,c,t,old_sq,
    skipm&#91;16&#93;,
    rij8&#91;2&#93;      = &#123;7,0&#125;,
    rij2&#91;2&#93;      = &#123;1,6&#125;,
    slalinks&#91;2&#93;  = &#123;7,-9&#125;,
    slarechts&#91;2&#93; = &#123;9,-7&#125;,
    veuren&#91;2&#93;    = &#123;8,-8&#125;,

    /* 12x12 bord delta-coordinaten */
    numberpiece&#91;3&#93; = &#123;bishop,rook,queen&#125;,
    numberfields&#91;3&#93; = &#123;4,4,8&#125;,
    direc&#91;3&#93;&#91;10&#93; = &#123; /* richtingen op een 12x12 bord */
     &#123;11,-11,13,-13,0,0,0,0,0,0&#125;, /* loper */
     &#123;12,-12,1 ,-1 ,0,0,0,0,0,0&#125;, /* toren */
     &#123;11,-11,13,-13,12,-12,1 ,-1,0,0&#125;  /* dame */
    &#125;,
    vlucht&#91;8&#93; = &#123;11,-11,13,-13,12,-12,1 ,-1&#125;, /* koning */
    spring&#91;8&#93; = &#123;23,-23,25,-25,10,-10,14,-14&#125;;/* paard */

  for&#40; sq = 0 ; sq < 64 ; sq++ )
    for&#40; m = 0 ; m < 64 ; m++ )
      iskippos&#91;sq&#93;&#91;m&#93; = 0;

  for&#40; i = 0 ; i < 7 ; i++ ) /* default value */
    for&#40; sq = 0 ; sq < 64 ; sq++ )
      for&#40; m = 0 ; m < 32 ; m++ )
        ipiecepos&#91;i&#93;&#91;sq&#93;&#91;m&#93; = 128;

  /* pionnen */
  for&#40; sq = 0 ; sq < 64 ; sq++ ) &#123;
    lijn = sq&7;
    rij  = sq/8;
    nsq  = 26 + rij*12 + lijn;

    for&#40; c = white ; c <= black ; c++ ) &#123; /* pion&#58; wit en zwart */
      if&#40; rij == rij8&#91;c&#93; )
        ipawndir&#91;c&#93;&#91;sq&#93;&#91;0&#93; = 128;
      else &#123;
        m = 0;
        if&#40; lijn != 7 ) &#123;
          ipawndir&#91;c&#93;&#91;sq&#93;&#91;m&#93; = &#40;sq+slarechts&#91;c&#93;);
          m++;
        &#125;
        if&#40; lijn != 0 ) &#123;
          ipawndir&#91;c&#93;&#91;sq&#93;&#91;m&#93; = &#40;sq+slalinks&#91;c&#93;);
          m++;
        &#125;
        ipawndir&#91;c&#93;&#91;sq&#93;&#91;m&#93; = 128;

        m = 0;
        ipiecepos&#91;c&#93;&#91;sq&#93;&#91;m&#93; = &#40;sq+veuren&#91;c&#93;);
        m++;
        if&#40; rij == rij2&#91;c&#93; )
          ipiecepos&#91;c&#93;&#91;sq&#93;&#91;m&#93; = &#40;sq+2*veuren&#91;c&#93;);
      &#125;
    &#125;

    m = 0;
    old_sq = sq;
    for&#40; i = 0; i < 8; i++ ) &#123;/* paard */
      t = nsq+spring&#91;i&#93;;
      if&#40; nunmap&#91;t&#93; >=  0 ) &#123;
        ipiecepos&#91;knight&#93;&#91;sq&#93;&#91;m&#93; = nunmap&#91;t&#93;;
        m++;
        old_sq = nunmap&#91;t&#93;;
      &#125;
    &#125;
    ipiecepos&#91;knight&#93;&#91;sq&#93;&#91;m&#93; = 128;

    m = 0;
    old_sq = sq;
    for&#40; i = 0; i < 8; i++ ) &#123; /* koning */
      t = nsq+vlucht&#91;i&#93;;
      if&#40; nunmap&#91;t&#93; >=  0 ) &#123;
        ipiecepos&#91;king&#93;&#91;sq&#93;&#91;m&#93; = nunmap&#91;t&#93;;
        m++;
        old_sq = nunmap&#91;t&#93;;
      &#125;
    &#125;
    ipiecepos&#91;king&#93;&#91;sq&#93;&#91;m&#93; = 128;

    for&#40; np = 0 ; np < 3 ; np++ ) &#123; /* loper,toren,dame */
      piece = numberpiece&#91;np&#93;;
      m = 0;
      ms = 0;
      flag = 0;

      j = 0;
      while&#40; nunmap&#91;nsq+direc&#91;np&#93;&#91;j&#93;&#93; == -1 )
        j++;

      for&#40; i = 0; i < numberfields&#91;np&#93;; i++ ) &#123; /* voor alle richtingen */
        int sqdone=0;

        t = nsq;
        t = t+direc&#91;np&#93;&#91;i&#93;;

        j = i+1;
        while&#40; nunmap&#91;nsq+direc&#91;np&#93;&#91;j&#93;&#93; == -1 )
          j++;
        next_sq = nunmap&#91;nsq+direc&#91;np&#93;&#91;j&#93;&#93;;

        while&#40; nunmap&#91;t&#93; != -1 ) &#123;
          sqdone++;
          ipiecepos&#91;piece&#93;&#91;sq&#93;&#91;m&#93; = nunmap&#91;t&#93;;

          m++;
          t = t+direc&#91;np&#93;&#91;i&#93;;
          flag = 1;
        &#125;

        if&#40; sqdone >= 2 && np <= 1 ) &#123;
          /* alleen als er bij from-to daarna nog velden af
           * te gaan zijn dan is het interessant. Anders 0.
           * Dame hoeft niet want toren,loper al gedaan */
          int my12sq/*,yesdeze=false*/;
          /* begonnen met  nsq &#40;12x12&#41; + delta &#40;direc&#91;np&#93;&#91;i&#93;)
           * */

          my12sq = nsq+direc&#91;np&#93;&#91;i&#93;;
          do &#123;
            /* 8x8 bord opslaan */
            sqdone--;
            my12sq += direc&#91;np&#93;&#91;i&#93;;
          &#125; while&#40; sqdone >= 2 );
        &#125;

        if&#40; flag ) &#123;
          flag = 0;
          skipm&#91;ms&#93; = m;
          ms++;
        &#125;
      &#125;
      ipiecepos&#91;piece&#93;&#91;sq&#93;&#91;m&#93; = 128;

      m  = 0;
      ms = 0;
      t  = ipiecepos&#91;piece&#93;&#91;sq&#93;&#91;m&#93;;
      if&#40; np == 2 ) &#123; /* skippos alleen voor de dame vullen dat is genoeg */
        do &#123;
          iskippos&#91;sq&#93;&#91;t&#93; = &#40;skipm&#91;ms&#93;-m&#41;-1;
          m++;
          t = ipiecepos&#91;piece&#93;&#91;sq&#93;&#91;m&#93;;
          if&#40; m == skipm&#91;ms&#93; )
            ms++;
        &#125; while&#40; t != 128 );
      &#125;
    &#125;
  &#125;
&#125;
This is far faster at a K7 than crafty at a 64 bits chip.

Of course you no longer lose time to 'optimizing' the datastructure when using this and you can use all your time to improve your program algorithmically. Most bitboarders are IMHO 99% of their time busy improving small tiny subroutines of their engine in order to get bitboards faster or fixing bugs as a result of the complex overview you have at bitboards.

Keep a generic datastructure like the above one and kick butt!

Vincent

bob
Posts: 20557
Joined: Mon Feb 27, 2006 6:30 pm
Location: Birmingham, AL

Re: Speedup with bitboards on 64-bit CPUs

Post by bob » Mon May 21, 2007 5:34 pm

<sigh>

comments from someone who knows little about bitboards doesn't provide much useful information...

Tony Thomas

Re: Speedup with bitboards on 64-bit CPUs

Post by Tony Thomas » Mon May 21, 2007 5:40 pm

diep wrote:[This is far faster at a K7 than crafty at a 64 bits chip.

Vincent
Ofcourse, you can say anything you want because we have no way of testing Crafty against your engine. May be you and Hyatt should do a 100 game online match at ICC at a decent time control.

bob
Posts: 20557
Joined: Mon Feb 27, 2006 6:30 pm
Location: Birmingham, AL

Re: Speedup with bitboards on 64-bit CPUs

Post by bob » Mon May 21, 2007 9:47 pm

Tony Thomas wrote:
diep wrote:[This is far faster at a K7 than crafty at a 64 bits chip.

Vincent
Ofcourse, you can say anything you want because we have no way of testing Crafty against your engine. May be you and Hyatt should do a 100 game online match at ICC at a decent time control.
The statement makes no sense. That implies that most of the work done in the engine is move generation. In my code it is under 10%. Bitboards have nice properties for other parts of the game, like the evaluation... So replacing the move generator means very little, if anything... And it even overlooks some important move generation details such as how often we want to just generate captures, which a mailbox approach has problems doing efficiently.

diep
Posts: 1780
Joined: Thu Mar 09, 2006 10:54 pm
Location: The Netherlands
Contact:

Re: Speedup with bitboards on 64-bit CPUs

Post by diep » Sat May 26, 2007 7:21 pm

bob wrote:
Tony Thomas wrote:
diep wrote:[This is far faster at a K7 than crafty at a 64 bits chip.

Vincent
Ofcourse, you can say anything you want because we have no way of testing Crafty against your engine. May be you and Hyatt should do a 100 game online match at ICC at a decent time control.
The statement makes no sense. That implies that most of the work done in the engine is move generation. In my code it is under 10%. Bitboards have nice properties for other parts of the game, like the evaluation... So replacing the move generator means very little, if anything... And it even overlooks some important move generation details such as how often we want to just generate captures, which a mailbox approach has problems doing efficiently.
And you really put in a lot of time in your evaluation function didn't you?
You really are THE GREAT EXPERT on evaluation.

Vincent

bob
Posts: 20557
Joined: Mon Feb 27, 2006 6:30 pm
Location: Birmingham, AL

Re: Speedup with bitboards on 64-bit CPUs

Post by bob » Sun May 27, 2007 9:41 pm

diep wrote:
bob wrote:
Tony Thomas wrote:
diep wrote:[This is far faster at a K7 than crafty at a 64 bits chip.

Vincent
Ofcourse, you can say anything you want because we have no way of testing Crafty against your engine. May be you and Hyatt should do a 100 game online match at ICC at a decent time control.
The statement makes no sense. That implies that most of the work done in the engine is move generation. In my code it is under 10%. Bitboards have nice properties for other parts of the game, like the evaluation... So replacing the move generator means very little, if anything... And it even overlooks some important move generation details such as how often we want to just generate captures, which a mailbox approach has problems doing efficiently.
And you really put in a lot of time in your evaluation function didn't you?
You really are THE GREAT EXPERT on evaluation.

Vincent
Didn't think you were capable of comprehending that, so I'm not surprised.

But once again, in the hope that one day it will sink in, not _every_ program is compute-bound by the move generator. But for typical programs, bitboard move generation is just as efficient as what you do, when you factor in the problem of generating captures-only for the q-search, something that is extremely efficient to a bitboarder but not to a mailbox approach. So while you might be a bit faster in generating _all_ moves, you won't be as fast generating just captures, and for my program, that happens _far_ more frequently.

But all that is moot when I spend less than 10% of my total search time generating moves. Doesn't matter how good/bad my evaluation is (and if yours is great, mine must be pretty good based on past results against your program) I still spend far more time there than I do generating moves.

Now why don't you try talking about something you know something about and quit trying to explain why bitboards are so bad, when you don't even understand how they work...

Chan Rasjid
Posts: 567
Joined: Thu Mar 09, 2006 3:47 pm
Location: Singapore

Re: Speedup with bitboards on 64-bit CPUs

Post by Chan Rasjid » Mon May 28, 2007 7:29 am

Hello,
But once again, in the hope that one day it will sink in, ....
Vasik Rajlich has become sort of Jesus Christ in computer chess, Osipov has become sort of Son of Jesus Christ in computer chess and Sergei Markoff is very like St. Peter...If after the appearance of sort of Messiah preaching the Gospel of Bitboards in computer chess and things don't sink in, it never will.

But it is still better that Vincent comes back from retirement as St.George without the Dragon don't an epic make.
So while you might be a bit faster in generating _all_ moves, you won't be as fast generating just captures, and for my program, that happens _far_ more frequently.
I'm not sure your statistic is correct here as my QS nodes is about average 30-40%

Rasjid
Don't believe when you're told "There's no free lunch!" There is Linux.

Tony Thomas

Re: Speedup with bitboards on 64-bit CPUs

Post by Tony Thomas » Mon May 28, 2007 9:04 pm

Chan Rasjid wrote:Hello,
But once again, in the hope that one day it will sink in, ....
Vasik Rajlich has become sort of Jesus Christ in computer chess, Osipov has become sort of Son of Jesus Christ in computer chess and Sergei Markoff is very like St. Peter...If after the appearance of sort of Messiah preaching the Gospel of Bitboards in computer chess and things don't sink in, it never will.

But it is still better that Vincent comes back from retirement as St.George without the Dragon don't an epic make.
So while you might be a bit faster in generating _all_ moves, you won't be as fast generating just captures, and for my program, that happens _far_ more frequently.
I'm not sure your statistic is correct here as my QS nodes is about average 30-40%

Rasjid
So does that mean all of you programmers are either brothers or that all of you are desciples of jesus? Why not Mohammed of computer chess? Or the Allah of algorithms? You wouldnt compare Vincent to Judas would you?

Post Reply