Author: Robert Hyatt
Date: 20:35:59 04/10/04
Go up one level in this thread
On April 09, 2004 at 13:03:26, Vincent Diepeveen wrote:
>On April 09, 2004 at 12:01:20, rasjid chan wrote:
>
>I completely agree with Christophe.
>
>Faster than bitboards for complex software is using my publicly posted as Gerd
>says "straightforward code" to generate moves.
>
>Without inline assembly at opteron bitboards is just dead slow.
where do you get your info? inline asm is worth less than 2% on the opteron.
Yet a single 2.2ghz cpu runs my "dead slow" program at > 2M nps.
I therefore have no idea what you are talking about...
>
>Who wants to program in assembly in the year 2004?
Some of us...
>
>>On April 09, 2004 at 10:59:45, Christophe Theron wrote:
>>
>>>On April 09, 2004 at 02:30:36, rasjid chan wrote:
>>>
>>>>
>>>>
>>>>I have a set of simple macros for bitboard operations and they are meant for
>>>>those with a new chess program and like to implement fast complete
>>>>attacks by bishops and rooks. It is basically just three #define and all sliding
>>>>attacks would then be available for use in evaluations and move ordering. Of
>>>>course it is only when we don't yet count instruction cycles,
>>>>but then after things are moving we could EASILY upgrade to
>>>>rotated bitboards.
>>>>
>>>>The only requirement is that the "all" bits must be available. Most chess
>>>>programmers sooner or later will have to use some bitboard operations as
>>>>there seem no escape for the sliding pieces and it is usually necessary to
>>>>incrementally update the "all" bits after makemove()and unmake().
>>>>
>>>>These bitboard operations just make use of simple direct intuitive
>>>>operations.If we have a single bit x, then x - 1 divides the board into
>>>>upper half and lower half and add to it some bitwise operations which
>>>>everyone say is fast. The only memory access is U64 diagonal[2][15]
>>>>and it is much better than U64 attack[64][64].
>>>>For those not using 0x88, they just need some simple editing.
>>>>
>>>>If anyone has something faster or can make them faster, please post.
>>>>
>>>>Best Regards
>>>>Rasjid
>>>>
>>>>
>>>>typedef unsigned _int64 U64
>>>>
>>>>#define GetFile64(sq) ((sq) & 7)
>>>>#define GetRank64(sq) ((sq) >> 3)
>>>>#define iGetFile(sq88) ((sq88) & 7)
>>>>#define iGetRank(sq88) ((sq88) >> 4)
>>>>#define sq88Bit(sq88) ((U64)1 << (((sq88) + ((sq88) & 7)) >> 1))
>>>>#define sq64Bit(sq64) (((U64)1) << (sq64))
>>>>#define sq88RankBits(sq88) ((U64)0xff << ((sq88) >> 1 & 0370))
>>>>#define sq88FileBits(sq88) ((U64) 0x0101010101010101 << ((sq88) & 7))
>>>>
>>>>//*** global variables
>>>>U64 all, diagonal[2][15];
>>>>
>>>>
>>>>//*** Start - bitboard attack operations for sliding pieces
>>>>
>>>>/*
>>>> This test that the in-between arc (x, y) is clear of any bits.
>>>> path is the complete bit path along x, y across the board
>>>> */
>>>>
>>>>#define brq_path_clear(x, y, path)
>>>> ((x) <= (y)
>>>> ? ((x) == (y) || isqBit(y) - 1 & ~(isqBit(x) - 1 | isqBit(x))
>>>> & (path) & all ? 0 : 1)
>>>> : (isqBit(x) - 1 & ~(isqBit(y) - 1 | isqBit(y))
>>>> & (path) & all ? 0 : 1))
>>>>
>>>>/*
>>>> given any two sq88 x, y , this test if they attack along
>>>> diagonals.
>>>> */
>>>>
>>>>#define bstyle_attack(x, y)
>>>> (iGetRank(x) + iGetFile(x) == iGetRank(y) + iGetFile(y)
>>>> ? (brq_path_clear(x, y, diagonal[1][iGetRank(x)
>>>> + iGetFile(x)]) ? 1 : 0)
>>>> : (iGetRank(x) - iGetFile(x) == iGetRank(y) - iGetFile(y)
>>>> ? (brq_path_clear(x, y, diagonal[0][7 + iGetRank(x) - iGetFile(x)])
>>>> ? 1 : 0) : 0))
>>>>
>>>>/*
>>>> given any two sq88 x, y , this test if they attack along
>>>> rank or file.
>>>> */
>>>>
>>>>#define rstyle_attack(x, y)
>>>> (iGetRank(x) == iGetRank(y)
>>>> ? (brq_path_clear(x, y, isqRankBits(x)) ? 1 : 0)
>>>> : (iGetFile(x) == iGetFile(y)
>>>> ? (brq_path_clear(x, y, isqFileBits(x)) ? 1 : 0) : 0))
>>>>
>>>>
>>>>//*** End - bitboard attack operations for sliding pieces
>>>>
>>>>
>>>> void pre_calculate_diagonal(){
>>>> int i, j, l;
>>>> //get diagonal[2][15]
>>>>
>>>>
>>>> memset(diagonal, 0, sizeof(diagonal));
>>>> //LR down == [0][7 + r - f]
>>>> //RL down == [1][r + f]
>>>>
>>>> i = 0;
>>>> while(!(i & 0x88)){
>>>> l = iGetRank(i) - iGetFile(i);
>>>> assert(7 + l >= 0 && 7 + l < 15);
>>>> for (j = i; !(j & 0x88); j += 17){
>>>> diagonal[0][7 + iGetRank(j) - iGetFile(j)] |= isqBit(j);
>>>> assert(l == iGetRank(j) - iGetFile(j));
>>>> }
>>>>
>>>> l = iGetRank(i) + iGetFile(i);
>>>> assert(l >= 0 && l < 15);
>>>> for (j = i; !(j & 0x88); j += 15){
>>>> diagonal[1][iGetRank(j) + iGetFile(j)] |= isqBit(j);
>>>> assert(l == iGetRank(j) + iGetFile(j));
>>>> }
>>>> ++i;
>>>> }
>>>>
>>>> i = 16;
>>>> while(!(i & 0x88)){
>>>> l = iGetRank(i) - iGetFile(i);
>>>> assert(7 + l >= 0 && 7 + l < 15);
>>>> for (j = i; !(j & 0x88); j += 17){
>>>> diagonal[0][7 + iGetRank(j) - iGetFile(j)] |= isqBit(j);
>>>> assert(l == iGetRank(j) - iGetFile(j));
>>>> }
>>>> i += 16;
>>>> }
>>>>
>>>> i = 23;
>>>> while(!(i & 0x88)){
>>>> l = iGetRank(i) + iGetFile(i);
>>>> assert(l >= 0 && l < 15);
>>>> for (j = i; !(j & 0x88); j += 15){
>>>> diagonal[1][iGetRank(j) + iGetFile(j)] |= isqBit(j);
>>>> assert(l == iGetRank(j) + iGetFile(j));
>>>> }
>>>> i += 16;
>>>> }
>>>> }
>>>
>>>
>>>
>>>
>>>Clearly, nothing beats the ugliness of bitboards.
>>>
>>>
>>>
>>> Christophe
>>
>>...implement fast complete attacks...
This page took 0 seconds to execute
Last modified: Thu, 15 Apr 21 08:11:13 -0700
Current Computer Chess Club Forums at Talkchess. This site by Sean Mintz.