static score_t scout_search(searchNode *node, int depth,
uint64_t *node_count_serial) {
// Initialize the search node.
initialize_scout_node(node, depth);
// check whether we should abort
if (should_abort_check() || parallel_parent_aborted(node)) {
return 0;
}
// Pre-evaluate this position.
leafEvalResult pre_evaluation_result = evaluate_as_leaf(node, SEARCH_SCOUT);
// If we decide to stop searching, return the pre-evaluation score.
if (pre_evaluation_result.type == MOVE_EVALUATED) {
return pre_evaluation_result.score;
}
// Populate some of the fields of this search node, using some
// of the information provided by the pre-evaluation.
int hash_table_move = pre_evaluation_result.hash_table_move;
node->best_score = pre_evaluation_result.score;
node->quiescence = pre_evaluation_result.should_enter_quiescence;
// Grab the killer-moves for later use.
move_t killer_a = killer[KMT(node->ply, 0)];
move_t killer_b = killer[KMT(node->ply, 1)];
// Store the sorted move list on the stack.
// MAX_NUM_MOVES is all that we need.
sortable_move_t move_list[MAX_NUM_MOVES];
// Obtain the sorted move list.
int num_of_moves = get_sortable_move_list(node, move_list, hash_table_move);
int number_of_moves_evaluated = 0;
// A simple mutex. See simple_mutex.h for implementation details.
simple_mutex_t node_mutex;
init_simple_mutex(&node_mutex);
// Sort the move list.
sort_incremental(move_list, num_of_moves, 0);
moveEvaluationResult result;
for (int mv_index = 0; mv_index < num_of_moves; mv_index++) {
if (mv_index == 1) {
sort_full(move_list, num_of_moves);
// sortable_move_t new_move_list[MAX_NUM_MOVES];
//memcpy(new_move_list, move_list, num_of_moves*sizeof(sortable_move_t));
//: sort_incremental_full(move_list,num_of_moves);
}
// Get the next move from the move list.
int local_index = number_of_moves_evaluated++;
move_t mv = get_move(move_list[local_index]);
if (TRACE_MOVES) {
print_move_info(mv, node->ply);
}
// increase node count
__sync_fetch_and_add(node_count_serial, 1);
evaluateMove(&result, node, mv, killer_a, killer_b,
SEARCH_SCOUT,
node_count_serial);
undo_move(&result.next_node, mv);
if (result.type == MOVE_ILLEGAL || result.type == MOVE_IGNORE
|| abortf || parallel_parent_aborted(node)) {
continue;
}
// A legal move is a move that's not KO, but when we are in quiescence
// we only want to count moves that has a capture.
if (result.type == MOVE_EVALUATED) {
node->legal_move_count++;
}
// process the score. Note that this mutates fields in node.
bool cutoff = search_process_score(node, mv, local_index, &result, SEARCH_SCOUT);
if (cutoff) {
node->abort = true;
break;
}
}
if (parallel_parent_aborted(node)) {
return 0;
}
if (node->quiescence == false) {
update_best_move_history(node->position, node->best_move_index,
move_list, number_of_moves_evaluated);
}
tbassert(abs(node->best_score) != -INF, "best_score = %d\n",
node->best_score);
// Reads node->position->key, node->depth, node->best_score, and node->ply
update_transposition_table(node);
return node->best_score;
}
score_t searchRoot(position_t *p, score_t alpha, score_t beta, int depth,
int ply, move_t *pv, uint64_t *node_count_serial,
FILE *OUT) {
static int num_of_moves = 0; // number of moves in list
// hopefully, more than we will need
static sortable_move_t move_list[MAX_NUM_MOVES];
if (depth == 1) {
// we are at depth 1; generate all possible moves
num_of_moves = generate_all_opt(p, move_list, false);
// shuffle the list of moves
for (int i = 0; i < num_of_moves; i++) {
int r = myrand() % num_of_moves;
sortable_move_t tmp = move_list[i];
move_list[i] = move_list[r];
move_list[r] = tmp;
}
}
searchNode rootNode;
rootNode.parent = NULL;
initialize_root_node(&rootNode, alpha, beta, depth, ply, p);
assert(rootNode.best_score == alpha); // initial conditions
searchNode next_node;
next_node.subpv[0] = 0;
next_node.parent = &rootNode;
score_t score;
for (int mv_index = 0; mv_index < num_of_moves; mv_index++) {
move_t mv = get_move(move_list[mv_index]);
if (TRACE_MOVES) {
print_move_info(mv, ply);
}
(*node_count_serial)++;
// make the move.
victims_t x = make_move(&(rootNode.position), &(next_node.position), mv);
if (is_KO(x)) {
continue; // not a legal move
}
if (is_game_over(x, rootNode.pov, rootNode.ply)) {
score = get_game_over_score(x, rootNode.pov, rootNode.ply);
next_node.subpv[0] = 0;
goto scored;
}
if (is_repeated(&(next_node.position), rootNode.ply)) {
score = get_draw_score(&(next_node.position), rootNode.ply);
next_node.subpv[0] = 0;
goto scored;
}
if (mv_index == 0 || rootNode.depth == 1) {
// We guess that the first move is the principle variation
score = -searchPV(&next_node, rootNode.depth-1, node_count_serial);
// Check if we should abort due to time control.
if (abortf) {
return 0;
}
} else {
score = -scout_search(&next_node, rootNode.depth-1, node_count_serial);
// Check if we should abort due to time control.
if (abortf) {
return 0;
}
// If its score exceeds the current best score,
if (score > rootNode.alpha) {
score = -searchPV(&next_node, rootNode.depth-1, node_count_serial);
// Check if we should abort due to time control.
if (abortf) {
return 0;
}
}
}
scored:
// only valid for the root node:
tbassert((score > rootNode.best_score) == (score > rootNode.alpha),
"score = %d, best = %d, alpha = %d\n", score, rootNode.best_score, rootNode.alpha);
if (score > rootNode.best_score) {
tbassert(score > rootNode.alpha, "score: %d, alpha: %d\n", score, rootNode.alpha);
rootNode.best_score = score;
pv[0] = mv;
memcpy(pv+1, next_node.subpv, sizeof(move_t) * (MAX_PLY_IN_SEARCH - 1));
pv[MAX_PLY_IN_SEARCH - 1] = 0;
// Print out based on UCI (universal chess interface)
double et = elapsed_time();
char pvbuf[MAX_PLY_IN_SEARCH * MAX_CHARS_IN_MOVE];
getPV(pv, pvbuf, MAX_PLY_IN_SEARCH * MAX_CHARS_IN_MOVE);
if (et < 0.00001) {
et = 0.00001; // hack so that we don't divide by 0
}
uint64_t nps = 1000 * *node_count_serial / et;
fprintf(OUT, "info depth %d move_no %d time (microsec) %d nodes %" PRIu64
" nps %" PRIu64 "\n",
depth, mv_index + 1, (int) (et * 1000), *node_count_serial, nps);
fprintf(OUT, "info score cp %d pv %s\n", score, pvbuf);
// Slide this move to the front of the move list
for (int j = mv_index; j > 0; j--) {
move_list[j] = move_list[j - 1];
}
move_list[0] = mv;
}
// Normal alpha-beta logic: if the current score is better than what the
// maximizer has been able to get so far, take that new value. Likewise,
// score >= beta is the beta cutoff condition
if (score > rootNode.alpha) {
rootNode.alpha = score;
}
if (score >= rootNode.beta) {
tbassert(0, "score: %d, beta: %d\n", score, rootNode.beta);
break;
}
}
return rootNode.best_score;
}
