From b8c5ea869ca80338f8b2fa6815fc92349b889750 Mon Sep 17 00:00:00 2001 From: Marco Costalba Date: Mon, 4 Feb 2013 19:48:56 +0100 Subject: [PATCH] Some renaming in split() Naming suggested by jundery. No functional change. --- src/movepick.cpp | 2 +- src/search.cpp | 8 ++++---- src/thread.cpp | 34 +++++++++++++++++----------------- src/thread.h | 6 +++--- 4 files changed, 25 insertions(+), 25 deletions(-) diff --git a/src/movepick.cpp b/src/movepick.cpp index 17516603..72601bb3 100644 --- a/src/movepick.cpp +++ b/src/movepick.cpp @@ -360,4 +360,4 @@ Move MovePicker::next_move() { /// from the split point's shared MovePicker object. This function is not thread /// safe so must be lock protected by the caller. template<> -Move MovePicker::next_move() { return ss->sp->mp->next_move(); } +Move MovePicker::next_move() { return ss->sp->movePicker->next_move(); } diff --git a/src/search.cpp b/src/search.cpp index 27669d9d..4adcefa9 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -1616,7 +1616,7 @@ void Thread::idle_loop() { // at the thread creation. So it means we are the split point's master. const SplitPoint* this_sp = splitPointsSize ? activeSplitPoint : NULL; - assert(!this_sp || (this_sp->master == this && searching)); + assert(!this_sp || (this_sp->masterThread == this && searching)); // If this thread is the master of a split point and all slaves have finished // their work at this split point, return from the idle loop. @@ -1700,11 +1700,11 @@ void Thread::idle_loop() { // Wake up master thread so to allow it to return from the idle loop // in case we are the last slave of the split point. if ( Threads.sleepWhileIdle - && this != sp->master + && this != sp->masterThread && !sp->slavesMask) { - assert(!sp->master->searching); - sp->master->notify_one(); + assert(!sp->masterThread->searching); + sp->masterThread->notify_one(); } // After releasing the lock we cannot access anymore any SplitPoint diff --git a/src/thread.cpp b/src/thread.cpp index 1a396516..7be8da88 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -147,7 +147,7 @@ void Thread::wait_for(volatile const bool& b) { bool Thread::cutoff_occurred() const { - for (SplitPoint* sp = activeSplitPoint; sp; sp = sp->parent) + for (SplitPoint* sp = activeSplitPoint; sp; sp = sp->parentSplitPoint) if (sp->cutoff) return true; @@ -258,17 +258,17 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, assert(bestValue > -VALUE_INFINITE); assert(depth >= Threads.minimumSplitDepth); - Thread* master = pos.this_thread(); + Thread* thisThread = pos.this_thread(); - assert(master->searching); - assert(master->splitPointsSize < MAX_SPLITPOINTS_PER_THREAD); + assert(thisThread->searching); + assert(thisThread->splitPointsSize < MAX_SPLITPOINTS_PER_THREAD); // Pick the next available split point from the split point stack - SplitPoint& sp = master->splitPoints[master->splitPointsSize]; + SplitPoint& sp = thisThread->splitPoints[thisThread->splitPointsSize]; - sp.master = master; - sp.parent = master->activeSplitPoint; - sp.slavesMask = 1ULL << master->idx; + sp.masterThread = thisThread; + sp.parentSplitPoint = thisThread->activeSplitPoint; + sp.slavesMask = 1ULL << thisThread->idx; sp.depth = depth; sp.bestMove = *bestMove; sp.threatMove = threatMove; @@ -276,7 +276,7 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, sp.beta = beta; sp.nodeType = nodeType; sp.bestValue = bestValue; - sp.mp = ∓ + sp.movePicker = ∓ sp.moveCount = moveCount; sp.pos = &pos; sp.nodes = 0; @@ -289,13 +289,13 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, mutex.lock(); sp.mutex.lock(); - master->splitPointsSize++; - master->activeSplitPoint = &sp; + thisThread->splitPointsSize++; + thisThread->activeSplitPoint = &sp; size_t slavesCnt = 1; // Master is always included for (size_t i = 0; i < threads.size() && !Fake; ++i) - if (threads[i]->is_available_to(master) && ++slavesCnt <= maxThreadsPerSplitPoint) + if (threads[i]->is_available_to(thisThread) && ++slavesCnt <= maxThreadsPerSplitPoint) { sp.slavesMask |= 1ULL << threads[i]->idx; threads[i]->activeSplitPoint = &sp; @@ -312,11 +312,11 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, // their work at this split point. if (slavesCnt > 1 || Fake) { - master->Thread::idle_loop(); // Force a call to base class idle_loop() + thisThread->Thread::idle_loop(); // Force a call to base class idle_loop() // In helpful master concept a master can help only a sub-tree of its split // point, and because here is all finished is not possible master is booked. - assert(!master->searching); + assert(!thisThread->searching); } // We have returned from the idle loop, which means that all threads are @@ -325,9 +325,9 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, mutex.lock(); sp.mutex.lock(); - master->searching = true; - master->splitPointsSize--; - master->activeSplitPoint = sp.parent; + thisThread->searching = true; + thisThread->splitPointsSize--; + thisThread->activeSplitPoint = sp.parentSplitPoint; pos.set_nodes_searched(pos.nodes_searched() + sp.nodes); *bestMove = sp.bestMove; diff --git a/src/thread.h b/src/thread.h index ad17e8b2..d24b65dc 100644 --- a/src/thread.h +++ b/src/thread.h @@ -63,15 +63,15 @@ struct SplitPoint { // Const data after split point has been setup const Position* pos; const Search::Stack* ss; - Thread* master; + Thread* masterThread; Depth depth; Value beta; int nodeType; Move threatMove; // Const pointers to shared data - MovePicker* mp; - SplitPoint* parent; + MovePicker* movePicker; + SplitPoint* parentSplitPoint; // Shared data Mutex mutex; -- 2.39.2