From: Marco Costalba Date: Sun, 7 Aug 2011 08:24:40 +0000 (+0100) Subject: Do not modify alpha in split() X-Git-Url: https://git.sesse.net/?p=stockfish;a=commitdiff_plain;h=5b35c149e833e365c2afb8039ca5c658abc53081 Do not modify alpha in split() 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 --- diff --git a/src/search.cpp b/src/search.cpp index d06ca8f3..b39bc176 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -1228,8 +1228,8 @@ split_point_start: // At split points actual search starts from here && Threads.available_slave_exists(pos.thread()) && !StopRequest && !thread.cutoff_occurred()) - Threads.split(pos, ss, &alpha, beta, &bestValue, depth, - threatMove, moveCount, &mp, NT); + bestValue = Threads.split(pos, ss, alpha, beta, bestValue, depth, + threatMove, moveCount, &mp, NT); } // Step 20. Check for mate and stalemate diff --git a/src/thread.cpp b/src/thread.cpp index 5d2b39f5..e1330396 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -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 -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(Position&, SearchStack*, Value*, const Value, Value*, Depth, Move, int, MovePicker*, int); -template void ThreadsManager::split(Position&, SearchStack*, Value*, const Value, Value*, Depth, Move, int, MovePicker*, int); +template Value ThreadsManager::split(Position&, SearchStack*, Value, Value, Value, Depth, Move, int, MovePicker*, int); +template Value ThreadsManager::split(Position&, SearchStack*, Value, Value, Value, Depth, Move, int, MovePicker*, int); diff --git a/src/thread.h b/src/thread.h index 1e92b776..6ee07d34 100644 --- a/src/thread.h +++ b/src/thread.h @@ -115,8 +115,8 @@ public: void idle_loop(int threadID, SplitPoint* sp); template - void split(Position& pos, SearchStack* ss, Value* alpha, const Value beta, Value* bestValue, - Depth depth, Move threatMove, int moveCount, MovePicker* mp, int nodeType); + Value split(Position& pos, SearchStack* ss, Value alpha, Value beta, Value bestValue, + Depth depth, Move threatMove, int moveCount, MovePicker* mp, int nodeType); private: Thread threads[MAX_THREADS]; Lock threadsLock;