[gnugo-devel] persistent reading cache consistency checking

[Evan Berggren Daniel]

This patch implements delete_persistent_reading_entry(), and makes
attack_and_defend() delete conflicting entries and redo the reading.

It has only been given cursory testing, because I do not know how to
reproduce the inconsistencies.

Thanks

Evan Daniel

Index: engine/liberty.h
===================================================================
RCS file: /cvsroot/gnugo/gnugo/engine/liberty.h,v
retrieving revision 1.124
diff -u -r1.124 liberty.h
--- engine/liberty.h    9 Oct 2002 18:36:23 -0000       1.124
+++ engine/liberty.h    9 Oct 2002 19:47:04 -0000
@@ -301,6 +301,7 @@
                                    int *move);
 void store_persistent_reading_cache(int routine, int str, int result,
                                    int move, int nodes);
+void delete_persistent_reading_entry(int index);
 void reading_hotspots(float values[BOARDMAX]);
 void purge_persistent_owl_cache(void);
 int search_persistent_owl_cache(int routine, int apos, int bpos, int cpos,
Index: engine/persistent.c
===================================================================
RCS file: /cvsroot/gnugo/gnugo/engine/persistent.c,v
retrieving revision 1.1
diff -u -r1.1 persistent.c
--- engine/persistent.c 26 Sep 2002 20:04:36 -0000      1.1
+++ engine/persistent.c 9 Oct 2002 19:47:04 -0000
@@ -265,7 +265,9 @@
 }


-/* Look for a valid read result in the persistent cache. */
+/* Look for a valid read result in the persistent cache.
+ * Return index of the entry found if there is a match, -1 if no match
+ */
 int
 search_persistent_reading_cache(int routine, int str, int *result, int *move)
 {
@@ -298,7 +300,8 @@

     /* Matched alright. Increase score, fill in the answer, and return. */
     entry->score += entry->nodes;
-    *result = entry->result;
+    if (result)
+      *result = entry->result;
     if (move)
       *move = entry->move;
     ASSERT1(entry->result == 0
@@ -319,10 +322,10 @@
       dump_stack();
     }

-    return 1;
+    return k;
   }

-  return 0;
+  return -1;
 }


@@ -472,6 +475,15 @@
   }

   persistent_reading_cache_size++;
+}
+
+/*delete an entry from the cache, given its index*/
+void
+delete_persistent_reading_entry(int index)
+{
+  gg_assert(index >= 0 && index < persistent_reading_cache_size);
+  persistent_reading_cache[index]
+         = persistent_reading_cache[--persistent_reading_cache_size];
 }


Index: engine/reading.c
===================================================================
RCS file: /cvsroot/gnugo/gnugo/engine/reading.c,v
retrieving revision 1.79
diff -u -r1.79 reading.c
--- engine/reading.c    8 Oct 2002 19:42:05 -0000       1.79
+++ engine/reading.c    9 Oct 2002 19:47:04 -0000
@@ -248,7 +248,7 @@
     return 0;

   origin = find_origin(str);
-  if (search_persistent_reading_cache(ATTACK, origin, &result, &the_move)) {
+  if (search_persistent_reading_cache(ATTACK, origin, &result, &the_move) != 
-1) {
     if (move)
       *move = the_move;
     return result;
@@ -311,7 +311,7 @@

   origin = find_origin(str);
   if (search_persistent_reading_cache(FIND_DEFENSE, origin,
-                                     &result, &the_move)) {
+                                     &result, &the_move) != -1) {
     if (move)
       *move = the_move;
     return result;
@@ -379,11 +379,21 @@
      * incorrect, but we can't easily find a defense point to return.
      */
     if (dcode == WIN && dpos == NO_MOVE) {
-      acode = 0;
-      apos = NO_MOVE;
+      int ai, di;
+      ai = search_persistent_reading_cache(ATTACK, str, NULL, NULL);
+      di = search_persistent_reading_cache(FIND_DEFENSE, str, NULL, NULL);
+      if (ai != -1)
+        delete_persistent_reading_entry(ai);
+      if (di != -1)
+        delete_persistent_reading_entry(di);
+      acode = attack(str, &apos);
+      if (acode != 0)
+        dcode = find_defense(str, &dpos);
     }
   }

+  gg_assert(!((acode != 0) && (dcode == WIN && dpos == NO_MOVE)));
+
   if (attack_code)
     *attack_code = acode;
   if (attack_point)