Ticket #148: changes2.diff

gnugo/engine/board.h

@@ -36 +36 @@
  * character access is very slow.
  */
 
+/* simple test for old machines */
+#if SIZEOF_INT >= 4
+#define INT_INTERSECTION
+typedef int Intersection;
+#else
 typedef unsigned char Intersection;
+#endif
 
 /* FIXME: This is very ugly but we can't include hash.h until we have
  * defined Intersection. And we do need to include it before using
@@ -135 +141 @@
 
 /* Note that POS(-1, -1) == 0
  * DELTA() is defined so that POS(i+di, j+dj) = POS(i, j) + DELTA(di, dj).
+ * For details look in the documentation.
  */
 #define BOARDSIZE     ((MAX_BOARD + 2) * (MAX_BOARD + 1) + 1)
 #define BOARDMIN      (MAX_BOARD + 2)
@@ -148 +155 @@
 #define NS            (MAX_BOARD + 1)
 #define WE            1
 #define SOUTH(pos)    ((pos) + NS)
-#define WEST(pos)     ((pos) - 1)
+#define WEST(pos)     ((pos) - WE)
 #define NORTH(pos)    ((pos) - NS)
-#define EAST(pos)     ((pos) + 1)
-#define SW(pos)       ((pos) + NS - 1)
-#define NW(pos)       ((pos) - NS - 1)
-#define NE(pos)       ((pos) - NS + 1)
-#define SE(pos)       ((pos) + NS + 1)
+#define EAST(pos)     ((pos) + WE)
+#define SW(pos)       ((pos) + NS - WE)
+#define NW(pos)       ((pos) - NS - WE)
+#define NE(pos)       ((pos) - NS + WE)
+#define SE(pos)       ((pos) + NS + WE)
 #define SS(pos)       ((pos) + 2 * NS)
-#define WW(pos)       ((pos) - 2)
+#define WW(pos)       ((pos) - 2 * WE)
 #define NN(pos)       ((pos) - 2 * NS)
-#define EE(pos)       ((pos) + 2)
+#define EE(pos)       ((pos) + 2 * WE)
 
 #define DIRECT_NEIGHBORS(pos1, pos2)            \
   ((pos1) == SOUTH(pos2)                        \
@@ -260 +267 @@
 /* Functions handling the permanent board state. */
 void clear_board(void);
 int test_gray_border(void);
-void setup_board(Intersection new_board[MAX_BOARD][MAX_BOARD], int ko_pos,
-                 int *last, float new_komi, int w_captured, int b_captured);
 void add_stone(int pos, int color);
 void remove_stone(int pos);
 void play_move(int pos, int color);
@@ -271 +276 @@
 void restore_board(struct board_state *state);
 
 /* Information about the permanent board. */
-int get_last_move(void);
-int get_last_player(void);
+inline int get_last_move(void);
+inline int get_last_player(void);
 int get_last_opponent_move(int color);
 int stones_on_board(int color);
 
 /* Functions handling the variable board state. */
-int trymove(int pos, int color, const char *message, int str);
+int trymove(int pos, int color, const char *message, int str_pos);
 int tryko(int pos, int color, const char *message);
 void popgo(void);
 int komaster_trymove(int pos, int color,
                      const char *message, int str,
                      int *is_conditional_ko, int consider_conditional_ko);
-int get_komaster(void);
-int get_kom_pos(void);
+inline int get_komaster(void);
+inline int get_kom_pos(void);
 
 int move_in_stack(int pos, int cutoff);
-void get_move_from_stack(int k, int *move, int *color);
+inline void get_move_from_stack(int k, int *move, int *color);
 void dump_stack(void);
 void do_dump_stack(void);
 
-void reset_trymove_counter(void);
-int get_trymove_counter(void);
+void dump_incremental_board(void);
+
+inline void reset_trymove_counter(void);
+inline int get_trymove_counter(void);
 
 /* move properties */
-int is_pass(int pos);
+inline int is_pass(int pos);
 int is_legal(int pos, int color);
 int is_suicide(int pos, int color);
-int is_illegal_ko_capture(int pos, int color);
+inline int is_illegal_ko_capture(int pos, int color);
 int is_allowed_move(int pos, int color);
 int is_ko(int pos, int color, int *ko_pos);
 int is_ko_point(int pos);
@@ -306 +313 @@
 int is_self_atari(int pos, int color);
 
 /* Purely gemoetric functions */
-int is_edge_vertex(int pos);
-int is_corner_vertex(int pos);
-int edge_distance(int pos);
-int square_dist(int pos1, int pos2);
+inline int is_edge_vertex(int pos);
+inline int is_corner_vertex(int pos);
+inline int edge_distance(int pos);
+inline int square_dist(int pos1, int pos2);
 
 /* Basic string information. */
-int find_origin(int str);
-int chainlinks(int str, int adj[MAXCHAIN]);
-int chainlinks2(int str, int adj[MAXCHAIN], int lib);
-int chainlinks3(int str, int adj[MAXCHAIN], int lib);
-int extended_chainlinks(int str, int adj[MAXCHAIN], int both_colors);
-
-int liberty_of_string(int pos, int str);
-int second_order_liberty_of_string(int pos, int str);
-int neighbor_of_string(int pos, int str);
-int has_neighbor(int pos, int color);
-int same_string(int str1, int str2);
-int adjacent_strings(int str1, int str2);
+inline int find_origin(int str_pos);
+int chainlinks(int str_pos, int adj[MAXCHAIN]);
+int chainlinks2(int str_pos, int adj[MAXCHAIN], int lib);
+int chainlinks3(int str_pos, int adj[MAXCHAIN], int lib);
+int extended_chainlinks(int str_pos, int adj[MAXCHAIN], int both_colors);
+
+int liberty_of_string(int pos, int str_pos);
+int liberty_of_string2(int pos, int str_pos);
+int second_order_liberty_of_string(int pos, int str_pos);
+int neighbor_of_string(int pos, int str_pos);
+inline int has_neighbor(int pos, int color);
+inline int same_string(int str1_pos, int str2_pos);
+int adjacent_strings(int str1_pos, int str2_pos);
 void mark_string(int str, signed char mx[BOARDMAX], signed char mark);
 int are_neighbors(int pos1, int pos2);
 
-/* Count and/or find liberties at (pos). */
-int countlib(int str);
-int findlib(int str, int maxlib, int *libs);
+/* Count and/or find liberties at (pos) */
+inline int countlib(int str_pos);
+int findlib(int str_pos, int maxlib, int *libs);
 int fastlib(int pos, int color, int ignore_captures);
 int approxlib(int pos, int color, int maxlib, int *libs);
 int accuratelib(int pos, int color, int maxlib, int *libs);
-int count_common_libs(int str1, int str2);
-int find_common_libs(int str1, int str2, int maxlib, int *libs);
-int have_common_lib(int str1, int str2, int *lib);
+int count_common_libs(int str1_pos, int str2_pos);
+int find_common_libs(int str1_pos, int str2_pos, int maxlib, int *libs);
+int have_common_lib(int str1_pos, int str2_pos, int *lib);
 
 /* Count the number of stones in a string. */
-int countstones(int str);
-int findstones(int str, int maxstones, int *stones);
-int count_adjacent_stones(int str1, int str2, int maxstones);
+inline int countstones(int str_pos);
+int findstones(int str_pos, int maxstones, int *stones);
+int count_adjacent_stones(int str1_pos, int str2_pos, int maxstones);
 
 /* Special function for reading.c */
-void incremental_order_moves(int move, int color, int string,
+void incremental_order_moves(int move, int color, int target_pos,
                              int *number_edges, int *number_same_string,
                              int *number_own, int *number_opponent,
                              int *captured_stones, int *threatened_stones,
                              int *saved_stones, int *number_open);
 
 /* Board caches initialization functions. */
-void clear_approxlib_cache(void);
-void clear_accuratelib_cache(void);
+inline void clear_approxlib_cache(void);
+inline void clear_accuratelib_cache(void);
   
 
 /* Is this point inside the board? */
@@ -381 +389 @@
  * south, west, north, east, southwest, northwest, northeast, southeast.
  * Defined in board.c.
  */
-extern int deltai[8]; /* = { 1,  0, -1,  0,  1, -1, -1, 1}; */
-extern int deltaj[8]; /* = { 0, -1,  0,  1, -1, -1,  1, 1}; */
-extern int delta[8];  /* = { NS, -1, -NS, 1, NS-1, -NS-1, -NS+1, NS+1}; */
+extern const int deltai[8]; /* = { 1,  0, -1,  0,  1, -1, -1, 1}; */
+extern const int deltaj[8]; /* = { 0, -1,  0,  1, -1, -1,  1, 1}; */
+extern const int delta[8];  /* = { NS, -WE, -NS, WE, NS-WE, -NS-WE, -NS+WE, NS+WE}; */
 
 
 

gnugo/engine/boardlib.c

@@ -29 +29 @@
 /* The board state itself. */
 int          board_size = DEFAULT_BOARD_SIZE; /* board size */
 Intersection board[BOARDSIZE];
-int          board_ko_pos;
+int          board_ko_pos;      /* Position of a ko (captured stone). */
 int          white_captured;    /* number of black and white stones captured */
 int          black_captured;
 
@@ -54 +54 @@
 /* Hashing of positions. */
 Hash_data board_hash;
 
-int stackp;             /* stack pointer */
+int stackp;             /* moves stack depth */
 int position_number;    /* position number */
 
 /* Some statistics gathered partly in board.c and hash.c */

gnugo/engine/breakin.c

@@ -367 +367 @@
 
         if (used[pos2])
           break;
-      }
+          }
 
       used[pos] = 1;
       if (ON_BOARD(pos2))
@@ -440 +440 @@
   }
 }
 
-void
+inline void
 clear_break_in_list()
 {
   num_break_ins = 0;

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)) {
-
+  else if (hashdata_is_equal(hashval, newest->key))
+  {
     /* 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;
+    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;
+      }
     }
-
   }
-  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 {
+  /* 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
+  {
     /* 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;

gnugo/engine/cache.h

@@ -32 +32 @@
  * (Reading/Hashing) for more information.  
  */
 
+#if SIZEOF_INT == 4
+  typedef unsigned int HASHNODE_DATATYPE;
+#elif SIZEOF_LONG == 4
+  typedef unsigned long HASHNODE_DATATYPE;
+#elif SIZEOF_INT > 4
+  typedef unsigned short HASHNODE_DATATYPE;
+#elif
+  #error Long type size has to be at least 4 bytes.
+#endif
 
 /* Hashnode: a node stored in the transposition table.
  *
  * In addition to the position, the hash lock encodes the following data,
  * all hashed:
- *   komaster
- *   kom_pos
+ *   ko
+ *   komaster (look in doc)
+ *   kom_pos (look in doc)
  *   routine
- *   str1
- *   str2
+ *   target1
+ *   target2
  *   extra hashvalue, optional (e.g. encoding a goal array)
  *
  * The data field packs into 32 bits the following
@@ -54 +64 @@
  *   cost           :  4 bits
  *   remaining_depth:  5 bits (depth - stackp)  NOTE: HN_MAX_REMAINING_DEPTH
  *
- *   The last 9 bits together give an index for the total costs.
+ *   The last 9 bits together give a reliability index (bigger index means
+ *   more reliable result).
+ *   Values are results of analyzed position (WIN, LOSE, etc.)
  */
 typedef struct {
   Hash_data key;
-  unsigned int data; /* Should be 32 bits, but only wastes 25% if 64 bits. */
+  HASHNODE_DATATYPE data; /* 32-bit value */
 } Hashnode;
 
 #define HN_MAX_REMAINING_DEPTH 31
@@ -67 +79 @@
 /* Hashentry: an entry, with two nodes of the hash_table
  */
 typedef struct {
-  Hashnode deepest;
+  Hashnode most_reliable;
   Hashnode newest;
 } Hashentry;
 
@@ -76 +88 @@
 #define hn_get_value2(hn)           ((hn >> 19) & 0x0f)
 #define hn_get_move(hn)             ((hn >>  9) & 0x3ff)
 #define hn_get_cost(hn)             ((hn >>  5) & 0x0f)
-#define hn_get_remaining_depth(hn)  ((hn >>  0) & 0x1f)
-#define hn_get_total_cost(hn)       ((hn >>  0) & 0x1ff)
+#define hn_get_remaining_depth(hn)  ((hn/*>>  0*/) & 0x1f)
+#define hn_get_reliability(hn)      ((hn/*>>  0*/) & 0x1ff)
 
 #define hn_create_data(remaining_depth, value1, value2, move, cost) \
     ((((value1)         & 0x0f)  << 23) \
    | (((value2)         & 0x0f)  << 19) \
    | (((move)           & 0x3ff) <<  9) \
    | (((cost)           & 0x0f)  <<  5) \
-   | (((remaining_depth & 0x1f)  <<  0)))
+   | (((remaining_depth & 0x1f)/*<<  0*/)))
 
 
 /* Transposition_table: transposition table used for caching. */
 typedef struct {
   unsigned int num_entries;
   Hashentry *entries;
-  int is_clean;
 } Transposition_table;
 
 extern Transposition_table ttable;
@@ -101 +112 @@
  */
 #define DEFAULT_NUMBER_OF_CACHE_ENTRIES 350000
 
-void tt_free(Transposition_table *table);
+inline void tt_free(Transposition_table *table);
 int  tt_get(Transposition_table *table, enum routine_id routine,
             int target1, int target2, int remaining_depth,
             Hash_data *extra_hash,
@@ -141 +152 @@
   int q1 = board[str1] == EMPTY ? str1 : find_origin(str1); \
   int q2 = board[str2] == EMPTY ? str2 : find_origin(str2);
 
+#define READ_FUNCTION_NAME read_function_name
+
 #else
 
 #define TRACE_CACHED_RESULT(result, move)
 #define TRACE_CACHED_RESULT2(result1, result2, move)
 
+#ifndef GG_TURN_OFF_TRACES
+
 #define SETUP_TRACE_INFO(name, str) \
   const char *read_function_name = name; \
   int q = str;
@@ -155 +170 @@
   int q1 = str1; \
   int q2 = str2;
 
-#endif
-
-/* Trace messages in decidestring/decidedragon sgf file. */
-void sgf_trace(const char *func, int str, int move, int result,
-               const char *message);
-/* Trace messages in decideconnection sgf file. */
-void sgf_trace2(const char *func, int str1, int str2, int move, 
-                const char *result, const char *message);
-/* Trace messages in decidesemeai sgf file. */
-void sgf_trace_semeai(const char *func, int str1, int str2, int move, 
-                      int result1, int result2, const char *message);
-
 /* Macro to hide the call to sgf_trace(). Notice that a little black
  * magic is going on here. Before using this macro, SETUP_TRACE_INFO
  * must have been called to provide the variables read_function_name
@@ -190 +193 @@
     sgf_trace_semeai(read_function_name, q1, q2, move, \
                      result1, result2, message)
 
+#define READ_FUNCTION_NAME read_function_name
+
+#else // #ifndef GG_TURN_OFF_TRACES
+
+#define SETUP_TRACE_INFO(name, str)
+#define SETUP_TRACE_INFO2(name, str1, str2)
+#define SGFTRACE(move, result, message) (void)0
+#define SGFTRACE2(move, result, message) (void)0
+#define SGFTRACE_SEMEAI(move, result1, result2, message) (void)0
+#define READ_FUNCTION_NAME NULL
+
+#endif // #ifndef GG_TURN_OFF_TRACES
+
+#endif // #if TRACE_READ_RESULTS
+
+/* Trace messages in decidestring/decidedragon sgf file. */
+void sgf_trace(const char *func, int str, int move, int result,
+               const char *message);
+/* Trace messages in decideconnection sgf file. */
+void sgf_trace2(const char *func, int str1, int str2, int move, 
+                const char *result, const char *message);
+/* Trace messages in decidesemeai sgf file. */
+void sgf_trace_semeai(const char *func, int str1, int str2, int move, 
+                      int result1, int result2, const char *message);
+
 
 /* ================================================================ */
 
@@ -212 +240 @@
   do { \
     tt_update(&ttable, routine, str, NO_MOVE, remaining_depth, NULL,\
               value, 0, move);\
-    if ((value) != 0 && (point) != 0) *(point) = (move); \
+    if ((point) != NULL && (value) != 0) \
+      *(point) = (move); \
     return (value); \
   } while (0)
 
@@ -220 +249 @@
   do { \
     tt_update(&ttable, routine, str1, str2, remaining_depth, NULL, \
               value1, value2, move); \
-    if ((value1) != 0 && (point) != 0) *(point) = (move); \
+    if ((point) != NULL && (value1) != 0) \
+      *(point) = (move); \
     return; \
   } while (0)
 
@@ -228 +258 @@
   do { \
     tt_update(&ttable, routine, str1, str2, remaining_depth, NULL,\
               value, 0, move);\
-    if ((value) != 0 && (point) != 0) *(point) = (move); \
+    if ((point) != NULL && (value) != 0) \
+      *(point) = (move); \
     return (value); \
   } while (0)
 
@@ -236 +267 @@
   do { \
     tt_update(&ttable, routine, str, NO_MOVE, remaining_depth, hash,\
               value, 0, move);\
-    if ((value) != 0 && (point) != 0) *(point) = (move); \
+    if ((point) != NULL && (value) != 0) \
+      *(point) = (move); \
     return (value); \
   } while (0)
 
@@ -244 +276 @@
   do { \
     tt_update(&ttable, routine, str, NO_MOVE, remaining_depth, NULL,\
               value1, value2, move);\
-    if ((value1) != 0 && (point) != 0) *(point) = (move); \
+    if ((point) != NULL && (value1) != 0) \
+      *(point) = (move); \
     return (value1); \
   } while (0)