HCha/Stockfish
1
0
Fork 0
mirror of https://github.com/HChaZZY/Stockfish.git synced 2025-12-19 08:36:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Do not modify alpha in split()

Browse Source 
When calling split or we immediately return because unable to
find available slaves, or we start searching on _all_ the moves
of the node or until a cut-off occurs, so that when returning
from split we immediately leave the moves loop.

Because of this we don't need to change alpha inside split() and
we can use a signature similar to search() so to better clarify
that split() is actually a search on the remaining node's moves.

No functional change with faked split.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba
2011-08-07 09:24:40 +01:00
parent 9a542d9698
commit 5b35c149e8
3 changed files with 20 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
src/thread.cpp
View File

@@ -238,13 +238,13 @@ bool ThreadsManager::available_slave_exists(int master) const {
// call search().When all threads have returned from search() then split() returns.
template <bool Fake>
void ThreadsManager::split(Position& pos, SearchStack* ss, Value* alpha, const Value beta,
Value* bestValue, Depth depth, Move threatMove,
int moveCount, MovePicker* mp, int nodeType) {
Value ThreadsManager::split(Position& pos, SearchStack* ss, Value alpha, Value beta,
Value bestValue, Depth depth, Move threatMove,
int moveCount, MovePicker* mp, int nodeType) {
assert(pos.is_ok());
assert(*bestValue >= -VALUE_INFINITE);
assert(*bestValue <= *alpha);
assert(*alpha < beta);
assert(bestValue >= -VALUE_INFINITE);
assert(bestValue <= alpha);
assert(alpha < beta);
assert(beta <= VALUE_INFINITE);
assert(depth > DEPTH_ZERO);
assert(pos.thread() >= 0 && pos.thread() < activeThreads);
@@ -255,7 +255,7 @@ void ThreadsManager::split(Position& pos, SearchStack* ss, Value* alpha, const V
// If we already have too many active split points, don't split
if (masterThread.activeSplitPoints >= MAX_ACTIVE_SPLIT_POINTS)
return;
return bestValue;
// Pick the next available split point object from the split point stack
SplitPoint& splitPoint = masterThread.splitPoints[masterThread.activeSplitPoints];
@@ -266,10 +266,10 @@ void ThreadsManager::split(Position& pos, SearchStack* ss, Value* alpha, const V
splitPoint.is_betaCutoff = false;
splitPoint.depth = depth;
splitPoint.threatMove = threatMove;
splitPoint.alpha = *alpha;
splitPoint.alpha = alpha;
splitPoint.beta = beta;
splitPoint.nodeType = nodeType;
splitPoint.bestValue = *bestValue;
splitPoint.bestValue = bestValue;
splitPoint.mp = mp;
splitPoint.moveCount = moveCount;
splitPoint.pos = &pos;
@@ -301,12 +301,12 @@ void ThreadsManager::split(Position& pos, SearchStack* ss, Value* alpha, const V
// We failed to allocate even one slave, return
if (!Fake && !booked)
return;
return bestValue;
masterThread.activeSplitPoints++;
masterThread.splitPoint = &splitPoint;
// Tell the threads that they have work to do. This will make them leave
// Tell the threads that they have some work to do. This will make them leave
// their idle loop.
for (i = 0; i < activeThreads; i++)
if (i == master || splitPoint.is_slave[i])
@@ -328,9 +328,8 @@ void ThreadsManager::split(Position& pos, SearchStack* ss, Value* alpha, const V
idle_loop(master, &splitPoint);
// We have returned from the idle loop, which means that all threads are
// finished. Update alpha and bestValue, and return. Note that changing
// state and decreasing activeSplitPoints is done under lock protection
// to avoid a race with Thread::is_available_to().
// finished. Note that changing state and decreasing activeSplitPoints is done
// under lock protection to avoid a race with Thread::is_available_to().
lock_grab(&threadsLock);
masterThread.state = Thread::SEARCHING;
@@ -339,11 +338,10 @@ void ThreadsManager::split(Position& pos, SearchStack* ss, Value* alpha, const V
lock_release(&threadsLock);
*alpha = splitPoint.alpha;
*bestValue = splitPoint.bestValue;
pos.set_nodes_searched(pos.nodes_searched() + splitPoint.nodes);
return splitPoint.bestValue;
}
// Explicit template instantiations
template void ThreadsManager::split<false>(Position&, SearchStack*, Value*, const Value, Value*, Depth, Move, int, MovePicker*, int);
template void ThreadsManager::split<true>(Position&, SearchStack*, Value*, const Value, Value*, Depth, Move, int, MovePicker*, int);
template Value ThreadsManager::split<false>(Position&, SearchStack*, Value, Value, Value, Depth, Move, int, MovePicker*, int);
template Value ThreadsManager::split<true>(Position&, SearchStack*, Value, Value, Value, Depth, Move, int, MovePicker*, int);