kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-30 16:53:09 +00:00
Code Issues Releases Wiki Activity

Rename available_to()

Browse source 
Change this API to be more natural and simple.

Inspired by a patch by Joona.

No functional change.
This commit is contained in:
Marco Costalba 2015-03-01 12:13:14 +01:00
parent 0da7295795
commit 63a5fc2366
3 changed files with 16 additions and 17 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/search.cpp
View file

@ -1593,7 +1593,7 @@ void Thread::idle_loop() {
if ( sp if ( sp
&& sp->allSlavesSearching && sp->allSlavesSearching
&& sp->slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT && sp->slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT
&& available_to(sp->master)) && can_join(sp))
{ {
assert(this != th); assert(this != th);
assert(!(this_sp && this_sp->slavesMask.none())); assert(!(this_sp && this_sp->slavesMask.none()));
@ -1623,7 +1623,7 @@ void Thread::idle_loop() {
if ( sp->allSlavesSearching if ( sp->allSlavesSearching
&& sp->slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT && sp->slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT
&& available_to(sp->master)) && can_join(sp))
{ {
sp->slavesMask.set(idx); sp->slavesMask.set(idx);
activeSplitPoint = sp; activeSplitPoint = sp;

25
src/thread.cpp
View file

@ -102,14 +102,13 @@ bool Thread::cutoff_occurred() const {
} }
// Thread::available_to() checks whether the thread is available to help the // Thread::can_join() checks whether the thread is available to join the split
// thread 'master' at a split point. An obvious requirement is that thread must // point 'sp'. An obvious requirement is that thread must be idle. With more than
// be idle. With more than two threads, this is not sufficient: If the thread is // two threads, this is not sufficient: If the thread is the master of some split
// the master of some split point, it is only available as a slave to the slaves // point, it is only available as a slave for the split points below his active
// which are busy searching the split point at the top of slave's split point // one (the "helpful master" concept in YBWC terminology).
// stack (the "helpful master concept" in YBWC terminology).
bool Thread::available_to(const Thread* master) const { bool Thread::can_join(const SplitPoint* sp) const {
if (searching) if (searching)
return false; return false;
@ -120,7 +119,7 @@ bool Thread::available_to(const Thread* master) const {
// No split points means that the thread is available as a slave for any // No 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 !size || splitPoints[size - 1].slavesMask.test(master->idx); return !size || splitPoints[size - 1].slavesMask.test(sp->master->idx);
} }
@ -176,10 +175,10 @@ void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bes
Thread* slave; Thread* slave;
while ( sp.slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT while ( sp.slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT
&& (slave = Threads.available_slave(this)) != nullptr) && (slave = Threads.available_slave(activeSplitPoint)) != nullptr)
{ {
sp.slavesMask.set(slave->idx); sp.slavesMask.set(slave->idx);
slave->activeSplitPoint = &sp; slave->activeSplitPoint = activeSplitPoint;
slave->searching = true; // Slave leaves idle_loop() slave->searching = true; // Slave leaves idle_loop()
slave->notify_one(); // Could be sleeping slave->notify_one(); // Could be sleeping
} }
@ -325,12 +324,12 @@ void ThreadPool::read_uci_options() {
// ThreadPool::available_slave() tries to find an idle thread which is available // ThreadPool::available_slave() tries to find an idle thread which is available
// as a slave for the thread 'master'. // to join SplitPoint 'sp'.
Thread* ThreadPool::available_slave(const Thread* master) const { Thread* ThreadPool::available_slave(const SplitPoint* sp) const {
for (Thread* th : *this) for (Thread* th : *this)
if (th->available_to(master)) if (th->can_join(sp))
return th; return th;
return nullptr; return nullptr;

4
src/thread.h
View file

@ -114,7 +114,7 @@ struct Thread : public ThreadBase {
Thread(); Thread();
virtual void idle_loop(); virtual void idle_loop();
bool cutoff_occurred() const; bool cutoff_occurred() const;
bool available_to(const Thread* master) const; bool can_join(const SplitPoint* sp) const;
void split(Position& pos, Search::Stack* ss, Value alpha, Value beta, Value* bestValue, Move* bestMove, void split(Position& pos, Search::Stack* ss, Value alpha, Value beta, Value* bestValue, Move* bestMove,
Depth depth, int moveCount, MovePicker* movePicker, int nodeType, bool cutNode); Depth depth, int moveCount, MovePicker* movePicker, int nodeType, bool cutNode);
@ -161,7 +161,7 @@ struct ThreadPool : public std::vector<Thread*> {
MainThread* main() { return static_cast<MainThread*>(at(0)); } MainThread* main() { return static_cast<MainThread*>(at(0)); }
void read_uci_options(); void read_uci_options();
Thread* available_slave(const Thread* master) const; Thread* available_slave(const SplitPoint* sp) const;
void wait_for_think_finished(); void wait_for_think_finished();
void start_thinking(const Position&, const Search::LimitsType&, Search::StateStackPtr&); void start_thinking(const Position&, const Search::LimitsType&, Search::StateStackPtr&);