Exemplo n.º 1
0
void trans_alloc(trans_t * trans) {

    uint32 size, target;

    ASSERT(trans!=NULL);

    // calculate size

    target = option_get_int("Hash");
    if (target < 4) target = 16;
    target *= 1024 * 1024;

    for (size = 1; size != 0 && size <= target; size *= 2)
        ;

    size /= 2;
    ASSERT(size>0&&size<=target);

    // allocate table

    size /= sizeof(entry_t);
    ASSERT(size!=0&&(size&(size-1))==0); // power of 2

    trans->size = size + (ClusterSize - 1); // HACK to avoid testing for end of table
    trans->mask = size - 1;

    trans->table = (entry_t *) my_malloc(trans->size*sizeof(entry_t));

    trans_clear(trans);

    ASSERT(trans_is_ok(trans));
}
Exemplo n.º 2
0
void trans_free(trans_t * trans) {

    ASSERT(trans_is_ok(trans));

    my_free(trans->table);

    trans->table = NULL;
    trans->size = 0;
    trans->mask = 0;
}
Exemplo n.º 3
0
void trans_stats(const trans_t * trans) {

    double full;
    // double hit, collision;

    ASSERT(trans_is_ok(trans));

    full = double(trans->used) / double(trans->size);
    // hit = double(trans->read_hit) / double(trans->read_nb);
    // collision = double(trans->write_collision) / double(trans->write_nb);

    send("info hashfull %.0f",full*1000.0);
}
Exemplo n.º 4
0
static entry_t * trans_entry(trans_t * trans, uint64 key) {

    uint32 index;

    ASSERT(trans_is_ok(trans));

    if (UseModulo) {
        index = KEY_INDEX(key) % (trans->mask + 1);
    } else {
        index = KEY_INDEX(key) & trans->mask;
    }

    ASSERT(index<=trans->mask);

    return &trans->table[index];
}
Exemplo n.º 5
0
bool trans_retrieve(trans_t * trans, uint64 key, int * move, int * min_depth, int * max_depth, int * min_value, int * max_value) {

   entry_t * entry;
   int i;

   ASSERT(trans_is_ok(trans));
   ASSERT(move!=NULL);
   ASSERT(min_depth!=NULL);
   ASSERT(max_depth!=NULL);
   ASSERT(min_value!=NULL);
   ASSERT(max_value!=NULL);

   // init

   trans->read_nb++;

   // probe

   entry = trans_entry(trans,key);

   for (i = 0; i < ClusterSize; i++, entry++) {

      if (entry->lock == KEY_LOCK(key) /*^ entry->key1 ^ entry->key2 ^ entry->key3*/) {

         // found

         trans->read_hit++;
         if (entry->date != trans->date) {
            entry->date = trans->date;
            entry->lock == KEY_LOCK(key) /*^ entry->key1 ^ entry->key2 ^ entry->key3*/;
         }

         *move = entry->move;

         *min_depth = entry->min_depth;
         *max_depth = entry->max_depth;
         *min_value = entry->min_value;
         *max_value = entry->max_value;

         return true;
      }
   }

   // not found

   return false;
}
Exemplo n.º 6
0
void trans_store(trans_t * trans, uint64 key, int move, int depth, int min_value, int max_value) {

    entry_t * entry, * best_entry;
    int score, best_score;
    int i;

    ASSERT(trans_is_ok(trans));
    ASSERT(move>=0&&move<65536);
    ASSERT(depth>=-127&&depth<=+127);
    ASSERT(min_value>=-ValueInf&&min_value<=+ValueInf);
    ASSERT(max_value>=-ValueInf&&max_value<=+ValueInf);
    ASSERT(min_value<=max_value);

    // init

    trans->write_nb++;

    // probe

    best_entry = NULL;
    best_score = -32767;

    entry = trans_entry(trans,key);

    for (i = 0; i < ClusterSize; i++, entry++) {

        if (entry->lock == KEY_LOCK(key)) {

            // hash hit => update existing entry

            trans->write_hit++;
            if (entry->date != trans->date) trans->used++;

            entry->date = trans->date;

            if (trans_endgame || depth > entry->depth) entry->depth = depth;
            /* if (depth > entry->depth)  entry->depth = depth; // for replacement scheme */

            // if (move != MoveNone /* && depth >= entry->move_depth */) {
            if (move != MoveNone && (trans_endgame || depth >= entry->move_depth)) {
                entry->move_depth = depth;
                entry->move = move;
            }

            // if (min_value > -ValueInf /* && depth >= entry->min_depth */) {
            if (min_value > -ValueInf && (trans_endgame || depth >= entry->min_depth)) {
                entry->min_depth = depth;
                entry->min_value = min_value;
            }

            // if (max_value < +ValueInf /* && depth >= entry->max_depth */) {
            if (max_value < +ValueInf && (trans_endgame || depth >= entry->max_depth)) {
                entry->max_depth = depth;
                entry->max_value = max_value;
            }

            ASSERT(entry_is_ok(entry));

            return;
        }

        // evaluate replacement score

        score = trans->age[entry->date] * 256 - entry->depth;
        ASSERT(score>-32767);

        if (score > best_score) {
            best_entry = entry;
            best_score = score;
        }
    }

    // "best" entry found

    entry = best_entry;
    ASSERT(entry!=NULL);
    ASSERT(entry->lock!=KEY_LOCK(key));

    if (entry->date == trans->date) {
        trans->write_collision++;
    } else {
        trans->used++;
    }

    // store

    ASSERT(entry!=NULL);

    entry->lock = KEY_LOCK(key);
    entry->date = trans->date;

    entry->depth = depth;

    entry->move_depth = (move != MoveNone) ? depth : DepthNone;
    entry->move = move;

    entry->min_depth = (min_value > -ValueInf) ? depth : DepthNone;
    entry->max_depth = (max_value < +ValueInf) ? depth : DepthNone;
    entry->min_value = min_value;
    entry->max_value = max_value;

    ASSERT(entry_is_ok(entry));
}