deepcrayon
/
stockfish
1
0
Fork 0
Code Releases Activity

Split transposition table lookup in a separate function 

This slims down the code and is a prerequisite for
future patches.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
sf_2.3.1_base
Marco Costalba 2008-09-06 15:53:43 +02:00
parent c2c0ba875f
commit a230dc1404
3 changed files with 39 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
src/search.cpp
View File

@ -240,6 +240,7 @@ namespace {
bool singleReply, bool mateThreat);
bool ok_to_do_nullmove(const Position &pos);
bool ok_to_prune(const Position &pos, Move m, Move threat, Depth d);
bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply);
bool fail_high_ply_1();
int current_search_time();
@ -458,7 +459,7 @@ void think(const Position &pos, bool infinite, bool ponder, int time,
// We're ready to start thinking. Call the iterative deepening loop
// function:
id_loop(pos, searchMoves);
id_loop(pos, searchMoves);;
if(UseLogFile)
LogFile.close();
@ -859,14 +860,11 @@ namespace {
// Transposition table lookup. At PV nodes, we don't use the TT for
// pruning, but only for move ordering.
Value ttValue;
Depth ttDepth;
Move ttMove = MOVE_NONE;
ValueType ttValueType;
const TTEntry* tte = TT.retrieve(pos);
TT.retrieve(pos, &ttValue, &ttDepth, &ttMove, &ttValueType);
Move ttMove = (tte ? tte->move() : MOVE_NONE);
// Internal iterative deepening.
// Go with internal iterative deepening if we don't have a TT move.
if(UseIIDAtPVNodes && ttMove == MOVE_NONE && depth >= 5*OnePly) {
search_pv(pos, ss, alpha, beta, depth-2*OnePly, ply, threadID);
ttMove = ss[ply].pv[ply];
@ -1045,24 +1043,14 @@ namespace {
return beta-1;
// Transposition table lookup
bool ttFound;
Value ttValue;
Depth ttDepth;
Move ttMove = MOVE_NONE;
ValueType ttValueType;
const TTEntry* tte = TT.retrieve(pos);
ttFound = TT.retrieve(pos, &ttValue, &ttDepth, &ttMove, &ttValueType);
if(ttFound) {
ttValue = value_from_tt(ttValue, ply);
if(ttDepth >= depth
|| ttValue >= Max(value_mate_in(100), beta)
|| ttValue < Min(value_mated_in(100), beta)) {
if((is_lower_bound(ttValueType) && ttValue >= beta) ||
(is_upper_bound(ttValueType) && ttValue < beta)) {
ss[ply].currentMove = ttMove;
return ttValue;
}
}
Move ttMove = (tte ? tte->move() : MOVE_NONE);
if (tte && ok_to_use_TT(tte, depth, beta, ply))
{
ss[ply].currentMove = ttMove; // can be MOVE_NONE ?
return value_from_tt(tte->value(), ply);
}
Value approximateEval = quick_evaluate(pos);
@ -1590,6 +1578,20 @@ namespace {
lock_release(&(sp->lock));
}
// ok_to_use_TT() returns true if a transposition table score
// can be used at a given point in search.
bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply) {
Value v = value_from_tt(tte->value(), ply);
return ( tte->depth() >= depth
|| v >= Max(value_mate_in(100), beta)
|| v < Min(value_mated_in(100), beta))
&& ( (is_lower_bound(tte->type()) && v >= beta)
|| (is_upper_bound(tte->type()) && v < beta));
}
/// The RootMove class

45
src/tt.cpp
View File

@ -136,29 +136,20 @@ void TranspositionTable::store(const Position &pos, Value v, Depth d,
/// TranspositionTable::retrieve looks up the current position in the
/// transposition table, and extracts the value, value type, depth and
/// best move if the position is found. The return value is true if
/// the position is found, and false if it isn't.
/// transposition table. Returns a pointer to the TTEntry or NULL
/// if position is not found.
const TTEntry* TranspositionTable::retrieve(const Position &pos) const {
bool TranspositionTable::retrieve(const Position &pos, Value *value,
Depth *d, Move *move,
ValueType *type) const {
TTEntry *tte = first_entry(pos);
for (int i = 0; i < 4; i++)
{
tte += i;
if (tte->key() == pos.get_key())
{
*value = tte->value();
*type = tte->type();
*d = tte->depth();
*move = tte->move();
return true;
}
return tte;
}
*move = MOVE_NONE;
return false;
return NULL;
}
@ -222,28 +213,4 @@ TTEntry::TTEntry(Key k, Value v, ValueType t, Depth d, Move m,
value_(v), depth_(int16_t(d)) {}
/// Functions for extracting data from TTEntry objects.
inline Key TTEntry::key() const {
return key_;
}
inline Depth TTEntry::depth() const {
return Depth(depth_);
}
inline Move TTEntry::move() const {
return Move(data & 0x7FFFF);
}
inline Value TTEntry::value() const {
return Value(value_);
}
inline ValueType TTEntry::type() const {
return ValueType((data >> 20) & 3);
}
inline int TTEntry::generation() const {
return (data >> 23);
}

16
src/tt.h
View File

@ -40,12 +40,12 @@ class TTEntry {
public:
TTEntry();
TTEntry(Key k, Value v, ValueType t, Depth d, Move m, int generation);
Key key() const;
Depth depth() const;
Move move() const;
Value value() const;
ValueType type() const;
int generation() const;
Key key() const { return key_; }
Depth depth() const { return Depth(depth_); }
Move move() const { return Move(data & 0x7FFFF); }
Value value() const { return Value(value_); }
ValueType type() const { return ValueType((data >> 20) & 3); }
int generation() const { return (data >> 23); }
private:
Key key_;
@ -54,7 +54,6 @@ private:
int16_t depth_;
};
/// The transposition table class. This is basically just a huge array
/// containing TTEntry objects, and a few methods for writing new entries
/// and reading new ones.
@ -67,8 +66,7 @@ public:
void set_size(unsigned mbSize);
void clear();
void store(const Position &pos, Value v, Depth d, Move m, ValueType type);
bool retrieve(const Position &pos, Value *value, Depth *d, Move *move,
ValueType *type) const;
const TTEntry* retrieve(const Position &pos) const;
void new_search();
void insert_pv(const Position &pos, Move pv[]);
int full();