From 0363b5435847e66678cd3fa0d8a94e30b9a91663 Mon Sep 17 00:00:00 2001 From: Marco Costalba Date: Fri, 20 Aug 2010 18:16:20 +0100 Subject: [PATCH] Retire beta counters stuff Is now obsoleted by previous patch. No functional change. Signed-off-by: Marco Costalba --- src/search.cpp | 66 ++++++++++---------------------------------------- src/thread.h | 1 - 2 files changed, 13 insertions(+), 54 deletions(-) diff --git a/src/search.cpp b/src/search.cpp index 68b19cd3..97b7a29c 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -76,12 +76,9 @@ namespace { 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; @@ -117,7 +114,7 @@ namespace { struct RootMove { - RootMove() { mp_score = 0; 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 @@ -131,7 +128,7 @@ namespace { Move move; Value score; int mp_score; - int64_t nodes, cumulativeNodes, ourBeta, theirBeta; + int64_t nodes, cumulativeNodes; Move pv[PLY_MAX_PLUS_2]; }; @@ -144,17 +141,15 @@ namespace { public: RootMoveList(Position& pos, Move searchMoves[]); - void set_mp_scores(const Position &pos); - int move_count() const { return count; } Move get_move(int moveNum) const { return moves[moveNum].move; } Value get_move_score(int moveNum) const { return moves[moveNum].score; } 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); @@ -742,7 +737,7 @@ namespace { while (1) { // Sort the moves before to (re)search - rml.set_mp_scores(pos); + rml.score_moves(pos); rml.sort(); // Step 10. Loop through all moves in the root move list @@ -754,9 +749,6 @@ namespace { // 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); @@ -875,11 +867,7 @@ namespace { 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); @@ -1371,14 +1359,11 @@ namespace { 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); @@ -2324,12 +2309,6 @@ namespace { 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; @@ -2339,16 +2318,6 @@ namespace { 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 @@ -2780,25 +2749,22 @@ namespace { 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::set_mp_scores(const Position &pos) + void RootMoveList::score_moves(const Position& pos) { - MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H); Move move; + int score = 1000; + MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H); - int moveCount = 0; while ((move = mp.get_next_move()) != MOVE_NONE) - { - moveCount++; for (int i = 0; i < count; i++) - { if (moves[i].move == move) { - moves[i].mp_score = 512 - moveCount; + moves[i].mp_score = score--; break; } - } - } } // RootMoveList simple methods definitions @@ -2809,12 +2775,6 @@ namespace { 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; diff --git a/src/thread.h b/src/thread.h index c209e125..d9a91f00 100644 --- a/src/thread.h +++ b/src/thread.h @@ -85,7 +85,6 @@ enum ThreadState struct Thread { uint64_t nodes; - uint64_t betaCutOffs[2]; volatile ThreadState state; SplitPoint* volatile splitPoint; volatile int activeSplitPoints; -- 2.39.2