static void test_timer(void)
{
int rc, state;
test_timer_t test;
diag("test_timer");
test_timer_create(&test);
pthread_mutex_lock(&test.mutex);
rc= my_timer_set(&test.timer, 5);
ok(rc == 0, "my_timer_set");
ok(test.fired == 0, "not fired yet");
while (!test.fired)
pthread_cond_wait(&test.cond, &test.mutex);
ok(test.fired == 1, "timer fired once");
rc= my_timer_reset(&test.timer, &state);
ok(rc == 0, "my_timer_reset");
ok(state == 0, "timer state was signaled");
pthread_mutex_unlock(&test.mutex);
test_timer_destroy(&test);
}
static void mess() {
// clear state variables
State->resign_nb = 0;
State->exp_move = MoveNone;
my_timer_reset(State->timer);
// abort a possible search
stop_search();
// calculate the new state
if (false) {
} else if (!active()) {
State->state = WAIT;
my_log("POLYGLOT WAIT\n");
} else if (XB->analyse) {
State->state = ANALYSE;
my_log("POLYGLOT ANALYSE\n");
} else if (State->computer[game_turn(Game)]) {
State->state = THINK;
my_log("POLYGLOT THINK\n");
} else {
State->state = WAIT;
my_log("POLYGLOT WAIT\n");
}
search_update();
}
static void search_clear() {
uci_clear(Uci);
// TODO: MOVE ME
my_timer_reset(State->timer);
my_timer_start(State->timer);
}
void adapter_loop() {
// init
game_clear(Game);
// state
State->state = WAIT;
State->computer[White] = false;
State->computer[Black] = true;
State->exp_move = MoveNone;
State->resign_nb = 0;
my_timer_reset(State->timer);
#ifndef _WIN32
// xboard
XBoard->io->in_fd = STDIN_FILENO;
XBoard->io->out_fd = STDOUT_FILENO;
XBoard->io->name = "XBOARD";
io_init(XBoard->io);
#endif
XB->analyse = false;
XB->computer = false;
XB->name = NULL;
my_string_set(&XB->name,"<empty>");
XB->ics = false;
XB->new_hack = true;
XB->ping = -1;
XB->ponder = false;
XB->post = false;
XB->proto_ver = 1;
XB->result = false;
XB->mps = 0;
XB->base = 300.0;
XB->inc = 0.0;
XB->time_limit = false;
XB->time_max = 5.0;
XB->depth_limit = false;
XB->depth_max = 127;
XB->my_time = 300.0;
XB->opp_time = 300.0;
#ifdef _WIN32
// loop
while(true)
engine_step();
#else
while (true) adapter_step();
#endif
}
void xboard2uci_init() {
// init
game_clear(Game);
// state
State->state = WAIT;
State->computer[White] = FALSE;
State->computer[Black] = TRUE;
State->exp_move = MoveNone;
State->hint_move = MoveNone;
State->resign_nb = 0;
my_timer_reset(State->timer);
// yes there are engines that do not have the "Hash" option....
XB->has_feature_memory= (option_find(Uci->option,"Hash")!=NULL);
XB->has_feature_smp = (uci_thread_option(Uci)!=NULL);
// TODO: support for other types of table bases
// This is a quick hack.
XB->has_feature_egt_nalimov = (option_find(Uci->option,"NalimovPath")!=NULL);
XB->has_feature_egt_gaviota = (option_find(Uci->option,"GaviotaTbPath")!=NULL);
XB->analyse = FALSE;
XB->computer = FALSE;
XB->name = NULL;
my_string_set(&XB->name,"<empty>");
XB->ics = FALSE;
XB->new_hack = TRUE;
XB->ping = -1;
XB->ponder = FALSE;
XB->post = FALSE;
XB->proto_ver = 1;
XB->result = FALSE;
XB->mps = 0;
XB->base = 300.0;
XB->inc = 0.0;
XB->time_limit = FALSE;
XB->time_max = 5.0;
XB->depth_limit = FALSE;
XB->depth_max = 127;
XB->my_time = 300.0;
XB->opp_time = 300.0;
XB->node_rate = -1;
}
static void timer_set_and_wait(test_timer_t *test, unsigned int fired_count)
{
int rc, state;
rc= my_timer_set(&test->timer, 5);
ok(rc == 0, "my_timer_set");
ok(test->fired != fired_count, "not fired yet");
while (test->fired != fired_count)
pthread_cond_wait(&test->cond, &test->mutex);
ok(test->fired == fired_count, "timer fired");
rc= my_timer_reset(&test->timer, &state);
ok(rc == 0, "my_timer_reset");
ok(state == 0, "timer state was signaled");
}
static void test_reset(void)
{
int rc, state;
test_timer_t test;
diag("test_reset");
test_timer_create(&test);
rc= my_timer_set(&test.timer, 3600000U);
ok(rc == 0, "my_timer_set");
rc= my_timer_reset(&test.timer, &state);
ok(rc == 0, "my_timer_reset");
ok(state == 1, "timer state is nonsignaled");
ok(test.fired == 0, "timer has not fired");
test_timer_destroy(&test);
}
static void test_timer_no_tap(void)
{
int rc, state;
test_timer_t test;
memset(&test, 0, sizeof(test_timer_t));
pthread_mutex_init(&test.mutex, NULL);
pthread_cond_init(&test.cond, NULL);
test.timer.notify_function= timer_notify_function;
rc= my_timer_create(&test.timer);
assert(rc == 0);
pthread_mutex_lock(&test.mutex);
rc= my_timer_set(&test.timer, 5);
assert(rc == 0);
assert(test.fired == 0); /* not fired yet */
while (!test.fired)
pthread_cond_wait(&test.cond, &test.mutex);
assert(test.fired == 1); /* timer fired once */
rc= my_timer_reset(&test.timer, &state);
assert(rc == 0);
assert(state == 0); /* timer state was signaled */
pthread_mutex_unlock(&test.mutex);
pthread_mutex_destroy(&test.mutex);
pthread_cond_destroy(&test.cond);
my_timer_delete(&test.timer);
}
void search_perft(const board_t * board, int depth_max) {
int depth;
my_timer_t timer[1];
double time, speed;
ASSERT(board_is_ok(board));
ASSERT(depth_max>=1&&depth_max<DepthMax);
// init
board_disp(board);
// iterative deepening
for (depth = 1; depth <= depth_max; depth++) {
// init
NodeNb = 0;
LeafNb = 0;
my_timer_reset(timer);
my_timer_start(timer);
perft(board,depth);
my_timer_stop(timer);
time = my_timer_elapsed_cpu(timer);
speed = (time < 0.01) ? 0.0 : double(NodeNb) / time;
printf("%2d %10lld %10lld %7.2f %7.0f\n",depth,NodeNb,LeafNb,time,speed);
}
printf("\n");
}
void search() {
int move;
int depth;
int i;
bool search_ready;
for (i = 0; i < MultiPVMax; i++){
save_multipv[SearchCurrent->multipv].mate = 0;
save_multipv[SearchCurrent->multipv].depth = 0;
save_multipv[SearchCurrent->multipv].max_depth = 0;
save_multipv[SearchCurrent->multipv].value = 0;
save_multipv[SearchCurrent->multipv].time = 0;
save_multipv[SearchCurrent->multipv].node_nb = 0;
strcpy(save_multipv[SearchCurrent->multipv].pv_string,"");
}
SearchInput->multipv = option_get_int("MultiPV")-1;
SearchCurrent->multipv = 0;
ASSERT(board_is_ok(SearchInput->board));
// opening book
if (option_get_bool("OwnBook") && !SearchInput->infinite) {
move = book_move(SearchInput->board);
if (move != MoveNone) {
// play book move
SearchBest[SearchCurrent->multipv].move = move;
SearchBest[SearchCurrent->multipv].value = 1;
SearchBest[SearchCurrent->multipv].flags = SearchExact;
SearchBest[SearchCurrent->multipv].depth = 1;
SearchBest[SearchCurrent->multipv].pv[0] = move;
SearchBest[SearchCurrent->multipv].pv[1] = MoveNone;
search_update_best();
return;
}
}
// SearchInput
gen_legal_moves(SearchInput->list,SearchInput->board);
if (LIST_SIZE(SearchInput->list) < SearchInput->multipv+1){
SearchInput->multipv = LIST_SIZE(SearchInput->list)-1;
}
if (LIST_SIZE(SearchInput->list) <= 1) {
SearchInput->depth_is_limited = true;
SearchInput->depth_limit = 4; // was 1
}
// SearchInfo
if (setjmp(SearchInfo->buf) != 0) {
ASSERT(SearchInfo->can_stop);
ASSERT(SearchBest->move!=MoveNone);
search_update_current();
return;
}
// SearchRoot
list_copy(SearchRoot->list,SearchInput->list);
// SearchCurrent
board_copy(SearchCurrent->board,SearchInput->board);
my_timer_reset(SearchCurrent->timer);
my_timer_start(SearchCurrent->timer);
// init
trans_inc_date(Trans);
sort_init();
search_full_init(SearchRoot->list,SearchCurrent->board);
// analyze game for evaluation
if (SearchCurrent->board->piece_size[White] < 3 && SearchCurrent->board->piece_size[Black] < 3){
trans_endgame = true;
}
else{
trans_endgame = false;
}
// iterative deepening
search_ready = false;
for (depth = 1; depth < DepthMax; depth++) {
for (SearchCurrent->multipv = 0; SearchCurrent->multipv <= SearchInput->multipv; SearchCurrent->multipv++){
if (DispDepthStart && SearchCurrent->multipv == 0) send("info depth %d",depth);
SearchCurrent->max_extensions = depth * 10;
SearchRoot->bad_1 = false;
SearchRoot->change = false;
board_copy(SearchCurrent->board,SearchInput->board);
if (UseShortSearch && depth <= ShortSearchDepth) {
search_full_root(SearchRoot->list,SearchCurrent->board,depth,SearchShort);
} else {
search_full_root(SearchRoot->list,SearchCurrent->board,depth,SearchNormal);
}
search_update_current();
if (DispDepthEnd && SearchCurrent->multipv == SearchInput->multipv) {
send("info depth %d seldepth %d time %.0f nodes " S64_FORMAT " nps %.0f",depth,SearchCurrent->max_depth,SearchCurrent->time*1000.0,SearchCurrent->node_nb,SearchCurrent->speed);
}
// update search info
if (depth >= 1) SearchInfo->can_stop = true;
if (depth == 1
&& LIST_SIZE(SearchRoot->list) >= 2
&& LIST_VALUE(SearchRoot->list,0) >= LIST_VALUE(SearchRoot->list,1) + EasyThreshold) {
SearchRoot->easy = true;
}
if (depth > 1) {
SearchRoot->bad_2 = SearchRoot->bad_1;
SearchRoot->bad_1 = false;
ASSERT(SearchRoot->bad_2==(SearchBest->value<=SearchRoot->last_value-BadThreshold));
}
SearchRoot->last_value = SearchBest[SearchCurrent->multipv].value;
// stop search?
if (SearchInput->depth_is_limited && SearchCurrent->multipv >= SearchInput->multipv
&& depth >= SearchInput->depth_limit) {
SearchRoot->flag = true;
}
if (SearchInput->time_is_limited
&& SearchCurrent->time * 2 >= SearchInput->time_limit_1
&& !SearchRoot->bad_2) {
SearchRoot->flag = true;
}
if (SearchInput->time_is_limited
&& SearchCurrent->time >= SearchInput->time_limit_1 * EasyRatio
&& SearchRoot->easy) {
ASSERT(!SearchRoot->bad_2);
ASSERT(!SearchRoot->change);
SearchRoot->flag = true;
}
if (SearchInput->time_is_limited
&& SearchCurrent->time >= SearchInput->time_limit_1 * EarlyRatio
&& !SearchRoot->bad_2
&& !SearchRoot->change) {
SearchRoot->flag = true;
}
if (SearchInfo->can_stop
&& (SearchInfo->stop || (SearchRoot->flag && !SearchInput->infinite))) {
search_ready = true;
break;
}
}
if (search_ready)
break;
}
}
static void no_mess(int move) {
ASSERT(move_is_ok(move));
// just received a move, calculate the new state
if (false) {
} else if (!active()) {
stop_search(); // abort a possible search
State->state = WAIT;
State->exp_move = MoveNone;
my_log("POLYGLOT WAIT\n");
} else if (State->state == WAIT) {
ASSERT(State->computer[game_turn(Game)]);
ASSERT(!State->computer[colour_opp(game_turn(Game))]);
ASSERT(!XB->analyse);
my_log("POLYGLOT WAIT -> THINK\n");
State->state = THINK;
State->exp_move = MoveNone;
} else if (State->state == THINK) {
ASSERT(!State->computer[game_turn(Game)]);
ASSERT(State->computer[colour_opp(game_turn(Game))]);
ASSERT(!XB->analyse);
if (ponder() && ponder_move_is_ok(Uci->ponder_move)) {
my_log("POLYGLOT THINK -> PONDER\n");
State->state = PONDER;
State->exp_move = Uci->ponder_move;
} else {
my_log("POLYGLOT THINK -> WAIT\n");
State->state = WAIT;
State->exp_move = MoveNone;
}
} else if (State->state == PONDER) {
ASSERT(State->computer[game_turn(Game)]);
ASSERT(!State->computer[colour_opp(game_turn(Game))]);
ASSERT(!XB->analyse);
if (move == State->exp_move && Uci->searching) {
ASSERT(Uci->searching);
ASSERT(Uci->pending_nb>=1);
my_timer_reset(State->timer);
my_timer_start(State->timer);
my_log("POLYGLOT PONDER -> THINK (*** HIT ***)\n");
engine_send(Engine,"ponderhit");
State->state = THINK;
State->exp_move = MoveNone;
send_pv(); // update display
return; // do not launch a new search
} else {
my_log("POLYGLOT PONDER -> THINK (miss)\n");
stop_search();
State->state = THINK;
State->exp_move = MoveNone;
}
} else if (State->state == ANALYSE) {
ASSERT(XB->analyse);
my_log("POLYGLOT ANALYSE -> ANALYSE\n");
stop_search();
} else {
ASSERT(false);
}
search_update();
}