Author: Robert Hyatt
Date: 10:21:09 11/18/02
Go up one level in this thread
On November 18, 2002 at 11:34:14, Uri Blass wrote:
>On November 18, 2002 at 10:50:02, Robert Hyatt wrote:
>
>>On November 18, 2002 at 09:25:37, Omid David Tabibi wrote:
>>
>>>On November 17, 2002 at 22:31:31, Robert Hyatt wrote:
>>>
>>>>On November 17, 2002 at 21:12:53, Joel wrote:
>>>>
>>>>>Hey All,
>>>>>
>>>>>Thankyou to everyone who responded to my query regarding 'extracting bits from a
>>>>>bitboard'. I think I will use some preprocessor code and use the bsf/bsr method,
>>>>>otherwise falling back on my old method (I can play around with this part
>>>>>later).
>>>>>
>>>>>My next question that follows is how do you guys measure nodes per second. I can
>>>>>think of a quite a few ways of doing it myself, but I would prefer implementing
>>>>>it in a way which lets me very confidently compare my results with others.
>>>>>
>>>>>Thanks,
>>>>>Joel
>>>>
>>>>
>>>>Every time you recursively call Search() or Quiesce(), increment a counter
>>>>by one. That is counting nodes searched. Divide that by time used and you
>>>>get a useful NPS value.
>>>
>>>But when you reach depth == 0, don't increment the node counter, since this node
>>>will be counted as a quiescence node upon calling quiesc(). (if you do, this
>>>node will be counted twice!)
>>
>>
>>Not in my code. If I enter search, that is a node. If I call quiesce, I call
>>it _from_ search
>>and _only_ after making a move. There is no way in a normal alpha/beta search
>>to enter
>>search and from there go to quiesce() without making a move. If you are doing
>>that you
>>are wasting time with an extra procedure call and its overhead...
>
>My alphabeta algorithm is the following:
>
>1)Calculate extensions or partial extensions(I have a special varaible for
>partial extension and if it is big enough I reduce it and increase depth by 1).
>2)if remaining depth=0 call qsearch
>3)while no moves left do the following
>a)makenextmove
>b)calculate alphbeta with depth-1
>c)if score>beta return beta
>d)if score>alpha alpha=score
>4)return alpha;
>
>I understand that you do it in the following way:
>
>1)while nomove left
>a)makenextmove
>b)calculate extensions
>c)call alphabeta with depth-1 or qsearch in case that depth-1=0(you do not use
>depth-1 and you have not a special varaible for partial extensions but these are
>unimportant technical details)
>d)if score<beta return beta
>e)if score>alpha alpha=score
>
>2)return alpha;
>
>Do you say that the second way is faster because you call alphabeta less times?
>How much speed improvement can a program get from it?
>
>Uri
What I said was to not do this:
int Search(alpha,beta,etc) {
if (depth==0) return Quiesce(alpha,beta,etc):
do normal search stuff
return alpha;
}
Instead, do it this way:
int Search(alpha,beta,etc) {
do normal stuff
if (depth <= 0) value=-Quiesce(-beta,-alpha,etc);
else value=-Search(-beta,-alpha,etc);
}
The first way calls search only to have it directly call quiesce(). That is
less
efficient than the second way, the way all searches I have seen actually work.
The first way calls search and wastes that overhead, and instantly calls
quiesce instead. It would have been better to directly call quiesce from the
previous search call...
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.