Ticket #145: cache.c.patch

gnugo/engine/cache.c

@@ -39 +39 @@
 /* ---------------------------------------------------------------- */
 
 static void tt_init(Transposition_table *table, int memsize);
-static void tt_clear(Transposition_table *table);
+inline static void tt_clear(Transposition_table *table);
 
 /* The transposition table itself. */
 Transposition_table ttable;
@@ -72 +72 @@
 calculate_hashval_for_tt(Hash_data *hashdata, int routine, int target1,
                          int target2, Hash_data *extra_hash)
 { 
-  *hashdata = board_hash;                /* from globals.c */
+  *hashdata = board_hash;                /* from boardlib.c */
   hashdata_xor(*hashdata, routine_hash[routine]);
   hashdata_xor(*hashdata, target1_hash[target1]);
   if (target2 != NO_MOVE)
@@ -97 +97 @@
   keyhash_init();
 
   if (memsize > 0)
-    num_entries = memsize / sizeof(table->entries[0]);
+    num_entries = memsize / sizeof(Hashentry);
   else
     num_entries = DEFAULT_NUMBER_OF_CACHE_ENTRIES;
 
   table->num_entries = num_entries;
-  table->entries     = malloc(num_entries * sizeof(table->entries[0]));
+  table->entries     = malloc(num_entries * sizeof(Hashentry));
 
   if (table->entries == NULL) {
     perror("Couldn't allocate memory for transposition table. \n");
     exit(1);
   }
 
-  table->is_clean = 0;
   tt_clear(table);
 }
 
 
 /* Clear the transposition table. */
 
-static void
+inline static void
 tt_clear(Transposition_table *table)
 {
-  if (!table->is_clean) {
-    memset(table->entries, 0, table->num_entries * sizeof(table->entries[0]));
-    table->is_clean = 1;
-  }
+  memset(table->entries, 0, table->num_entries * sizeof(Hashentry));
 }
- 
- 
+
+
 /* Free the transposition table. */
 
-void
+inline void
 tt_free(Transposition_table *table)
 {
   free(table->entries);
 }
 
 
-/* Get result and move. Return value:
+/* Get result and move (the bigger remaining depth the lower depth).
+ * Return value:
  *   0 if not found
- *   1 if found, but depth too small to be trusted.  In this case the move
+ *   1 if found, but depth too big to be trusted.  In this case the move
  *     can be used for move ordering.
- *   2 if found and depth is enough so that the result can be trusted.
+ *   2 if found and depth is small enough so that the result can be trusted.
  */
  
 int
@@ -162 +159 @@
 
   /* Get the correct entry and node. */
   entry = &table->entries[hashdata_remainder(hashval, table->num_entries)];
-  if (hashdata_is_equal(hashval, entry->deepest.key))
-    node = &entry->deepest;
+
+  if (hashdata_is_equal(hashval, entry->most_reliable.key))
+    node = &entry->most_reliable;
   else if (hashdata_is_equal(hashval, entry->newest.key))
     node = &entry->newest;
   else
     return 0;
 
-  stats.read_result_hits++;
+#ifndef GG_TURN_OFF_STATS
+  ++stats.read_result_hits;
+#endif
 
   /* Return data.  Only set the result if remaining depth in the table
    * is big enough to be trusted.  The move can always be used for move
@@ -177 +177 @@
    */
   if (move)
     *move = hn_get_move(node->data);
+
   if (remaining_depth <= (int) hn_get_remaining_depth(node->data)) {
     if (value1)
       *value1 = hn_get_value1(node->data);
     if (value2)
       *value2 = hn_get_value2(node->data);
-    stats.trusted_read_result_hits++;
+
+#ifndef GG_TURN_OFF_STATS
+    ++stats.trusted_read_result_hits;
+#endif
+
     return 2;
   }
 
@@ -201 +206 @@
 {
   Hash_data hashval;
   Hashentry *entry;
-  Hashnode *deepest;
+  Hashnode *most_reliable;
   Hashnode *newest;
   unsigned int data;
   /* Get routine costs definitions from liberty.h. */
@@ -220 +225 @@
 
   /* Get the entry and nodes. */ 
   entry = &table->entries[hashdata_remainder(hashval, table->num_entries)];
-  deepest = &entry->deepest;
+  most_reliable = &entry->most_reliable;
   newest  = &entry->newest;
  
   /* See if we found an already existing node. */
-  if (hashdata_is_equal(hashval, deepest->key)
-      && remaining_depth >= (int) hn_get_remaining_depth(deepest->data)) {
-
-    /* Found deepest */
-    deepest->data = data;
-
+  if (hashdata_is_equal(hashval, most_reliable->key))
+  {
+          /* Found shallower node (can be trusted more likely) */
+          if (remaining_depth > (int) hn_get_remaining_depth(most_reliable->data))
+                  most_reliable->data = data;
   }
-  else if (hashdata_is_equal(hashval, newest->key)
-           && remaining_depth >= (int) hn_get_remaining_depth(newest->data)) {
-
-    /* Found newest */
-    newest->data = data;
-
-    /* If newest has become deeper than deepest, then switch them. */
-    if (hn_get_remaining_depth(newest->data)
-        > hn_get_remaining_depth(deepest->data)) {
-      Hashnode temp;
-
-      temp = *deepest;
-      *deepest = *newest;
-      *newest = temp;
-    }
-
+  else if (hashdata_is_equal(hashval, newest->key))
+  {
+          /* Found newest */
+          if (remaining_depth > (int) hn_get_remaining_depth(newest->data))
+          {
+        newest->data = data;
+
+        /* If newest reliability is bigger than most_reliable, switch them. */
+            if (hn_get_reliability(newest->data) >
+                        hn_get_reliability(most_reliable->data))
+                {
+                        Hashnode temp;
+
+                        temp = *most_reliable;
+                        *most_reliable = *newest;
+                        *newest = temp;
+                }
+          }
+  }
+  /* Have new node. */
+  else if (hn_get_reliability(data) >
+          hn_get_reliability(most_reliable->data))
+  {
+          /* Replace most_reliable. */
+          most_reliable->key  = hashval;
+          most_reliable->data = data;
   }
-  else if (hn_get_total_cost(data) > hn_get_total_cost(deepest->data)) {
-    if (hn_get_total_cost(newest->data) < hn_get_total_cost(deepest->data))
-      *newest = *deepest;
-    deepest->key  = hashval;
-    deepest->data = data;
-  } 
-  else {
+  else
+  {
     /* Replace newest. */
     newest->key  = hashval;
     newest->data = data;
   }
 
-  stats.read_result_entered++;
-  table->is_clean = 0;
+#ifndef GG_TURN_OFF_STATS
+  ++stats.read_result_entered;
+#endif
 }
 
 
@@ -270 +280 @@
 };
 
 /* Convert a routine as used in the cache table to a string. */
-const char *
+inline const char *
 routine_id_to_string(enum routine_id routine)
 {
   return routine_names[(int) routine];
@@ -282 +292 @@
  * allocate a single node or if the allocation fails, the caching is
  * disabled.
  */
-void
+inline void
 reading_cache_init(int bytes)
 {
   tt_init(&ttable, bytes);
@@ -290 +300 @@
 
 
 /* Clear the cache for read results. */
-void
+inline void
 reading_cache_clear()
 {
   tt_clear(&ttable);
 }
 
-float
+inline float
 reading_cache_default_size()
 {
   return DEFAULT_NUMBER_OF_CACHE_ENTRIES * sizeof(Hashentry) / 1024.0 / 1024.0;