Thread local (lockfree) hash, ported from acepck's PR to egaroucid

Author: okuhara

src/endgame.c

@@ -339,7 +339,7 @@ static int search_solve_4(Search *search, int alpha)
 #endif
 
 /**
- * @brief  Evaluate a position using a shallow NWS.
+ * @brief  Evaluate a position using a shallow NWS. (5..6 empties)
  *
  * This function is used when there are few empty squares on the board. Here,
  * optimizations are in favour of speed instead of efficiency.
@@ -444,7 +444,7 @@ static int search_shallow(Search *search, const int alpha, bool pass1)
 }
 
 /**
- * @brief Evaluate an endgame position with a Null Window Search algorithm.
+ * @brief Evaluate an endgame position with a Null Window Search algorithm. (7..9 empties)
  *
  * This function is used when there are still many empty squares on the board. Move
  * ordering, hash table cutoff, enhanced transposition cutoff, etc. are used in
@@ -455,7 +455,8 @@ static int search_shallow(Search *search, const int alpha, bool pass1)
  * @param alpha Alpha bound.
  * @return The final score, as a disc difference.
  */
-int NWS_endgame(Search *search, const int alpha)
+
+static int NWS_endgame_local(Search *search, const int alpha)
 {
 	int score, ofssolid, bestscore;
 	unsigned long long hash_code, solid_opp;
@@ -491,34 +492,32 @@ int NWS_endgame(Search *search, const int alpha)
 		// Improvement of Serch by Reducing Redundant Information in a Position of Othello
 		// Hidekazu Matsuo, Shuji Narazaki
 		// http://id.nii.ac.jp/1001/00156359/
-		if (search->eval.n_empties <= MASK_SOLID_DEPTH) {	// (99%)
-			solid_opp = full[4] & hashboard.opponent;	// full[4] = all full
+		solid_opp = full[4] & hashboard.opponent;	// full[4] = all full
 #ifndef POPCOUNT
-			if (solid_opp)	// (72%)
+		if (solid_opp)	// (72%)
 #endif
-			{
-				hashboard.player ^= solid_opp;	// normalize solid to player
-				hashboard.opponent ^= solid_opp;
-				ofssolid = bit_count(solid_opp) * 2;	// hash score is ofssolid grater than real
-			}
+		{
+			hashboard.player ^= solid_opp;	// normalize solid to player
+			hashboard.opponent ^= solid_opp;
+			ofssolid = bit_count(solid_opp) * 2;	// hash score is ofssolid grater than real
 		}
 	}
 
 	hash_code = board_get_hash_code(&hashboard);
-	hash_prefetch(&search->hash_table, hash_code);
+	PREFETCH(search->thread_hash.hash + (hash_code & search->thread_hash.hash_mask));
 
 	search_get_movelist(search, &movelist);
 
 	if (movelist.n_moves > 1) {	// (96%)
 		// transposition cutoff
-		if (hash_get(&search->hash_table, &hashboard, hash_code, &hash_data.data)) {	// (6%)
+		if (hash_get_local(&search->thread_hash, &hashboard, hash_code, &hash_data.data)) {	// (6%)
 			hash_data.data.lower -= ofssolid;
 			hash_data.data.upper -= ofssolid;
 			if (search_TC_NWS(&hash_data.data, search->eval.n_empties, NO_SELECTIVITY, alpha, &score))	// (6%)
 				return score;
 		}
 		// else if (ofssolid)	// slows down
-		//	hash_get_from_board(&search->hash_table, HBOARD_V(board0), &hash_data.data);
+		//	hash_get_from_board(&search->thread_hash, HBOARD_V(board0), &hash_data.data);
 
 		movelist_evaluate_fast(&movelist, search, &hash_data.data);
 
@@ -547,7 +546,7 @@ int NWS_endgame(Search *search, const int alpha)
 				search->eval.parity = parity0 ^ QUADRANT_ID[move->x];
 				empty_remove(search->empties, move->x);
 				vboard_update(&search->board, board0, move);
-				score = -NWS_endgame(search, ~alpha);
+				score = -NWS_endgame_local(search, ~alpha);
 				empty_restore(search->empties, move->x);
 				search->board = board0.board;
 
@@ -565,12 +564,12 @@ int NWS_endgame(Search *search, const int alpha)
 
 		hash_data.data.wl.c.depth = search->eval.n_empties;
 		hash_data.data.wl.c.selectivity = NO_SELECTIVITY;
-		hash_data.data.wl.c.cost = last_bit(search->n_nodes - nodes_org);
+		// hash_data.data.wl.c.cost = last_bit(search->n_nodes - nodes_org);
 		// hash_data.data.move[0] = bestmove;
 		hash_data.alpha = alpha + ofssolid;
 		hash_data.beta = alpha + ofssolid + 1;
 		hash_data.score = bestscore + ofssolid;
-		hash_store(&search->hash_table, &hashboard, hash_code, &hash_data);
+		hash_store_local(&search->thread_hash, &hashboard, hash_code, &hash_data);
 
 	// special cases
 	} else if (movelist.n_moves == 1) {	// (3%)
@@ -581,12 +580,130 @@ int NWS_endgame(Search *search, const int alpha)
 		vboard_update(&search->board, board0, move);
 		if (--search->eval.n_empties <= DEPTH_TO_SHALLOW_SEARCH)	// (56%)
 			bestscore = -search_shallow(search, ~alpha, false);
-		else	bestscore = -NWS_endgame(search, ~alpha);
+		else	bestscore = -NWS_endgame_local(search, ~alpha);
 		++search->eval.n_empties;
 		empty_restore(search->empties, move->x);
 		search->eval.parity = parity0;
 		search->board = board0.board;
 
+	} else {	// (1%)
+		if (can_move(search->board.opponent, search->board.player)) { // pass
+			search_pass(search);
+			bestscore = -NWS_endgame_local(search, ~alpha);
+			search_pass(search);
+		} else  { // game over
+			bestscore = search_solve(search);
+		}
+	}
+
+	if (SQUARE_STATS(1) + 0) {
+		foreach_move(move, movelist)
+			++statistics.n_played_square[search->eval.n_empties][SQUARE_TYPE[move->x]];
+		if (bestscore > alpha)
+			++statistics.n_good_square[search->eval.n_empties][SQUARE_TYPE[bestscore]];
+	}
+ 	assert(SCORE_MIN <= bestscore && bestscore <= SCORE_MAX);
+ 	assert((bestscore & 1) == 0);
+	return bestscore;
+}
+
+/**
+ * @brief Evaluate an endgame position with a Null Window Search algorithm. (10..15 empties)
+ *
+ * This function is used when there are still many empty squares on the board. Move
+ * ordering, hash table cutoff, enhanced transposition cutoff, etc. are used in
+ * order to diminish the size of the tree to analyse, but at the expense of a
+ * slower speed.
+ *
+ * @param search Search.
+ * @param alpha Alpha bound.
+ * @return The final score, as a disc difference.
+ */
+int NWS_endgame(Search *search, const int alpha)
+{
+	int score, bestscore;
+	unsigned long long hash_code;
+	// const int beta = alpha + 1;
+	HashStoreData hash_data;
+	Move *move;
+	long long nodes_org;
+	V2DI board0;
+	Board hashboard;
+	unsigned int parity0;
+	unsigned long long full[5];
+	MoveList movelist;
+
+	assert(bit_count(~(search->board.player|search->board.opponent)) < DEPTH_MIDGAME_TO_ENDGAME);
+	assert(SCORE_MIN <= alpha && alpha <= SCORE_MAX);
+
+	if (search->eval.n_empties <= DEPTH_TO_USE_LOCAL_HASH)
+		return NWS_endgame_local(search, alpha);
+
+	if (search->stop) return alpha;
+
+	SEARCH_STATS(++statistics.n_NWS_endgame);
+	SEARCH_UPDATE_INTERNAL_NODES(search->n_nodes);
+
+	// stability cutoff
+	hashboard = board0.board = search->board;
+	if (USE_SC && alpha >= NWS_STABILITY_THRESHOLD[search->eval.n_empties]) {	// (7%)
+		CUTOFF_STATS(++statistics.n_stability_try;)
+		score = SCORE_MAX - 2 * get_stability(search->board.opponent, search->board.player);
+		if (score <= alpha) {	// (3%)
+			CUTOFF_STATS(++statistics.n_stability_low_cutoff;)
+			return score;
+		}
+	}
+
+	hash_code = board_get_hash_code(&hashboard);
+	hash_prefetch(&search->hash_table, hash_code);
+
+	search_get_movelist(search, &movelist);
+
+	if (movelist.n_moves > 0) {	// (96%)
+		// transposition cutoff
+		if (hash_get(&search->hash_table, &hashboard, hash_code, &hash_data.data)) {	// (6%)
+			if (search_TC_NWS(&hash_data.data, search->eval.n_empties, NO_SELECTIVITY, alpha, &score))	// (6%)
+				return score;
+		}
+		if (movelist.n_moves > 1)
+			movelist_evaluate_fast(&movelist, search, &hash_data.data);
+
+		nodes_org = search->n_nodes;
+		parity0 = search->eval.parity;
+		bestscore = -SCORE_INF;
+		// loop over all moves
+		move = &movelist.move[0];
+		--search->eval.n_empties;	// for next move
+		while ((move = move_next_best(move))) {	// (76%)
+			search->eval.parity = parity0 ^ QUADRANT_ID[move->x];
+			empty_remove(search->empties, move->x);
+			vboard_update(&search->board, board0, move);
+			score = -NWS_endgame(search, ~alpha);
+			empty_restore(search->empties, move->x);
+			search->board = board0.board;
+
+			if (score > bestscore) {	// (63%)
+				bestscore = score;
+				hash_data.data.move[0] = move->x;
+				if (bestscore > alpha) break;	// (39%)
+			}
+		}
+		++search->eval.n_empties;
+		search->eval.parity = parity0;
+
+		if (search->stop)	// (1%)
+			return alpha;
+
+		hash_data.data.wl.c.depth = search->eval.n_empties;
+		hash_data.data.wl.c.selectivity = NO_SELECTIVITY;
+		hash_data.data.wl.c.cost = last_bit(search->n_nodes - nodes_org);
+		// hash_data.data.move[0] = bestmove;
+		hash_data.alpha = alpha;
+		hash_data.beta = alpha + 1;
+		hash_data.score = bestscore;
+		hash_store(&search->hash_table, &hashboard, hash_code, &hash_data);
+
 	} else {	// (1%)
 		if (can_move(search->board.opponent, search->board.player)) { // pass
 			search_pass(search);

src/hash.c

@@ -707,3 +707,56 @@ void hash_print(const HashData *data, FILE *f)
 	fprintf(f, "score = [%+02d, %+02d] ; ", data->lower, data->upper);
 	fprintf(f, "level = %2d:%2d:%2d@%3d%%", data->wl.c.date, data->wl.c.cost, data->wl.c.depth, selectivity_table[data->wl.c.selectivity].percent);
 }
+
+/**
+ * @brief Thead local (lockfree), 1-way version of hash_store
+ *
+ * @param hash_table Hash table to update.
+ * @param board Bitboard.
+ * @param hash_code  Hash code of an othello board.
+ * @param storedata.alpha      Alpha bound when calling the alphabeta function.
+ * @param storedata.beta       Beta bound when calling the alphabeta function.
+ * @param storedata.score      Best score found.
+ * @param storedata.move       Best move found.
+ */
+void hash_store_local(HashTable *hash_table, const Board *board, const unsigned long long hash_code, HashStoreData *storedata)
+{
+	Hash *hash = hash_table->hash + (hash_code & hash_table->hash_mask);
+	HashData *data = &hash->data;
+	int score = storedata->score;
+	if (board_equal(&hash->board, board)) {	// data_update
+		if (score < storedata->beta && score < data->upper) data->upper = score;
+		if (score > storedata->alpha && score > data->lower) data->lower = score;
+		// if (storedata->data.wl.c.cost > data->wl.c.cost)
+		//	data->wl.c.cost = storedata->data.wl.c.cost;
+	} else {	// data_new
+		hash->board = *board;
+		if (score < storedata->beta) data->upper = score; else data->upper = SCORE_MAX;
+		if (score > storedata->alpha) data->lower = score; else data->lower = SCORE_MIN;
+		data->wl = storedata->data.wl;
+		data->move[0] = NOMOVE;
+	}
+	if (score > storedata->alpha || score == SCORE_MIN)
+		data->move[0] = storedata->data.move[0];
+}
+
+/**
+ * @brief Thead local (lockfree), 1-way version of hash_get
+ *
+ * @param hash_table Hash table.
+ * @param board Bitboard.
+ * @param hash_code Hash code of an othello board.
+ * @param data Output hash data.
+ * @return True the board was found, false otherwise.
+ */
+bool hash_get_local(HashTable *hash_table, const Board *board, const unsigned long long hash_code, HashData *data)
+{
+	Hash *hash = hash_table->hash + (hash_code & hash_table->hash_mask);
+	if (board_equal(&hash->board, board)) {
+		*data = hash->data;
+		return true;
+	} else {
+		*data = HASH_DATA_INIT;
+		return false;
+	}
+}

src/hash.h

@@ -100,25 +100,28 @@ bool hash_get_from_board(HashTable*, const Board *, HashData *);
 void hash_exclude_move(HashTable*, const Board *, const unsigned long long, const int);
 void hash_copy(const HashTable*, HashTable*);
 void hash_print(const HashData*, FILE*);
+void hash_store_local(HashTable *, const Board *, const unsigned long long, HashStoreData *);
+bool hash_get_local(HashTable*, const Board *, const unsigned long long, HashData *);
 extern unsigned int writeable_level(HashData *data);
 
 extern const HashData HASH_DATA_INIT;
 
+#ifdef hasSSE2
+	#define	PREFETCH(P)	_mm_prefetch((char const *)(P), _MM_HINT_T0)
+#elif defined(__ARM_ACLE)
+	#define	PREFETCH(P)	__pld(P)
+#elif defined(__GNUC__)
+	#define	PREFETCH(P)	__builtin_prefetch(P)
+#elif defined(_M_ARM) || defined(_M_ARM64)
+  	#define	PREFETCH(P)	__prefetch(P)
+#else
+	#define	PREFETCH(P)
+#endif
+
 inline void hash_prefetch(HashTable *hashtable, unsigned long long hashcode) {
 	Hash *p = hashtable->hash + (hashcode & hashtable->hash_mask);
-  #ifdef hasSSE2
-	_mm_prefetch((char const *) p, _MM_HINT_T0);
-	_mm_prefetch((char const *)(p + HASH_N_WAY - 1), _MM_HINT_T0);
-  #elif defined(__ARM_ACLE)
-	__pld(p);
-	__pld(p + HASH_N_WAY - 1);
-  #elif defined(__GNUC__)
-	__builtin_prefetch(p);
-	__builtin_prefetch(p + HASH_N_WAY - 1);
-  #elif defined(_M_ARM) || defined(_M_ARM64)
-  	__prefetch(p);
-  	__prefetch(p + HASH_N_WAY - 1);
-  #endif
+	PREFETCH(p);
+	PREFETCH(p + HASH_N_WAY - 1);
 }
 
 #endif

src/midgame.c

@@ -841,7 +841,7 @@ int PVS_midgame(Search *search, const int alpha, const int beta, int depth, Node
 		hash_store(&search->pv_table, &search->board, hash_code, &hash_data);
 
 		// store solid-normalized for endgame TC
-		if (search->eval.n_empties <= depth && depth <= MASK_SOLID_DEPTH && depth > DEPTH_TO_SHALLOW_SEARCH) {
+		if (search->eval.n_empties <= depth && depth <= DEPTH_TO_USE_LOCAL_HASH && depth > DEPTH_TO_SHALLOW_SEARCH) {
 			solid_opp = get_all_full_lines(search->board.player | search->board.opponent) & search->board.opponent;
 			if (solid_opp) {
 				hashboard.player = search->board.player ^ solid_opp;	// normalize solid to player
@@ -850,7 +850,7 @@ int PVS_midgame(Search *search, const int alpha, const int beta, int depth, Node
 				hash_data.alpha += ofssolid;
 				hash_data.beta += ofssolid;
 				hash_data.score += ofssolid;
-				hash_store(&search->hash_table, &hashboard, board_get_hash_code(&hashboard), &hash_data);
+				hash_store_local(&search->thread_hash, &hashboard, board_get_hash_code(&hashboard), &hash_data);
 			}
 		}
 

src/options.c

@@ -20,7 +20,7 @@
 
 /** global options with default value */
 Options options = {
-	22, // hash table size (2^22 * 24 * 1.125 = 113MB)
+	21, // hash table size (2^21 * 24 * 1.125 = 57MB)
 
 	{0,-2,-3}, // inc_sort_depth
 

src/search.c

@@ -114,8 +114,8 @@ const Selectivity selectivity_table [] = {
 /** threshold values to try stability cutoff during NWS search */
 // TODO: better values may exist.
 const signed char NWS_STABILITY_THRESHOLD[] = { // 99 = unused value...
-	 99, 99, 99, 99,  6,  8, 10, 12,
-	  8, 10, 20, 22, 24, 26, 28, 30, // 8 & 9 lowered to work best with solid stone
+	 99, 99, 99, 99,  6,  8,  8,  8,
+	  8, 10, 20, 22, 24, 26, 28, 30, // 6..9 lowered to work best with solid stone
 	 32, 34, 36, 38, 40, 42, 44, 46,
 	 48, 48, 50, 50, 52, 52, 54, 54,
 	 56, 56, 58, 58, 60, 60, 62, 62,
@@ -380,6 +380,12 @@ void search_init(Search *search)
 	search->shallow_table.hash = NULL;
 	search->shallow_table.hash_mask = 0;
 	search_resize_hashtable(search);
+	search->thread_hash.hash = mm_malloc(((1 << THREAD_LOCAL_HASH_SIZE) + HASH_N_WAY) * sizeof (Hash));
+	if (search->thread_hash.hash == NULL) {
+		fatal_error("Cannot allocate a thread hash\n");
+	}
+	search->thread_hash.hash_mask = (1 << THREAD_LOCAL_HASH_SIZE) - 1;
+	hash_cleanup(&search->thread_hash);
 
 	/* board */
 	search->board.player = search->board.opponent = 0;
@@ -460,7 +466,8 @@ void search_free(Search *search)
 	hash_free(&search->pv_table);
 	hash_free(&search->shallow_table);
 	// eval_free(search->eval);
-	
+	mm_free(search->thread_hash.hash);
+
 	task_stack_free(search->tasks);
 	free(search->tasks);
 	spin_free(search);

src/search.h

@@ -77,6 +77,7 @@ typedef struct Search {
 	HashTable hash_table;                         /**< hashtable */
 	HashTable pv_table;                           /**< hashtable for the pv */
 	HashTable shallow_table;                      /**< hashtable for short search */
+	HashTable thread_hash;                        /**< thread local hash */
 	Random random;                                /**< random generator */
 
 	struct TaskStack *tasks;                      /**< available task queue */