Johnny T wrote:
Thomas T. Veldhouse wrote:


So, doesn't bitboard manipulation significantly faster on 64-bit processors
due to the fact that a bitboard is a 64-bit word? Certainly that should
increase performance by a factor of two for such manipulations.

Often, no, because the compilers don't do anything special enough for
you here. It is more a question of cache size, speed to the stacks,
qty of stacks, and of course speed of the processor.


It isn't the compiler [assuming it compiles 64-bit targets], it is the CPU.
Working with a 64-bit word on a 32-bit CPU requires to steps instead of one.
Any compiler that compiles 64-bit targets will do this correctly.

Yes, given a good "chessie" architecture you may see a speed advantage,
but we are WAY less than 2x away from the next ply. So 2x gives you,
essentially, nothing. It can improve speed chess, but essentially you
are just lowering and lowering the amount of time that it takes to get
to xply.


I wasn't indicating a 2x performance overall, I was indicating a 2x
performance on bitboard manipulations. There is a LOT more involved in chess
programming than simple bitboard manipulations. What I want to know is how
the entire package performs; hence my question.

Unfortunately it is not going to improve the quality of either normal
controls, or overnight analysis. Because you are still too far away
that 2x isn't going to make such a difference. Nor 4x, like with the
transmeta processors. And other unix processors.


I have since done some reading and there is indication of increased
performance simply because the application can access more the 2G of RAM [my
box is 4G, so I am curious about testing this]. I think increasing the hash
table capability and faster bitboard processing ought to result in a
significant and measurable performance increase. I am hoping for a real-world
measurement of this.

Hydra and deep blue work/worked well because they were 2+ MAGNITUDES
deeper, not 2x deeper. And today computers and engines are essentially
all at the same level, about 8 moves, 16 ply (i think those are the
right numbers, we may actually be slightly deeper than that, but it
doesn't matter, because the limit is there whatever the actual number
is). That works out to about world class good move level, and no real
"mistakes". And every ply added more points and deeper (faster) was
better than smarter. But each ply is EXPONENTIALLY farther away.
Computers are not getting exponentially faster anytime soon, and for
awhile there was bunches and bucket loads of programming cleverness that
wrung every cycle of the processor in the quest for deepness. This was
hugely important while computers were slow, and it is the current state
of the art.


As I said, I didn't say anything at all about 2x deeper ... I didn't say
anything at all about ply. I said 2x increased performance in bitboard
manipulations simply because the CPU can now work with a 64-bit word natively
in one call instead of two [working with two 32-bit words instead for a 32-bit
processor].

snip

You still haven't answered my question. I am looking for real performance
measurements ... what are people seeing? Even engine versus engine match
results on Playchess would be an interested statistic for me if I knew the
hardware configuration behind it.

Thanks!

--
Thomas T. Veldhouse
Key Fingerprint: D281 77A5 63EE 82C5 5E68 00E4 7868 0ADC 4EFB 39F0