espy/src/tree/EngineJacek.h

   1 #include<pthread.h>
   2 #include<iostream>
   3 #include<string>
   4 #include<stdlib.h>
   5
   6 #include<errno.h>
   7
   8 #include "CPEventListener.h"
   9 #include "CPCommandParser.h"
  10 #include "ConnectSix.h"
  11
  12 int ec_prep = 0;
  13
  14 #include<vector>
  15 using namespace std;
  16
  17 #include "Log.h"
  18 #include "sys/time.h"
  19
  20 template <class G>
  21 class Engine : public CPEventListener {
  22
  23     /*
  24     * Dostęp do danych i synchronizacja między wątkami.
  25     */
  26     class Mutex {
  27         pthread_mutex_t mutex;
  28         pthread_cond_t cond;
  29     public:
  30         Mutex() {
  31             if (pthread_mutex_init(&mutex,NULL) != 0)
  32                 Log::error("pthread_mutex_init failed in Mutex class constructor");
  33             if (pthread_cond_init(&cond,NULL) != 0)
  34                 Log::error("pthread_cond_init failed in Mutex class constructor");
  35         }
  36
  37         ~Mutex() {
  38             if (pthread_mutex_destroy(&mutex) != 0)
  39                 Log::error("pthread_mutex_destroy failed in Mutex class destructor");
  40             if (pthread_cond_destroy(&cond) != 0)
  41                 Log::error("pthread_cond_destroy failed in Mutex class destructor");
  42         }
  43
  44         void grab() {
  45             if (pthread_mutex_lock(&mutex) != 0)
  46                 Log::error("pthread_mutex_lock failed in Mutex.grab()");
  47         }
  48
  49         void release() {
  50             if (pthread_mutex_unlock(&mutex) != 0)
  51                 Log::error("pthread_mutex_unlock failed in Mutex.release()");
  52         }
  53
  54         void sleep() {
  55             if (pthread_cond_wait(&cond,&mutex) != 0)
  56                 Log::error("pthread_cond_wait failed in Mutex.sleep()");
  57         }
  58
  59         void sleep(timespec &ts) {
  60             int x;
  61             if ((x = pthread_cond_timedwait(&cond,&mutex, &ts)) != 0) {
  62                 if (x != ETIMEDOUT) {
  63                     Log::error("pthread_cond_wait failed in method Mutex.sleep(timespec)");
  64                 }
  65             }
  66         }
  67
  68         void wake() {
  69             if (pthread_cond_signal(&cond) != 0)
  70                 Log::error("pthread_cond_signal failed in Mutex.wake()");
  71         }
  72
  73     };
  74
  75
  76 protected:
  77
  78     class SearchResult {
  79     public:
  80         Mutex lock;
  81
  82         bool in_progress;
  83         int nominal_depth;
  84         int score_lower_bound;
  85         int score_upper_bound;
  86
  87         bool resign;
  88         vector<typename G::move> pv;
  89
  90         int elapsed_time;
  91         int nodes_used;
  92
  93         void init() {
  94             in_progress = true;
  95             resign = false;
  96             nominal_depth = -1;
  97             pv.clear();
  98         }
  99
 100         void update(SearchResult &sr) {
 101             lock.grab();
 102             in_progress = sr.in_progress;
 103             nominal_depth = sr.nominal_depth;
 104             pv = sr.pv;
 105             // .....
 106             lock.release();
 107         }
 108     };
 109
 110     SearchResult search_result;
 111
 112     bool pause_search;
 113
 114     SearchResult current_search;
 115
 116 private:
 117     G official_board;
 118     Mutex official_board_mutex;
 119     int _time;
 120
 121     virtual void think(G&, SearchResult&, int) = 0;
 122
 123     Mutex engine_mutex;
 124
 125     typedef enum { e_idle, e_white, e_black, e_analyze } mode;
 126
 127     typedef enum { c_none, c_update, c_reset, c_quit, c_move } command;
 128
 129     command command_to_engine;
 130     mode engine_mode;
 131
 132     void engine_sleep() {
 133         engine_mutex.wake();
 134
 135         if (command_to_engine == c_none) {
 136             engine_mutex.sleep();
 137         }
 138     }
 139
 140     void *engine_thread() {
 141         Log::debug("Engine thread started.");
 142
 143         engine_mutex.grab();
 144
 145         while (1) {
 146             pause_search = false;
 147             command tmp = command_to_engine;
 148             command_to_engine = c_none;
 149
 150             cout << "Engine loop " << tmp << endl;
 151
 152             switch (tmp) {
 153             case c_none:
 154                 switch(engine_mode) {
 155                 case e_idle: engine_sleep(); break;
 156                 case e_white:
 157                 case e_black:
 158                 case e_analyze:
 159                     current_search.lock.grab();
 160                     current_search.init();
 161                     current_search.lock.release();
 162
 163                     official_board_mutex.grab();
 164
 165                     if ((engine_mode == e_white && !official_board.wtm()) ||
 166                         (engine_mode == e_black && official_board.wtm()) ||
 167                         (official_board.game_state() != G::in_progress)) {
 168                             official_board_mutex.release();
 169                             engine_sleep();
 170                             break;
 171                     }
 172
 173                     G board = official_board;
 174                     official_board_mutex.release();
 175
 176                     engine_mutex.release();
 177                     engine_mutex.wake();
 178
 179                     think(board, current_search, _time);
 180
 181                     engine_mutex.grab();
 182
 183                     current_search.lock.grab();
 184                     if (!current_search.in_progress) {
 185                         search_result.update(current_search);
 186                     }
 187                     current_search.lock.release();
 188
 189                     if (!pause_search  && command_to_engine == c_none) {
 190                         cout << "WILL BE SENDING" << endl;
 191                         command_to_engine = c_move;
 192                         pause_search = true;
 193                     }
 194
 195                 }
 196                 break;
 197
 198             case c_quit:
 199                 engine_mutex.release();
 200
 201                 Log::debug("Engine thread finished.");
 202                 return NULL;
 203
 204             case c_reset:
 205                 // czyszczenie tablicy transpozycji itp.
 206
 207             case c_update:
 208                 pause_search = false;
 209                 search_result.lock.grab();
 210                 search_result.init();
 211                 search_result.lock.release();
 212
 213                 //                              Log::debug("reset/pause");
 214
 215                 break;
 216
 217             case c_move:
 218                 Log::debug("c_move entered");
 219
 220                 official_board_mutex.grab();
 221                 if ((official_board.wtm() && engine_mode != e_white) ||
 222                     ((!official_board.wtm()) && engine_mode != e_black)) {
 223                     official_board_mutex.release();
 224                     //                                  Log::debug("c_move break - wrong side to move!!!");
 225                     break;
 226                 }
 227
 228                 official_board_mutex.release();
 229
 230                 search_result.lock.grab();
 231                 typename G::move bestmove;
 232
 233                 if (search_result.pv.size() == 0 && !search_result.resign) {
 234                     Log::debug("PANIC! No vaild search result found. Making random move!");
 235
 236                     bestmove = -1;
 237                 } else {
 238                     bestmove = search_result.pv[search_result.pv.size()-1];
 239                 }
 240                 search_result.init();
 241                 search_result.lock.release();
 242
 243                 official_board_mutex.grab();
 244                 official_board.prepare_moves();
 245                 if (bestmove == -1 && !search_result.resign) {
 246                     vector<typename G::move> moves;
 247
 248                     while(official_board.has_next_move()) {
 249                         moves.push_back(official_board.get_next_move());
 250                     }
 251
 252                     if (moves.size() == 0) {
 253                         Log::error("Move requested in a final position (with no moves available).");
 254                     } else {
 255                         bestmove = moves[random() % moves.size()];
 256                     }
 257                 }
 258
 259                 if (bestmove != -1) {
 260                     official_board.make_move(bestmove);
 261                     cout << "bestmove " << official_board.print_move(bestmove) << endl;
 262                 } else if (search_result.resign) {
 263                     cout << "concede" << endl;
 264                 }
 265
 266                 switch (official_board.game_state()) {
 267                 case G::white_wins:
 268                     cout << "endgame white" << endl;
 269                     break;
 270                 case G::black_wins:
 271                     cout << "endgame black" << endl;
 272                     break;
 273                 case G::draw:
 274                     cout << "endgame draw" << endl;
 275                     break;
 276                 }
 277
 278                 official_board_mutex.release();
 279
 280                 break;
 281             default:
 282                 Log::error("Internal error: bad command sent to the engine thread.");
 283             }
 284         }
 285
 286         Log::debug("Engine thread finished.");
 287         return NULL;
 288     }
 289
 290     static void* engine_thread_helper(void *context) {
 291         return ((Engine *) context) -> engine_thread();
 292     }
 293
 294     void display_feedback() {
 295         cout << "info feedback XXX" << endl;
 296     }
 297
 298
 299     /*
 300     * Wątek clock obsługuje dwa zadania:
 301     *
 302     *   w przypadku, gdy toczy się gra i silnik ma swój ruch decyduje, w którym momencie zakończyć myślenie i wysłać ruch
 303     *   w przypadku, gdy feedback jest włączony, co sekundę wysyła informacje o wynikach szukania do interfejsu
 304     *     (wtedy, gdy silnik pracuje)
 305     */
 306
 307     Mutex clock_mutex;
 308
 309     void *clock_thread() {
 310     Log::debug("Clock thread started.");
 311
 312     clock_mutex.grab();
 313
 314     while (1) {
 315         /*
 316         * Działamy
 317         */
 318         switch (engine_mode) {
 319         case e_idle:
 320             break;
 321         case e_white:
 322         case e_black:
 323             official_board_mutex.grab();
 324
 325             if (!pause_search &&
 326                     ((engine_mode == e_white && official_board.wtm()) ||
 327                     (engine_mode == e_black && !official_board.wtm()))
 328                 ) {
 329
 330                 official_board_mutex.release();
 331
 332                 ec_prepare("c_move");
 333                 command_to_engine = c_move;
 334                 pause_search = true;
 335                 ec_send();
 336             } else {
 337                 official_board_mutex.release();
 338             }
 339
 340             break;
 341         case e_analyze:
 342             display_feedback();
 343             break;
 344         }
 345
 346         /*
 347         * Usypiamy
 348         */
 349         timeval tp, tpo;
 350         tpo = tp;
 351         gettimeofday(&tp, NULL);
 352
 353         if (tp.tv_sec != tpo.tv_sec) {
 354             //                    cout << "debug " << getpid() << " engine_mode " << engine_mode << " board.wtm() " << official_board.wtm() << endl;
 355         }
 356
 357         timespec ts;
 358         ts.tv_sec = tp.tv_sec;
 359         ts.tv_nsec = tp.tv_usec * 1000;
 360         ts.tv_nsec += (random() % 500000000);
 361         if (ts.tv_nsec >= 1000000000) {
 362             ts.tv_sec += 1;
 363             ts.tv_nsec -= 1000000000;
 364         }
 365
 366         ts.tv_sec += 5;
 367
 368         clock_mutex.sleep(ts);
 369 //         cout << "CLOCK TICK" << endl;
 370
 371         if (!interface_loop) {
 372             break;
 373         }
 374     }
 375
 376     clock_mutex.release();
 377
 378     Log::debug("Clock thread finished.");
 379     return NULL;
 380     }
 381
 382     static void* clock_thread_helper(void *context) {
 383         return ((Engine *) context) -> clock_thread();
 384     }
 385
 386     bool interface_loop;
 387
 388     void *interface_thread() {
 389     Log::debug("Interface thread started.");
 390
 391     CPCommandParser parser(cin, *this);
 392
 393     while (interface_loop) {
 394         string line = parser.nextCommand();
 395         try {
 396             parser.parse(line);
 397         } catch (int error) {
 398             if (error == 2)
 399                 cout << "Unknown command." << endl;
 400             else
 401                 cout << "Command corrupted." << endl;
 402         }
 403     }
 404
 405     Log::debug("Interface thread finished.");
 406     return NULL;
 407     }
 408
 409     static void* interface_thread_helper(void *context) {
 410         return ((Engine *) context) -> interface_thread();
 411     }
 412
 413     void ec_prepare(string msg) {
 414         ec_prep++;
 415         cout << "ec_prepare " << msg << " (" << ec_prep << "); command_to_engine " << command_to_engine << endl;
 416
 417         engine_mutex.grab();
 418         while (command_to_engine != c_none) {
 419             engine_mutex.sleep();
 420         }
 421     }
 422
 423     void ec_send() {
 424         cout << "ec_send (" << ec_prep << ")";
 425
 426         ec_prep--;
 427
 428         engine_mutex.release();
 429         engine_mutex.wake();
 430     }
 431
 432 public:
 433
 434     void main() {
 435         interface_loop = true;
 436
 437         pthread_attr_t attr;
 438         pthread_t thr[3];
 439
 440
 441         if (pthread_attr_init(&attr) != 0) {
 442             Log::error("pthread_attr_init");
 443         };
 444
 445         if (pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE) != 0) {
 446             Log::error("pthread_attr_setdetachstate");
 447         };
 448
 449         if (pthread_create(&thr[0], &attr, engine_thread_helper,this) != 0 ||
 450             pthread_create(&thr[1], &attr, clock_thread_helper, this) != 0 ||
 451             pthread_create(&thr[2], &attr, interface_thread_helper, this) != 0) {
 452             Log::error("pthread_create");
 453         };
 454
 455
 456         if (pthread_join(thr[0],NULL) != 0 ||
 457             pthread_join(thr[1],NULL) != 0 ||
 458             pthread_join(thr[2],NULL) != 0) {
 459             error("pthread_join");
 460         };
 461
 462         Log::debug("Engine::main() exiting.");
 463     }
 464
 465     /*****
 466     * Implementacja metod CPEventListenera
 467     * (Komunikacja GUI -> silnik.)
 468     */
 469
 470     /*
 471     * Wszystkie poniższe metody wywoływane są przez wątek nasłuchujący na
 472     *   wejściu i nie wykonują bezpośrednio poleceń, a kolejkują je
 473     *   w kolejce komend zegara lub silnika i wysyłają sygnał, że jest następne
 474     *   polecenie.
 475     */
 476
 477     void init() {
 478         engine_mode = e_idle;
 479         official_board.clear();
 480     }
 481
 482     virtual void startGame(std::string position, CPRole role,
 483                 int gameTime, int bonusTime) {
 484
 485         switch (role) {
 486         case CP_ROLE_WHITE: // Log::debug("startGame as white");
 487             break;
 488         case CP_ROLE_BLACK: //Log::debug("startGame as black");
 489             break;
 490         default: break;
 491         }
 492
 493         ec_prepare("startGame");
 494
 495         command_to_engine = c_update;
 496         pause_search = true;
 497
 498         switch (role) {
 499         case CP_ROLE_WHITE: engine_mode = e_white; break;
 500         case CP_ROLE_BLACK: engine_mode = e_black; break;
 501         case CP_ROLE_ANALYST: engine_mode = e_analyze; break;
 502         default: break;
 503         }
 504
 505         search_result.lock.grab();
 506         search_result.init();
 507         search_result.lock.release();
 508
 509         official_board_mutex.grab();
 510         official_board.clear();
 511         official_board_mutex.release();
 512
 513         ec_send();
 514 //              Log::debug("startGame send");
 515
 516     }
 517
 518     virtual void move(CPColor color, std::string move) {
 519 //              Log::debug("got opp move: " + move);
 520
 521         switch (color) {
 522         case CP_COLOR_WHITE:
 523             cout << "white moves " << move << " Im playing";
 524
 525             if (!official_board.wtm()) cout << "!!!!!!!!!!!!! ";
 526             break;
 527         case CP_COLOR_BLACK:
 528             cout << "black moves Im playing";
 529             if (official_board.wtm()) cout << "!!!!!!!!!!!!! ";
 530             break;
 531         default: break;
 532         }
 533
 534         switch (engine_mode) {
 535         case e_white: cout << " white ";break;
 536         case e_black: cout << " black "; break;
 537         default: break;
 538         }
 539
 540         if (official_board.wtm()) {
 541             cout << " on board white" << endl;
 542         } else {
 543             cout << " on board black" << endl;
 544         }
 545
 546         ec_prepare("move");
 547         command_to_engine = c_update;
 548         pause_search = true;
 549
 550         official_board_mutex.grab();
 551         typename G::move mv = official_board.parse_move(move);
 552
 553         cout << " parsed as " << official_board.print_move(mv) << endl;
 554
 555         /*official_board.prepare_moves();
 556         bool valid = false;
 557         while (official_board.has_next_move() && !valid) {
 558             if (official_board.get_next_move() == mv) {
 559                 valid = true;
 560             }
 561         }
 562         if (valid) {*/
 563             official_board.make_move(mv);
 564         /*} else {
 565             Log::error("Invalid move.");
 566         }*/
 567
 568         switch (official_board.game_state()) {
 569         case G::white_wins:
 570             cout << "endgame White wins"  << endl;
 571             break;
 572         case G::black_wins:
 573             cout << "endgame Black wins"  << endl;
 574             break;
 575         case G::draw:
 576             cout << "endgame Draw" << endl;
 577             break;
 578         }
 579
 580         official_board_mutex.release();
 581
 582         ec_send();
 583     }
 584
 585     virtual void feedback(bool on) {
 586         Log::log("feedback not implemented.");
 587     }
 588
 589     virtual void setOption(std::map<std::string, std::string> & options) {
 590         Log::log("setOption not implemented.");
 591     }
 592
 593     virtual void getMove(CPColor color, int moveTime,
 594                 int gameTime) {
 595
 596 //              Log::debug("getMove");
 597
 598         if ((color == CP_COLOR_WHITE && engine_mode == e_white) ||
 599             (color == CP_COLOR_BLACK && engine_mode == e_black)) {
 600
 601             // do uzupełnienia
 602             return;
 603         }
 604
 605         ec_prepare("getMove");
 606         if (color == CP_COLOR_WHITE) {
 607             engine_mode = e_white;
 608         } else {
 609             engine_mode = e_black;
 610         }
 611         command_to_engine = c_update;
 612         pause_search = true;
 613         _time = gameTime;
 614         ec_send();
 615     }
 616
 617     virtual void forceMove() {
 618         ec_prepare("forceMove");
 619         command_to_engine = c_move;
 620         pause_search = true;
 621         ec_send();
 622     }
 623
 624     virtual void stop() {
 625         ec_prepare("stop");
 626         engine_mode = e_idle;
 627         command_to_engine = c_update;
 628         pause_search = true;
 629         ec_send();
 630     }
 631
 632     virtual void endGame(CPResult result) {
 633         ec_prepare("endGame");
 634         engine_mode = e_idle;
 635         command_to_engine = c_update;
 636         pause_search = true;
 637         ec_send();
 638     }
 639
 640     virtual void quit() {
 641         interface_loop = false;
 642
 643         ec_prepare("quit");
 644         command_to_engine = c_quit;
 645         pause_search = true;
 646         ec_send();
 647
 648         clock_mutex.wake();
 649     }
 650
 651
 652     virtual void connect(std::string name) {};
 653     virtual void bestMove(std::string move) {};
 654     virtual void error(std::string message) {};
 655     virtual void concede() {};
 656     virtual void info(std::map<std::string, std::string> & options) {};
 657
 658 };