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

Small renaming in Thread struct

Browse Source 
Should be a bit more clear the meaning of the
single variables.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba
2012-02-18 10:57:00 +01:00
parent d8349f9d0f
commit 6088ac2108
3 changed files with 18 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/search.cpp
View File

@@ -1865,7 +1865,7 @@ void Thread::idle_loop(SplitPoint* sp_master) {
lock_grab(Threads.splitLock); lock_grab(Threads.splitLock);
assert(is_searching); assert(is_searching);
SplitPoint* sp = splitPoint; SplitPoint* sp = curSplitPoint;
lock_release(Threads.splitLock); lock_release(Threads.splitLock);

26
src/thread.cpp
View File

@@ -141,7 +141,7 @@ void Thread::wait_for_stop_or_ponderhit() {
bool Thread::cutoff_occurred() const { bool Thread::cutoff_occurred() const {
for (SplitPoint* sp = splitPoint; sp; sp = sp->parent) for (SplitPoint* sp = curSplitPoint; sp; sp = sp->parent)
if (sp->cutoff) if (sp->cutoff)
return true; return true;
@@ -163,11 +163,11 @@ bool Thread::is_available_to(int master) const {
// Make a local copy to be sure doesn't become zero under our feet while // Make a local copy to be sure doesn't become zero under our feet while
// testing next condition and so leading to an out of bound access. // testing next condition and so leading to an out of bound access.
int sp_count = activeSplitPoints; int spCnt = splitPointsCnt;
// No active split points means that the thread is available as a slave for any // No active split points means that the thread is available as a slave for any
// other thread otherwise apply the "helpful master" concept if possible. // other thread otherwise apply the "helpful master" concept if possible.
return !sp_count || (splitPoints[sp_count - 1].slavesMask & (1ULL << master)); return !spCnt || (splitPoints[spCnt - 1].slavesMask & (1ULL << master));
} }
@@ -224,7 +224,7 @@ void ThreadsManager::init() {
lock_init(threads[i].sleepLock); lock_init(threads[i].sleepLock);
cond_init(threads[i].sleepCond); cond_init(threads[i].sleepCond);
for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++) for (int j = 0; j < MAX_SPLITPOINTS_PER_THREAD; j++)
lock_init(threads[i].splitPoints[j].lock); lock_init(threads[i].splitPoints[j].lock);
} }
@@ -264,7 +264,7 @@ void ThreadsManager::exit() {
lock_destroy(threads[i].sleepLock); lock_destroy(threads[i].sleepLock);
cond_destroy(threads[i].sleepCond); cond_destroy(threads[i].sleepCond);
for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++) for (int j = 0; j < MAX_SPLITPOINTS_PER_THREAD; j++)
lock_destroy(threads[i].splitPoints[j].lock); lock_destroy(threads[i].splitPoints[j].lock);
} }
@@ -313,13 +313,13 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
int master = pos.thread(); int master = pos.thread();
Thread& masterThread = threads[master]; Thread& masterThread = threads[master];
if (masterThread.activeSplitPoints >= MAX_ACTIVE_SPLIT_POINTS) if (masterThread.splitPointsCnt >= MAX_SPLITPOINTS_PER_THREAD)
return bestValue; return bestValue;
// Pick the next available split point from the split point stack // Pick the next available split point from the split point stack
SplitPoint* sp = &masterThread.splitPoints[masterThread.activeSplitPoints]; SplitPoint* sp = &masterThread.splitPoints[masterThread.splitPointsCnt];
sp->parent = masterThread.splitPoint; sp->parent = masterThread.curSplitPoint;
sp->master = master; sp->master = master;
sp->cutoff = false; sp->cutoff = false;
sp->slavesMask = 1ULL << master; sp->slavesMask = 1ULL << master;
@@ -349,7 +349,7 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
if (threads[i].is_available_to(master)) if (threads[i].is_available_to(master))
{ {
sp->slavesMask |= 1ULL << i; sp->slavesMask |= 1ULL << i;
threads[i].splitPoint = sp; threads[i].curSplitPoint = sp;
threads[i].is_searching = true; // Slave leaves idle_loop() threads[i].is_searching = true; // Slave leaves idle_loop()
if (useSleepingThreads) if (useSleepingThreads)
@@ -359,8 +359,8 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
break; break;
} }
masterThread.splitPoint = sp; masterThread.curSplitPoint = sp;
masterThread.activeSplitPoints++; masterThread.splitPointsCnt++;
lock_release(splitLock); lock_release(splitLock);
lock_release(sp->lock); lock_release(sp->lock);
@@ -380,8 +380,8 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
lock_grab(splitLock); lock_grab(splitLock);
masterThread.is_searching = true; masterThread.is_searching = true;
masterThread.activeSplitPoints--; masterThread.splitPointsCnt--;
masterThread.splitPoint = sp->parent; masterThread.curSplitPoint = sp->parent;
pos.set_nodes_searched(pos.nodes_searched() + sp->nodes); pos.set_nodes_searched(pos.nodes_searched() + sp->nodes);
lock_release(splitLock); lock_release(splitLock);

8
src/thread.h
View File

@@ -30,7 +30,7 @@
#include "search.h" #include "search.h"
const int MAX_THREADS = 32; const int MAX_THREADS = 32;
const int MAX_ACTIVE_SPLIT_POINTS = 8; const int MAX_SPLITPOINTS_PER_THREAD = 8;
struct SplitPoint { struct SplitPoint {
@@ -73,7 +73,7 @@ struct Thread {
void timer_loop(); void timer_loop();
void wait_for_stop_or_ponderhit(); void wait_for_stop_or_ponderhit();
SplitPoint splitPoints[MAX_ACTIVE_SPLIT_POINTS]; SplitPoint splitPoints[MAX_SPLITPOINTS_PER_THREAD];
MaterialInfoTable materialTable; MaterialInfoTable materialTable;
PawnInfoTable pawnTable; PawnInfoTable pawnTable;
int threadID; int threadID;
@@ -81,8 +81,8 @@ struct Thread {
Lock sleepLock; Lock sleepLock;
WaitCondition sleepCond; WaitCondition sleepCond;
ThreadHandle handle; ThreadHandle handle;
SplitPoint* volatile splitPoint; SplitPoint* volatile curSplitPoint;
volatile int activeSplitPoints; volatile int splitPointsCnt;
volatile bool is_searching; volatile bool is_searching;
volatile bool do_sleep; volatile bool do_sleep;
volatile bool do_exit; volatile bool do_exit;