kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-29 16:23: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
&& sp->allSlavesSearching
&& sp->slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT
&& available_to(sp->master))
&& can_join(sp))
{
assert(this != th);
assert(!(this_sp && this_sp->slavesMask.none()));
@ -1623,7 +1623,7 @@ void Thread::idle_loop() {
if ( sp->allSlavesSearching
&& sp->slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT
&& available_to(sp->master))
&& can_join(sp))
{
sp->slavesMask.set(idx);
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 'master' at a split point. An obvious requirement is that thread must
// be idle. With more than two threads, this is not sufficient: If the thread is
// the master of some split point, it is only available as a slave to the slaves
// which are busy searching the split point at the top of slave's split point
// stack (the "helpful master concept" in YBWC terminology).
// Thread::can_join() checks whether the thread is available to join the split
// point 'sp'. An obvious requirement is that thread must be idle. With more than
// two threads, this is not sufficient: If the thread is the master of some split
// point, it is only available as a slave for the split points below his active
// one (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)
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
// 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;
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);
slave->activeSplitPoint = &sp;
slave->activeSplitPoint = activeSplitPoint;
slave->searching = true; // Slave leaves idle_loop()
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
// 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)
if (th->available_to(master))
if (th->can_join(sp))
return th;
return nullptr;

4
src/thread.h
View file

@ -114,7 +114,7 @@ struct Thread : public ThreadBase {
Thread();
virtual void idle_loop();
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,
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)); }
void read_uci_options();
Thread* available_slave(const Thread* master) const;
Thread* available_slave(const SplitPoint* sp) const;
void wait_for_think_finished();
void start_thinking(const Position&, const Search::LimitsType&, Search::StateStackPtr&);