int active_threads() const { return ActiveThreads; }
void set_active_threads(int newActiveThreads) { ActiveThreads = newActiveThreads; }
void incrementNodeCounter(int threadID) { threads[threadID].nodes++; }
- void incrementBetaCounter(Color us, Depth d, int threadID) { threads[threadID].betaCutOffs[us] += unsigned(d); }
void resetNodeCounters();
- void resetBetaCounters();
int64_t nodes_searched() const;
- void get_beta_counters(Color us, int64_t& our, int64_t& their) const;
bool available_thread_exists(int master) const;
bool thread_is_available(int slave, int master) const;
bool thread_should_stop(int threadID) const;
struct RootMove {
- RootMove() { nodes = cumulativeNodes = ourBeta = theirBeta = 0ULL; }
+ RootMove() : mp_score(0), nodes(0), cumulativeNodes(0) {}
// RootMove::operator<() is the comparison function used when
// sorting the moves. A move m1 is considered to be better
// have equal score but m1 has the higher beta cut-off count.
bool operator<(const RootMove& m) const {
- return score != m.score ? score < m.score : theirBeta <= m.theirBeta;
+ return score != m.score ? score < m.score : mp_score <= m.mp_score;
}
Move move;
Value score;
- int64_t nodes, cumulativeNodes, ourBeta, theirBeta;
+ int mp_score;
+ int64_t nodes, cumulativeNodes;
Move pv[PLY_MAX_PLUS_2];
};
void set_move_score(int moveNum, Value score) { moves[moveNum].score = score; }
Move get_move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; }
int64_t get_move_cumulative_nodes(int moveNum) const { return moves[moveNum].cumulativeNodes; }
+ void score_moves(const Position& pos);
void set_move_nodes(int moveNum, int64_t nodes);
- void set_beta_counters(int moveNum, int64_t our, int64_t their);
void set_move_pv(int moveNum, const Move pv[]);
void sort();
void sort_multipv(int n);
while (1)
{
// Sort the moves before to (re)search
+ rml.score_moves(pos);
rml.sort();
// Step 10. Loop through all moves in the root move list
// Save the current node count before the move is searched
nodes = ThreadsMgr.nodes_searched();
- // Reset beta cut-off counters
- ThreadsMgr.resetBetaCounters();
-
// Pick the next root move, and print the move and the move number to
// the standard output.
move = ss->currentMove = rml.get_move(i);
if (AbortSearch)
break;
- // Remember beta-cutoff and searched nodes counts for this move. The
- // info is used to sort the root moves for the next iteration.
- int64_t our, their;
- ThreadsMgr.get_beta_counters(pos.side_to_move(), our, their);
- rml.set_beta_counters(i, our, their);
+ // Remember searched nodes counts for this move
rml.set_move_nodes(i, ThreadsMgr.nodes_searched() - nodes);
assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);
&& tte
&& tte->move()
&& !excludedMove // Do not allow recursive singular extension search
- && is_lower_bound(tte->type())
+ && (tte->type() & VALUE_TYPE_LOWER)
&& tte->depth() >= depth - 3 * ONE_PLY;
// Step 10. Loop through moves
TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, ei.kingDanger[pos.side_to_move()]);
// Update killers and history only for non capture moves that fails high
- if (bestValue >= beta)
+ if ( bestValue >= beta
+ && !pos.move_is_capture_or_promotion(move))
{
- ThreadsMgr.incrementBetaCounter(pos.side_to_move(), depth, threadID);
- if (!pos.move_is_capture_or_promotion(move))
- {
update_history(pos, move, depth, movesSearched, moveCount);
update_killers(move, ss);
- }
}
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
|| v >= Max(value_mate_in(PLY_MAX), beta)
|| v < Min(value_mated_in(PLY_MAX), beta))
- && ( (is_lower_bound(tte->type()) && v >= beta)
- || (is_upper_bound(tte->type()) && v < beta));
+ && ( ((tte->type() & VALUE_TYPE_LOWER) && v >= beta)
+ || ((tte->type() & VALUE_TYPE_UPPER) && v < beta));
}
Value v = value_from_tt(tte->value(), ply);
- if ( (is_lower_bound(tte->type()) && v >= defaultEval)
- || (is_upper_bound(tte->type()) && v < defaultEval))
+ if ( ((tte->type() & VALUE_TYPE_LOWER) && v >= defaultEval)
+ || ((tte->type() & VALUE_TYPE_UPPER) && v < defaultEval))
return v;
return defaultEval;
threads[i].nodes = 0ULL;
}
- void ThreadsManager::resetBetaCounters() {
-
- for (int i = 0; i < MAX_THREADS; i++)
- threads[i].betaCutOffs[WHITE] = threads[i].betaCutOffs[BLACK] = 0ULL;
- }
-
int64_t ThreadsManager::nodes_searched() const {
int64_t result = 0ULL;
return result;
}
- void ThreadsManager::get_beta_counters(Color us, int64_t& our, int64_t& their) const {
-
- our = their = 0UL;
- for (int i = 0; i < MAX_THREADS; i++)
- {
- our += threads[i].betaCutOffs[us];
- their += threads[i].betaCutOffs[opposite_color(us)];
- }
- }
-
// idle_loop() is where the threads are parked when they have no work to do.
// The parameter 'sp', if non-NULL, is a pointer to an active SplitPoint
sort();
}
+ // Score root moves using the standard way used in main search, the moves
+ // are scored according to the order in which are returned by MovePicker.
+
+ void RootMoveList::score_moves(const Position& pos)
+ {
+ Move move;
+ int score = 1000;
+ MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H);
+
+ while ((move = mp.get_next_move()) != MOVE_NONE)
+ for (int i = 0; i < count; i++)
+ if (moves[i].move == move)
+ {
+ moves[i].mp_score = score--;
+ break;
+ }
+ }
// RootMoveList simple methods definitions
moves[moveNum].cumulativeNodes += nodes;
}
- void RootMoveList::set_beta_counters(int moveNum, int64_t our, int64_t their) {
-
- moves[moveNum].ourBeta = our;
- moves[moveNum].theirBeta = their;
- }
-
void RootMoveList::set_move_pv(int moveNum, const Move pv[]) {
int j;