kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-05-02 09:39:36 +00:00
Code Issues Releases Wiki Activity

Convert handling of tt moves and killers to standard form

Browse source 
Use the same way of loop along the move list used for
the others move kinds so to be consistent in get_next_move()

And a bit of the usual clean up too, but just a bit.

It is even a bit (+0.3%) faster now. ;-)

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2009-08-29 08:02:30 +01:00
parent ac65b14d30
commit 9ab84a8165
2 changed files with 40 additions and 36 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

66
src/movepick.cpp
View file

@ -27,7 +27,6 @@
#include <cassert> #include <cassert>
#include "history.h" #include "history.h"
#include "evaluate.h"
#include "movegen.h" #include "movegen.h"
#include "movepick.h" #include "movepick.h"
#include "search.h" #include "search.h"
@ -40,8 +39,6 @@
namespace { namespace {
/// Variables
CACHE_LINE_ALIGNMENT CACHE_LINE_ALIGNMENT
const MovegenPhaseT MainSearchPhaseTable[] = { PH_NULL_MOVE, PH_TT_MOVES, PH_GOOD_CAPTURES, PH_KILLERS, PH_NONCAPTURES, PH_BAD_CAPTURES, PH_STOP}; const MovegenPhaseT MainSearchPhaseTable[] = { PH_NULL_MOVE, PH_TT_MOVES, PH_GOOD_CAPTURES, PH_KILLERS, PH_NONCAPTURES, PH_BAD_CAPTURES, PH_STOP};
const MovegenPhaseT MainSearchNoNullPhaseTable[] = { PH_TT_MOVES, PH_GOOD_CAPTURES, PH_KILLERS, PH_NONCAPTURES, PH_BAD_CAPTURES, PH_STOP}; const MovegenPhaseT MainSearchNoNullPhaseTable[] = { PH_TT_MOVES, PH_GOOD_CAPTURES, PH_KILLERS, PH_NONCAPTURES, PH_BAD_CAPTURES, PH_STOP};
@ -66,17 +63,17 @@ namespace {
MovePicker::MovePicker(const Position& p, Move ttm, Depth d, MovePicker::MovePicker(const Position& p, Move ttm, Depth d,
const History& h, SearchStack* ss, bool useNullMove) : pos(p), H(h) { const History& h, SearchStack* ss, bool useNullMove) : pos(p), H(h) {
ttMoves[0] = ttm; ttMoves[0].move = ttm;
if (ss) if (ss)
{ {
ttMoves[1] = (ss->mateKiller == ttm)? MOVE_NONE : ss->mateKiller; ttMoves[1].move = (ss->mateKiller == ttm)? MOVE_NONE : ss->mateKiller;
killers[0] = ss->killers[0]; killers[0].move = ss->killers[0];
killers[1] = ss->killers[1]; killers[1].move = ss->killers[1];
} else } else
ttMoves[1] = killers[0] = killers[1] = MOVE_NONE; ttMoves[1].move = killers[0].move = killers[1].move = MOVE_NONE;
numOfBadCaptures = 0;
finished = false; finished = false;
numOfBadCaptures = 0;
Color us = pos.side_to_move(); Color us = pos.side_to_move();
@ -109,8 +106,11 @@ void MovePicker::go_next_phase() {
switch (phase) { switch (phase) {
case PH_NULL_MOVE: case PH_NULL_MOVE:
return;
case PH_TT_MOVES: case PH_TT_MOVES:
movesPicked = 0; curMove = ttMoves;
lastMove = curMove + 2;
return; return;
case PH_GOOD_CAPTURES: case PH_GOOD_CAPTURES:
@ -120,7 +120,8 @@ void MovePicker::go_next_phase() {
return; return;
case PH_KILLERS: case PH_KILLERS:
movesPicked = 0; curMove = killers;
lastMove = curMove + 2;
return; return;
case PH_NONCAPTURES: case PH_NONCAPTURES:
@ -202,14 +203,16 @@ void MovePicker::score_noncaptures() {
// First score by history, when no history is available then use // First score by history, when no history is available then use
// piece/square tables values. This seems to be better then a // piece/square tables values. This seems to be better then a
// random choice when we don't have an history for any move. // random choice when we don't have an history for any move.
Move m;
Piece piece; Piece piece;
Square from, to; Square from, to;
int hs; int hs;
for (MoveStack* cur = moves; cur != lastMove; cur++) for (MoveStack* cur = moves; cur != lastMove; cur++)
{ {
from = move_from(cur->move); m = cur->move;
to = move_to(cur->move); from = move_from(m);
to = move_to(m);
piece = pos.piece_on(from); piece = pos.piece_on(from);
hs = H.move_ordering_score(piece, to); hs = H.move_ordering_score(piece, to);
@ -224,15 +227,17 @@ void MovePicker::score_noncaptures() {
void MovePicker::score_evasions() { void MovePicker::score_evasions() {
Move m;
for (MoveStack* cur = moves; cur != lastMove; cur++) for (MoveStack* cur = moves; cur != lastMove; cur++)
{ {
Move m = cur->move; m = cur->move;
if (m == ttMoves[0]) if (m == ttMoves[0].move)
cur->score = 2*HistoryMax; cur->score = 2 * HistoryMax;
else if (!pos.square_is_empty(move_to(m))) else if (!pos.square_is_empty(move_to(m)))
{ {
int seeScore = pos.see(m); int seeScore = pos.see(m);
cur->score = (seeScore >= 0)? seeScore + HistoryMax : seeScore; cur->score = seeScore + (seeScore >= 0 ? HistoryMax : 0);
} else } else
cur->score = H.move_ordering_score(pos.piece_on(move_from(m)), move_to(m)); cur->score = H.move_ordering_score(pos.piece_on(move_from(m)), move_to(m));
} }
@ -258,9 +263,9 @@ Move MovePicker::get_next_move() {
return MOVE_NULL; return MOVE_NULL;
case PH_TT_MOVES: case PH_TT_MOVES:
while (movesPicked < 2) while (curMove != lastMove)
{ {
Move move = ttMoves[movesPicked++]; Move move = (curMove++)->move;
if ( move != MOVE_NONE if ( move != MOVE_NONE
&& move_is_legal(pos, move, pinned)) && move_is_legal(pos, move, pinned))
return move; return move;
@ -271,8 +276,8 @@ Move MovePicker::get_next_move() {
while (curMove != lastMove) while (curMove != lastMove)
{ {
Move move = (curMove++)->move; Move move = (curMove++)->move;
if ( move != ttMoves[0] if ( move != ttMoves[0].move
&& move != ttMoves[1] && move != ttMoves[1].move
&& pos.pl_move_is_legal(move, pinned)) && pos.pl_move_is_legal(move, pinned))
{ {
// Check for a non negative SEE now // Check for a non negative SEE now
@ -290,12 +295,12 @@ Move MovePicker::get_next_move() {
break; break;
case PH_KILLERS: case PH_KILLERS:
while (movesPicked < 2) while (curMove != lastMove)
{ {
Move move = killers[movesPicked++]; Move move = (curMove++)->move;
if ( move != MOVE_NONE if ( move != MOVE_NONE
&& move != ttMoves[0] && move != ttMoves[0].move
&& move != ttMoves[1] && move != ttMoves[1].move
&& move_is_legal(pos, move, pinned) && move_is_legal(pos, move, pinned)
&& !pos.move_is_capture(move)) && !pos.move_is_capture(move))
return move; return move;
@ -306,10 +311,10 @@ Move MovePicker::get_next_move() {
while (curMove != lastMove) while (curMove != lastMove)
{ {
Move move = (curMove++)->move; Move move = (curMove++)->move;
if ( move != ttMoves[0] if ( move != ttMoves[0].move
&& move != ttMoves[1] && move != ttMoves[1].move
&& move != killers[0] && move != killers[0].move
&& move != killers[1] && move != killers[1].move
&& pos.pl_move_is_legal(move, pinned)) && pos.pl_move_is_legal(move, pinned))
return move; return move;
} }
@ -327,7 +332,7 @@ Move MovePicker::get_next_move() {
{ {
Move move = (curMove++)->move; Move move = (curMove++)->move;
// Maybe postpone the legality check until after futility pruning? // Maybe postpone the legality check until after futility pruning?
if ( move != ttMoves[0] if ( move != ttMoves[0].move
&& pos.pl_move_is_legal(move, pinned)) && pos.pl_move_is_legal(move, pinned))
return move; return move;
} }
@ -342,7 +347,6 @@ Move MovePicker::get_next_move() {
} }
go_next_phase(); go_next_phase();
} }
return MOVE_NONE;
} }
/// A variant of get_next_move() which takes a lock as a parameter, used to /// A variant of get_next_move() which takes a lock as a parameter, used to

8
src/movepick.h
View file

@ -79,12 +79,12 @@ private:
const Position& pos; const Position& pos;
const History& H; const History& H;
Move ttMoves[2], killers[2]; MoveStack ttMoves[2], killers[2];
const MovegenPhaseT* phasePtr;
int phase, movesPicked, numOfBadCaptures;
bool finished; bool finished;
Bitboard dc, pinned; int numOfBadCaptures, phase;
const MovegenPhaseT* phasePtr;
MoveStack *curMove, *lastMove; MoveStack *curMove, *lastMove;
Bitboard dc, pinned;
MoveStack moves[256], badCaptures[64]; MoveStack moves[256], badCaptures[64];
}; };