summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
699f700)
But use the newly introduced local storage
for this. A good code semplification and also
the correct way to go.
No functional change.
Signed-off-by: Marco Costalba <mcostalba@gmail.com>
for (size_t i = 0; i < fens.size(); i++)
{
for (size_t i = 0; i < fens.size(); i++)
{
- Position pos(fens[i], false, NULL);
+ Position pos(fens[i], false);
cerr << "\nPosition: " << i + 1 << '/' << fens.size() << endl;
cerr << "\nPosition: " << i + 1 << '/' << fens.size() << endl;
string fen = sides[0] + char('0' + int(8 - code.length()))
+ sides[1] + "/8/8/8/8/8/8/8 w - - 0 10";
string fen = sides[0] + char('0' + int(8 - code.length()))
+ sides[1] + "/8/8/8/8/8/8/8 w - - 0 10";
- return Position(fen, false, NULL).material_key();
+ return Position(fen, false).material_key();
margins[WHITE] = margins[BLACK] = VALUE_ZERO;
// Probe the material hash table
margins[WHITE] = margins[BLACK] = VALUE_ZERO;
// Probe the material hash table
- ei.mi = pos.this_thread().materialTable.probe(pos);
+ ei.mi = Threads.this_thread()->materialTable.probe(pos);
score += ei.mi->material_value();
// If we have a specialized evaluation function for the current material
score += ei.mi->material_value();
// If we have a specialized evaluation function for the current material
}
// Probe the pawn hash table
}
// Probe the pawn hash table
- ei.pi = pos.this_thread().pawnTable.probe(pos);
+ ei.pi = Threads.this_thread()->pawnTable.probe(pos);
score += ei.pi->pawns_value();
// Initialize attack and king safety bitboards
score += ei.pi->pawns_value();
// Initialize attack and king safety bitboards
-/// Position::copy() creates a copy of 'pos'. We want the new born Position
+/// Position::operator=() creates a copy of 'pos'. We want the new born Position
/// object do not depend on any external data so we detach state pointer from
/// the source one.
/// object do not depend on any external data so we detach state pointer from
/// the source one.
-void Position::copy(const Position& pos, Thread* th) {
+Position& Position::operator=(const Position& pos) {
memcpy(this, &pos, sizeof(Position));
startState = *st;
st = &startState;
memcpy(this, &pos, sizeof(Position));
startState = *st;
st = &startState;
/// string. This function is not very robust - make sure that input FENs are
/// correct (this is assumed to be the responsibility of the GUI).
/// string. This function is not very robust - make sure that input FENs are
/// correct (this is assumed to be the responsibility of the GUI).
-void Position::from_fen(const string& fenStr, bool isChess960, Thread* th) {
+void Position::from_fen(const string& fenStr, bool isChess960) {
/*
A FEN string defines a particular position using only the ASCII character set.
/*
A FEN string defines a particular position using only the ASCII character set.
st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
chess960 = isChess960;
st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
chess960 = isChess960;
- Position p(*this, thisThread);
cout << "\nMove is: " << (sideToMove == BLACK ? ".." : "") << move_to_san(p, move);
}
cout << "\nMove is: " << (sideToMove == BLACK ? ".." : "") << move_to_san(p, move);
}
}
// Prefetch pawn and material hash tables
}
// Prefetch pawn and material hash tables
- prefetch((char*)thisThread->pawnTable.entries[st->pawnKey]);
- prefetch((char*)thisThread->materialTable.entries[st->materialKey]);
+ prefetch((char*)Threads.this_thread()->pawnTable.entries[st->pawnKey]);
+ prefetch((char*)Threads.this_thread()->materialTable.entries[st->materialKey]);
// Update incremental scores
st->psqScore += psq_delta(piece, from, to);
// Update incremental scores
st->psqScore += psq_delta(piece, from, to);
void Position::flip() {
// Make a copy of current position before to start changing
void Position::flip() {
// Make a copy of current position before to start changing
- const Position pos(*this, thisThread);
+ const Position pos(*this);
- thisThread = &pos.this_thread();
// Board
for (Square s = SQ_A1; s <= SQ_H8; s++)
// Board
for (Square s = SQ_A1; s <= SQ_H8; s++)
/// * A counter for detecting 50 move rule draws.
class Position {
/// * A counter for detecting 50 move rule draws.
class Position {
-
- // No copy c'tor or assignment operator allowed
- Position(const Position&);
- Position& operator=(const Position&);
-
- Position(const Position& p, Thread* t) { copy(p, t); }
- Position(const std::string& f, bool c960, Thread* t) { from_fen(f, c960, t); }
+ Position(const Position& p) { *this = p; }
+ Position(const std::string& f, bool c960) { from_fen(f, c960); }
+ Position& operator=(const Position&);
- void copy(const Position& pos, Thread* th);
- void from_fen(const std::string& fen, bool isChess960, Thread* th);
+ void from_fen(const std::string& fen, bool isChess960);
const std::string to_fen() const;
void print(Move m = MOVE_NONE) const;
const std::string to_fen() const;
void print(Move m = MOVE_NONE) const;
Color side_to_move() const;
int startpos_ply_counter() const;
bool is_chess960() const;
Color side_to_move() const;
int startpos_ply_counter() const;
bool is_chess960() const;
- Thread& this_thread() const;
int64_t nodes_searched() const;
void set_nodes_searched(int64_t n);
template<bool SkipRepetition> bool is_draw() const;
int64_t nodes_searched() const;
void set_nodes_searched(int64_t n);
template<bool SkipRepetition> bool is_draw() const;
int64_t nodes;
int startPosPly;
Color sideToMove;
int64_t nodes;
int startPosPly;
Color sideToMove;
StateInfo* st;
int chess960;
StateInfo* st;
int chess960;
return st->capturedType;
}
return st->capturedType;
}
-inline Thread& Position::this_thread() const {
- return *thisThread;
-}
-
#endif // !defined(POSITION_H_INCLUDED)
#endif // !defined(POSITION_H_INCLUDED)
// but if we are pondering or in infinite search, we shouldn't print the best
// move before we are told to do so.
if (!Signals.stop && (Limits.ponder || Limits.infinite))
// but if we are pondering or in infinite search, we shouldn't print the best
// move before we are told to do so.
if (!Signals.stop && (Limits.ponder || Limits.infinite))
- pos.this_thread().wait_for_stop_or_ponderhit();
+ Threads.this_thread()->wait_for_stop_or_ponderhit();
// Best move could be MOVE_NONE when searching on a stalemate position
cout << "bestmove " << move_to_uci(RootMoves[0].pv[0], Chess960)
// Best move could be MOVE_NONE when searching on a stalemate position
cout << "bestmove " << move_to_uci(RootMoves[0].pv[0], Chess960)
bool isPvMove, inCheck, singularExtensionNode, givesCheck;
bool captureOrPromotion, dangerous, doFullDepthSearch;
int moveCount = 0, playedMoveCount = 0;
bool isPvMove, inCheck, singularExtensionNode, givesCheck;
bool captureOrPromotion, dangerous, doFullDepthSearch;
int moveCount = 0, playedMoveCount = 0;
- Thread& thread = pos.this_thread();
+ Thread* thisThread = Threads.this_thread();
SplitPoint* sp = NULL;
refinedValue = bestValue = value = -VALUE_INFINITE;
SplitPoint* sp = NULL;
refinedValue = bestValue = value = -VALUE_INFINITE;
ss->ply = (ss-1)->ply + 1;
// Used to send selDepth info to GUI
ss->ply = (ss-1)->ply + 1;
// Used to send selDepth info to GUI
- if (PvNode && thread.maxPly < ss->ply)
- thread.maxPly = ss->ply;
+ if (PvNode && thisThread->maxPly < ss->ply)
+ thisThread->maxPly = ss->ply;
// Step 1. Initialize node
if (SpNode)
// Step 1. Initialize node
if (SpNode)
// Loop through all pseudo-legal moves until no moves remain or a beta cutoff occurs
while ( bestValue < beta
&& (move = mp.next_move()) != MOVE_NONE
// Loop through all pseudo-legal moves until no moves remain or a beta cutoff occurs
while ( bestValue < beta
&& (move = mp.next_move()) != MOVE_NONE
- && !thread.cutoff_occurred()
+ && !thisThread->cutoff_occurred()
&& !Signals.stop)
{
assert(is_ok(move));
&& !Signals.stop)
{
assert(is_ok(move));
{
Signals.firstRootMove = (moveCount == 1);
{
Signals.firstRootMove = (moveCount == 1);
- if (&thread == Threads.main_thread() && SearchTime.elapsed() > 2000)
+ if (thisThread == Threads.main_thread() && SearchTime.elapsed() > 2000)
cout << "info depth " << depth / ONE_PLY
<< " currmove " << move_to_uci(move, Chess960)
<< " currmovenumber " << moveCount + PVIdx << endl;
cout << "info depth " << depth / ONE_PLY
<< " currmove " << move_to_uci(move, Chess960)
<< " currmovenumber " << moveCount + PVIdx << endl;
&& value < beta) // We want always alpha < beta
alpha = value;
&& value < beta) // We want always alpha < beta
alpha = value;
- if (SpNode && !thread.cutoff_occurred())
+ if (SpNode && !thisThread->cutoff_occurred())
{
sp->bestValue = value;
sp->bestMove = move;
{
sp->bestValue = value;
sp->bestMove = move;
if ( !SpNode
&& depth >= Threads.min_split_depth()
&& bestValue < beta
if ( !SpNode
&& depth >= Threads.min_split_depth()
&& bestValue < beta
- && Threads.available_slave_exists(thread)
+ && Threads.available_slave_exists(thisThread)
- && !thread.cutoff_occurred())
+ && !thisThread->cutoff_occurred())
bestValue = Threads.split<FakeSplit>(pos, ss, alpha, beta, bestValue, &bestMove,
depth, threatMove, moveCount, &mp, NT);
}
bestValue = Threads.split<FakeSplit>(pos, ss, alpha, beta, bestValue, &bestMove,
depth, threatMove, moveCount, &mp, NT);
}
// Step 21. Update tables
// Update transposition table entry, killers and history
// Step 21. Update tables
// Update transposition table entry, killers and history
- if (!SpNode && !Signals.stop && !thread.cutoff_occurred())
+ if (!SpNode && !Signals.stop && !thisThread->cutoff_occurred())
{
move = bestValue <= oldAlpha ? MOVE_NONE : bestMove;
bt = bestValue <= oldAlpha ? BOUND_UPPER
{
move = bestValue <= oldAlpha ? MOVE_NONE : bestMove;
bt = bestValue <= oldAlpha ? BOUND_UPPER
lock_release(Threads.splitLock);
Stack ss[MAX_PLY_PLUS_2];
lock_release(Threads.splitLock);
Stack ss[MAX_PLY_PLUS_2];
- Position pos(*sp->pos, this);
+ Position pos(*sp->pos);
Thread* master = sp->master;
memcpy(ss, sp->ss - 1, 4 * sizeof(Stack));
Thread* master = sp->master;
memcpy(ss, sp->ss - 1, 4 * sizeof(Stack));
// slaves which are busy searching the split point at the top of slaves split
// point stack (the "helpful master concept" in YBWC terminology).
// slaves which are busy searching the split point at the top of slaves split
// point stack (the "helpful master concept" in YBWC terminology).
-bool Thread::is_available_to(const Thread& master) const {
+bool Thread::is_available_to(Thread* master) const {
if (is_searching)
return false;
if (is_searching)
return false;
// 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.
// 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.
- return !spCnt || (splitPoints[spCnt - 1].slavesMask & (1ULL << master.idx));
+ return !spCnt || (splitPoints[spCnt - 1].slavesMask & (1ULL << master->idx));
// available_slave_exists() tries to find an idle thread which is available as
// a slave for the thread 'master'.
// available_slave_exists() tries to find an idle thread which is available as
// a slave for the thread 'master'.
-bool ThreadsManager::available_slave_exists(const Thread& master) const {
+bool ThreadsManager::available_slave_exists(Thread* master) const {
for (int i = 0; i < size(); i++)
if (threads[i]->is_available_to(master))
for (int i = 0; i < size(); i++)
if (threads[i]->is_available_to(master))
assert(beta <= VALUE_INFINITE);
assert(depth > DEPTH_ZERO);
assert(beta <= VALUE_INFINITE);
assert(depth > DEPTH_ZERO);
- Thread& master = pos.this_thread();
+ Thread* master = Threads.this_thread();
- if (master.splitPointsCnt >= MAX_SPLITPOINTS_PER_THREAD)
+ if (master->splitPointsCnt >= MAX_SPLITPOINTS_PER_THREAD)
return bestValue;
// Pick the next available split point from the split point stack
return bestValue;
// Pick the next available split point from the split point stack
- SplitPoint* sp = &master.splitPoints[master.splitPointsCnt++];
+ SplitPoint* sp = &master->splitPoints[master->splitPointsCnt++];
- sp->parent = master.curSplitPoint;
- sp->master = &master;
+ sp->parent = master->curSplitPoint;
+ sp->master = master;
- sp->slavesMask = 1ULL << master.idx;
+ sp->slavesMask = 1ULL << master->idx;
sp->depth = depth;
sp->bestMove = *bestMove;
sp->threatMove = threatMove;
sp->depth = depth;
sp->bestMove = *bestMove;
sp->threatMove = threatMove;
sp->nodes = 0;
sp->ss = ss;
sp->nodes = 0;
sp->ss = ss;
- assert(master.is_searching);
+ assert(master->is_searching);
- master.curSplitPoint = sp;
+ master->curSplitPoint = sp;
int slavesCnt = 0;
// Try to allocate available threads and ask them to start searching setting
int slavesCnt = 0;
// Try to allocate available threads and ask them to start searching setting
// their work at this split point.
if (slavesCnt || Fake)
{
// their work at this split point.
if (slavesCnt || Fake)
{
// 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.
// 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.is_searching);
+ assert(!master->is_searching);
}
// We have returned from the idle loop, which means that all threads are
}
// We have returned from the idle loop, which means that all threads are
lock_grab(sp->lock); // To protect sp->nodes
lock_grab(splitLock);
lock_grab(sp->lock); // To protect sp->nodes
lock_grab(splitLock);
- master.is_searching = true;
- master.splitPointsCnt--;
- master.curSplitPoint = sp->parent;
+ master->is_searching = true;
+ master->splitPointsCnt--;
+ master->curSplitPoint = sp->parent;
pos.set_nodes_searched(pos.nodes_searched() + sp->nodes);
*bestMove = sp->bestMove;
pos.set_nodes_searched(pos.nodes_searched() + sp->nodes);
*bestMove = sp->bestMove;
Signals.stopOnPonderhit = Signals.firstRootMove = false;
Signals.stop = Signals.failedLowAtRoot = false;
Signals.stopOnPonderhit = Signals.firstRootMove = false;
Signals.stop = Signals.failedLowAtRoot = false;
- RootPosition.copy(pos, main_thread());
Limits = limits;
RootMoves.clear();
Limits = limits;
RootMoves.clear();
void wake_up();
bool cutoff_occurred() const;
void wake_up();
bool cutoff_occurred() const;
- bool is_available_to(const Thread& master) const;
+ bool is_available_to(Thread* master) const;
void idle_loop(SplitPoint* sp_master);
void idle_loop() { idle_loop(NULL); } // Hack to allow storing in start_fn
void main_loop();
void idle_loop(SplitPoint* sp_master);
void idle_loop() { idle_loop(NULL); } // Hack to allow storing in start_fn
void main_loop();
void wake_up() const;
void sleep() const;
void read_uci_options();
void wake_up() const;
void sleep() const;
void read_uci_options();
- bool available_slave_exists(const Thread& master) const;
+ bool available_slave_exists(Thread* master) const;
void set_timer(int msec);
void wait_for_search_finished();
void start_searching(const Position& pos, const Search::LimitsType& limits,
void set_timer(int msec);
void wait_for_search_finished();
void start_searching(const Position& pos, const Search::LimitsType& limits,
void uci_loop(const string& args) {
void uci_loop(const string& args) {
- Position pos(StartFEN, false, Threads.main_thread()); // The root position
+ Position pos(StartFEN, false); // The root position
string cmd, token;
while (token != "quit")
string cmd, token;
while (token != "quit")
- pos.from_fen(fen, Options["UCI_Chess960"], Threads.main_thread());
+ pos.from_fen(fen, Options["UCI_Chess960"]);
// Parse move list (if any)
while (is >> token && (m = move_from_uci(pos, token)) != MOVE_NONE)
// Parse move list (if any)
while (is >> token && (m = move_from_uci(pos, token)) != MOVE_NONE)