From: Marco Costalba Date: Sat, 7 Feb 2015 18:34:24 +0000 (+0100) Subject: Small tweaks in do_move and friends X-Git-Url: https://git.sesse.net/?p=stockfish;a=commitdiff_plain;h=3184852bdce27e387852f4e250c3c5b502706cb3 Small tweaks in do_move and friends Also remove useless StateCopySize64 optimization: compiler uses SSE movups instruction anyhow and does not need this trick (verified with fishbench). No functional change. --- diff --git a/src/position.cpp b/src/position.cpp index c02fdf62..87067ea5 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -19,7 +19,7 @@ #include #include -#include // For std::memset +#include // For std::memset, std::memcmp #include #include @@ -381,7 +381,7 @@ void Position::set_state(StateInfo* si) const { if (sideToMove == BLACK) si->key ^= Zobrist::side; - si->key ^= Zobrist::castling[st->castlingRights]; + si->key ^= Zobrist::castling[si->castlingRights]; for (Bitboard b = pieces(PAWN); b; ) { @@ -693,25 +693,21 @@ void Position::do_move(Move m, StateInfo& newSt) { do_move(m, newSt, ci, gives_check(m, ci)); } -void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) { +void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool givesCheck) { assert(is_ok(m)); assert(&newSt != st); ++nodes; - Key k = st->key; + Key k = st->key ^ Zobrist::side; // Copy some fields of the old state to our new StateInfo object except the // ones which are going to be recalculated from scratch anyway and then switch // our state pointer to point to the new (ready to be updated) state. - std::memcpy(&newSt, st, StateCopySize64 * sizeof(uint64_t)); - + std::memcpy(&newSt, st, offsetof(StateInfo, key)); newSt.previous = st; st = &newSt; - // Update side to move - k ^= Zobrist::side; - // Increment ply counters. In particular, rule50 will be reset to zero later on // in case of a capture or a pawn move. ++gamePly; @@ -722,17 +718,16 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI Color them = ~us; Square from = from_sq(m); Square to = to_sq(m); - Piece pc = piece_on(from); - PieceType pt = type_of(pc); + PieceType pt = type_of(piece_on(from)); PieceType captured = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to)); - assert(color_of(pc) == us); - assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLING); + assert(color_of(piece_on(from)) == us); + assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == (type_of(m) != CASTLING ? them : us)); assert(captured != KING); if (type_of(m) == CASTLING) { - assert(pc == make_piece(us, KING)); + assert(pt == KING); Square rfrom, rto; do_castling(from, to, rfrom, rto); @@ -752,7 +747,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI { if (type_of(m) == ENPASSANT) { - capsq += pawn_push(them); + capsq -= pawn_push(us); assert(pt == PAWN); assert(to == st->epSquare); @@ -760,7 +755,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI assert(piece_on(to) == NO_PIECE); assert(piece_on(capsq) == make_piece(them, PAWN)); - board[capsq] = NO_PIECE; + board[capsq] = NO_PIECE; // Not done by remove_piece() } st->pawnKey ^= Zobrist::psq[them][PAWN][capsq]; @@ -810,9 +805,9 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI { // Set en-passant square if the moved pawn can be captured if ( (int(to) ^ int(from)) == 16 - && (attacks_from(from + pawn_push(us), us) & pieces(them, PAWN))) + && (attacks_from(to - pawn_push(us), us) & pieces(them, PAWN))) { - st->epSquare = Square((from + to) / 2); + st->epSquare = (from + to) / 2; k ^= Zobrist::enpassant[file_of(st->epSquare)]; } @@ -859,7 +854,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI // Update checkers bitboard: piece must be already moved due to attacks_from() st->checkersBB = 0; - if (moveIsCheck) + if (givesCheck) { if (type_of(m) != NORMAL) st->checkersBB = attackers_to(king_square(them)) & pieces(us); @@ -872,6 +867,8 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI // Discovered checks if (ci.dcCandidates && (ci.dcCandidates & from)) { + assert(pt != QUEEN); + if (pt != ROOK) st->checkersBB |= attacks_from(king_square(them)) & pieces(us, QUEEN, ROOK); @@ -906,11 +903,11 @@ void Position::undo_move(Move m) { if (type_of(m) == PROMOTION) { - assert(pt == promotion_type(m)); assert(relative_rank(us, to) == RANK_8); - assert(promotion_type(m) >= KNIGHT && promotion_type(m) <= QUEEN); + assert(pt == promotion_type(m)); + assert(pt >= KNIGHT && pt <= QUEEN); - remove_piece(to, us, promotion_type(m)); + remove_piece(to, us, pt); put_piece(to, us, PAWN); pt = PAWN; } @@ -936,6 +933,7 @@ void Position::undo_move(Move m) { assert(to == st->previous->epSquare); assert(relative_rank(us, to) == RANK_6); assert(piece_on(capsq) == NO_PIECE); + assert(st->capturedType == PAWN); } put_piece(capsq, ~us, st->capturedType); // Restore the captured piece @@ -975,9 +973,9 @@ void Position::do_castling(Square from, Square& to, Square& rfrom, Square& rto) void Position::do_null_move(StateInfo& newSt) { assert(!checkers()); + assert(&newSt != st); - std::memcpy(&newSt, st, sizeof(StateInfo)); // Fully copy here - + std::memcpy(&newSt, st, sizeof(StateInfo)); newSt.previous = st; st = &newSt; @@ -1172,11 +1170,13 @@ void Position::flip() { /// Position::pos_is_ok() performs some consistency checks for the position object. /// This is meant to be helpful when debugging. -bool Position::pos_is_ok(bool fast, int* failedStep) const { +bool Position::pos_is_ok(int* failedStep) const { + + const bool Fast = true; // Quick (default) or full check? enum { Default, King, Bitboards, State, Lists, Castling }; - for (int step = Default; step <= (fast ? Default : Castling); step++) + for (int step = Default; step <= (Fast ? Default : Castling); step++) { if (failedStep) *failedStep = step; @@ -1209,15 +1209,9 @@ bool Position::pos_is_ok(bool fast, int* failedStep) const { if (step == State) { - StateInfo si; + StateInfo si = *st; set_state(&si); - if ( st->key != si.key - || st->pawnKey != si.pawnKey - || st->materialKey != si.materialKey - || st->nonPawnMaterial[WHITE] != si.nonPawnMaterial[WHITE] - || st->nonPawnMaterial[BLACK] != si.nonPawnMaterial[BLACK] - || st->psq != si.psq - || st->checkersBB != si.checkersBB) + if (std::memcmp(&si, st, sizeof(StateInfo))) return false; } diff --git a/src/position.h b/src/position.h index 679a636d..3947180f 100644 --- a/src/position.h +++ b/src/position.h @@ -68,11 +68,6 @@ struct StateInfo { }; -/// When making a move the current StateInfo up to 'key' excluded is copied to -/// the new one. Here we calculate the quad words (64 bit) needed to be copied. -const size_t StateCopySize64 = offsetof(StateInfo, key) / sizeof(uint64_t) + 1; - - /// Position class stores information regarding the board representation as /// pieces, side to move, hash keys, castling info, etc. Important methods are /// do_move() and undo_move(), used by the search to update node info when @@ -144,7 +139,7 @@ public: // Doing and undoing moves void do_move(Move m, StateInfo& st); - void do_move(Move m, StateInfo& st, const CheckInfo& ci, bool moveIsCheck); + void do_move(Move m, StateInfo& st, const CheckInfo& ci, bool givesCheck); void undo_move(Move m); void do_null_move(StateInfo& st); void undo_null_move(); @@ -174,7 +169,7 @@ public: Value non_pawn_material(Color c) const; // Position consistency check, for debugging - bool pos_is_ok(bool fast = true, int* failedStep = nullptr) const; + bool pos_is_ok(int* failedStep = nullptr) const; void flip(); private: diff --git a/src/types.h b/src/types.h index 23e69d2e..eebd69e5 100644 --- a/src/types.h +++ b/src/types.h @@ -417,7 +417,7 @@ inline MoveType type_of(Move m) { } inline PieceType promotion_type(Move m) { - return PieceType(((m >> 12) & 3) + 2); + return PieceType(((m >> 12) & 3) + KNIGHT); } inline Move make_move(Square from, Square to) {