summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
307909b)
Avoid to take the lock two times in a tight sequence, the first
in get_next_move() and the second to update sp->moves.
Do all with one lock and so retire the now useless locked version
of get_next_move().
Also fix some theorical race due to comparison sp->bestValue < sp->beta
is done out of lock protection. Finally fix another (harmless but time
waster) race that coudl occur because thread_should_stop() is also
called outside of lock protection.
No functional change.
Signed-off-by: Marco Costalba <mcostalba@gmail.com>
+static inline bool lock_grab_bool(Lock* x) {
+ lock_grab(x);
+ return true;
+}
#endif // !defined(LOCK_H_INCLUDED)
#endif // !defined(LOCK_H_INCLUDED)
/// are no more moves left.
/// It picks the move with the biggest score from a list of generated moves taking
/// care not to return the tt move if has already been searched previously.
/// are no more moves left.
/// It picks the move with the biggest score from a list of generated moves taking
/// care not to return the tt move if has already been searched previously.
+/// Note that this function is not thread safe so should be lock protected by
+/// caller when accessed through a shared MovePicker object.
Move MovePicker::get_next_move() {
Move MovePicker::get_next_move() {
-/// A variant of get_next_move() which takes a lock as a parameter, used to
-/// prevent multiple threads from picking the same move at a split point.
-
-Move MovePicker::get_next_move(Lock &lock) {
-
- lock_grab(&lock);
-
- // Note that it is safe to call many times
- // get_next_move() when phase == PH_STOP
- Move m = get_next_move();
-
- lock_release(&lock);
- return m;
-}
#include "depth.h"
#include "history.h"
#include "depth.h"
#include "history.h"
public:
MovePicker(const Position& p, Move ttm, Depth d, const History& h, SearchStack* ss = NULL);
Move get_next_move();
public:
MovePicker(const Position& p, Move ttm, Depth d, const History& h, SearchStack* ss = NULL);
Move get_next_move();
- Move get_next_move(Lock& lock);
int number_of_evasions() const;
private:
int number_of_evasions() const;
private:
SearchStack* ss = sp->sstack[threadID];
Value value = -VALUE_INFINITE;
Move move;
SearchStack* ss = sp->sstack[threadID];
Value value = -VALUE_INFINITE;
Move move;
bool isCheck = pos.is_check();
bool useFutilityPruning = sp->depth < SelectiveDepth
&& !isCheck;
const int FutilityMoveCountMargin = 3 + (1 << (3 * int(sp->depth) / 8));
bool isCheck = pos.is_check();
bool useFutilityPruning = sp->depth < SelectiveDepth
&& !isCheck;
const int FutilityMoveCountMargin = 3 + (1 << (3 * int(sp->depth) / 8));
- while ( sp->bestValue < sp->beta
+ while ( lock_grab_bool(&(sp->lock))
+ && sp->bestValue < sp->beta
&& !thread_should_stop(threadID)
&& !thread_should_stop(threadID)
- && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
+ && (move = sp->mp->get_next_move()) != MOVE_NONE)
+ moveCount = ++sp->moves;
+ lock_release(&(sp->lock));
+
assert(move_is_ok(move));
bool moveIsCheck = pos.move_is_check(move, ci);
bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
assert(move_is_ok(move));
bool moveIsCheck = pos.move_is_check(move, ci);
bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
- lock_grab(&(sp->lock));
- int moveCount = ++sp->moves;
- lock_release(&(sp->lock));
-
ss[sp->ply].currentMove = move;
ss[sp->ply].currentMove = move;
- // Decide the new search depth.
+ // Decide the new search depth
bool dangerous;
Depth ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous);
Depth newDepth = sp->depth - OnePly + ext;
bool dangerous;
Depth ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous);
Depth newDepth = sp->depth - OnePly + ext;
- lock_grab(&(sp->lock));
+ /* Here we have the lock still grabbed */
// If this is the master thread and we have been asked to stop because of
// a beta cutoff higher up in the tree, stop all slave threads.
// If this is the master thread and we have been asked to stop because of
// a beta cutoff higher up in the tree, stop all slave threads.
CheckInfo ci(pos);
SearchStack* ss = sp->sstack[threadID];
Value value = -VALUE_INFINITE;
CheckInfo ci(pos);
SearchStack* ss = sp->sstack[threadID];
Value value = -VALUE_INFINITE;
- while ( sp->alpha < sp->beta
+ while ( lock_grab_bool(&(sp->lock))
+ && sp->alpha < sp->beta
&& !thread_should_stop(threadID)
&& !thread_should_stop(threadID)
- && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
+ && (move = sp->mp->get_next_move()) != MOVE_NONE)
- bool moveIsCheck = pos.move_is_check(move, ci);
- bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
+ moveCount = ++sp->moves;
+ lock_release(&(sp->lock));
assert(move_is_ok(move));
assert(move_is_ok(move));
- lock_grab(&(sp->lock));
- int moveCount = ++sp->moves;
- lock_release(&(sp->lock));
+ bool moveIsCheck = pos.move_is_check(move, ci);
+ bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
ss[sp->ply].currentMove = move;
ss[sp->ply].currentMove = move;
- // Decide the new search depth.
+ // Decide the new search depth
bool dangerous;
Depth ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
Depth newDepth = sp->depth - OnePly + ext;
bool dangerous;
Depth ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
Depth newDepth = sp->depth - OnePly + ext;
- lock_grab(&(sp->lock));
+ /* Here we have the lock still grabbed */
// If this is the master thread and we have been asked to stop because of
// a beta cutoff higher up in the tree, stop all slave threads.
// If this is the master thread and we have been asked to stop because of
// a beta cutoff higher up in the tree, stop all slave threads.