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();
// We're ready to start thinking. Call the iterative deepening loop
// function:
- id_loop(pos, searchMoves);
+ id_loop(pos, searchMoves);;
if(UseLogFile)
LogFile.close();
// 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];
return beta-1;
// Transposition table lookup
- bool ttFound;
- Value ttValue;
- Depth ttDepth;
- Move ttMove = MOVE_NONE;
- ValueType ttValueType;
-
- 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;
- }
- }
+ const TTEntry* tte = TT.retrieve(pos);
+
+ 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);
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
/// 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;
}
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);
-}
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_;
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.
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();