checkMovePerf.cc
Go to the documentation of this file.
00001 
00004 #include "osl/record/csaString.h"
00005 
00006 #define NO_SAFE_MOVE_ACTION_IN_LIBOSL
00007 #define SIMPLE_STATE_ONLY
00008 
00009 #include "osl/move_generator/addEffect_.h"
00010 #include "osl/move_generator/addEffectWithEffect.h"
00011 #include "osl/move_generator/escape_.h"
00012 
00013 #ifdef NO_SAFE_MOVE_ACTION_IN_LIBOSL
00014 #  include "osl/move_generator/open.tcc"
00015 #  include "osl/move_generator/allMoves.tcc"
00016 #  include "osl/move_generator/escape_.tcc"
00017 #  include "osl/move_generator/capture_.tcc"
00018 #  include "osl/move_generator/addEffect_.tcc"
00019 #  include "osl/move_generator/addEffectWithEffect.tcc"
00020 #endif
00021 
00022 #ifndef SIMPLE_STATE_ONLY
00023 #  include "osl/boardBitEffect.h"
00024 #  include "osl/evalHashEffectState.h"
00025 #  include "osl/numEffectState.h"
00026 #endif
00027 
00028 #include "osl/applyMove.h"
00029 #include "osl/move_action/store.h"
00030 #include "osl/move_action/safeFilter.h"
00031 #include "osl/perfmon.h"
00032 #include <time.h>
00033 #include <sys/time.h>
00034 
00035 using namespace osl;
00036 using namespace osl::move_generator;
00037 using namespace osl::move_action;
00038 
00039 int moveCount;
00040 int maxLevel;
00041 
00042 template<Player P,typename State, bool isAttack,bool withEffect>
00043 void nextMoves(State& state,int level,Move lastMove);
00044 
00045 template<class State, Player P, bool isAttack,bool withEffect>
00046 struct DoUndoHelper
00047 {
00048   State& state;
00049   int level;
00050   Move move;
00051     
00052   DoUndoHelper(State& s, int level) : state(s), level(level), move(MOVE_INVALID){}
00053   void operator()(Square p)
00054   {
00055     assert(move!=MOVE_INVALID);
00056     nextMoves<P,State,isAttack,withEffect>(state,level,move);
00057   }
00058 };
00059 
00060 template <Player P, typename State, bool isAttack,bool withEffect>
00061 void nextMoves(State& state,int level,Move lastMove)
00062 {
00063   typedef typename State::effect_state_t effect_t;
00064   if (level>maxLevel) 
00065     return;
00066   MoveVector moves;
00067   typedef DoUndoHelper<State,PlayerTraits<P>::opponent,!isAttack,withEffect> helper_t;
00068   helper_t helper(state, level+1);
00069   {
00070     Store store(moves);
00071     if (isAttack)
00072     {
00073       typedef SafeFilter<P,typename State::effect_state_t,Store> action_t;
00074       action_t safeAction(state,store);
00075       const Square opKingSquare
00076         =state.template kingSquare<PlayerTraits<P>::opponent>();
00077 #if 1
00078       if (state.hasEffectAt(P,opKingSquare)) // 逃げる手になっていない
00079         return; // 詰
00080 #else
00081       assert(!state.hasEffectAt(P,opKingSquare));
00082 #endif
00083       if(withEffect)
00084         AddEffectWithEffect<typename State::effect_state_t,action_t>::
00085 	  generateMoves(P,(effect_t)state,opKingSquare,safeAction);
00086 #if 1
00087       else
00088         AddEffect<typename State::effect_state_t,action_t>::
00089 	  generateMoves(P,state,opKingSquare,safeAction);
00090 #endif
00091     }
00092     else
00093     {
00094       assert(!state.hasEffectAt(P,state.template kingSquare<PlayerTraits<P>::opponent>()));
00095 
00096       Escape<P,typename State::effect_state_t,Store>::
00097 	generateKingEscape((effect_t)state, lastMove,store);
00098     }
00099   }
00100   size_t size=moves.size();
00101   for(size_t i=0;i<size;i++){
00102     // std::cerr << i << " " << moves[i] << "\n";
00103     moveCount++;
00104     helper.move=moves[i];
00105     ApplyMove<P>::doUndoMove(state,moves[i],helper);
00106   }
00107 }
00108 
00109 int main(int argc,char **argv){
00110   bool effectMode=false;
00111   bool hashMode=false;
00112   bool evalMode=false;
00113   bool nullMode=false;
00114   bool withEffectMode=false;
00115   bool simpleMode=false;
00116   bool boardBitMode=false;
00117   int level=3;
00118   extern char *optarg;
00119 
00120   char c;
00121   while ((c = getopt(argc, argv, "l:dehEnwsb")) != EOF)
00122   {
00123     switch(c)
00124     {
00125     case 'l':   level=atoi(optarg);
00126       break;
00127     case 'e':   effectMode=true;
00128       break;
00129     case 'h':   hashMode=true;
00130       break;
00131     case 'E':   evalMode=true;
00132       break;
00133     case 'n':   nullMode=true;
00134       break;
00135     case 'w':   withEffectMode=true;
00136       break;
00137     case 's':   simpleMode=true;
00138       break;
00139     case 'b':   boardBitMode=true;
00140       break;
00141     default:
00142       std::cerr << "unknown option\n";
00143       return 1;
00144     }
00145   }
00146   SimpleState state=CsaString(
00147 "P1-KY *  *  * -KY * -FU-KE * \n"
00148 "P2 *  *  *  * -OU *  *  *  * \n"
00149 "P3 *  *  * -FU-FU+RY *  * -KY\n"
00150 "P4-FU *  * -GI *  *  *  *  * \n"
00151 "P5 *  *  *  *  *  *  *  *  * \n"
00152 "P6+FU *  * +RY *  * +FU *  * \n"
00153 "P7 * +FU * +FU+FU+FU *  *  * \n"
00154 "P8 *  * +OU * -TO *  *  *  * \n"
00155 "P9+KY *  *  *  *  *  * +KE * \n"
00156 "P+00KI00GI00GI00GI00KE00KE00FU00FU00FU00KI\n"
00157 "P-00KA00KA00KI00FU00FU00FU00FU00KI\n"
00158 "-\n").getInitialState();
00159   maxLevel=level;
00160   moveCount=0;
00161   clock_start();
00162 
00163 #ifndef SIMPLE_STATE_ONLY
00164   if(evalMode)
00165   {
00166     std::cerr << "evalMode" << std::endl;
00167     NumEffectState neState(state);
00168     HashEffectState hState(neState);
00169     EvalHashEffectState eState(hState);
00170     
00171     Move lastMove=newMove(newSquare(4,4),newSquare(4,3),PROOK,
00172                           PTYPE_EMPTY,false,BLACK);
00173 
00174     if(withEffectMode)
00175       nextMoves<WHITE,EvalHashEffectState,false,true>(eState,0,lastMove);
00176     else
00177       nextMoves<WHITE,EvalHashEffectState,false,false>(eState,0,lastMove);
00178   }
00179   else if(hashMode)
00180   {
00181     std::cerr << "hashMode" << std::endl;
00182     NumEffectState neState(state);
00183     HashEffectState hState(neState);
00184     
00185     Move lastMove=newMove(newSquare(4,4),newSquare(4,3),PROOK,
00186                           PTYPE_EMPTY,false,BLACK);
00187     if(withEffectMode)
00188       nextMoves<WHITE,HashEffectState,false,true>(hState,0,lastMove);
00189     else
00190       nextMoves<WHITE,HashEffectState,false,false>(hState,0,lastMove);
00191   }
00192   else if(effectMode);
00193   {
00194     assert(effectMode);
00195     
00196     std::cerr << "effectMode" << std::endl;
00197     NumEffectState neState(state);
00198     Move lastMove=newMove(newSquare(4,4),newSquare(4,3),PROOK,
00199                           PTYPE_EMPTY,false,BLACK);
00200     if(withEffectMode)
00201       nextMoves<WHITE,NumEffectState,false,true>(neState,0,lastMove);
00202     else
00203       nextMoves<WHITE,NumEffectState,false,false>(neState,0,lastMove);
00204   }
00205 #if 0
00206   else 
00207     if(boardBitMode){
00208     std::cerr << "boardBitEffectMode" << std::endl;
00209     typedef BoardBitEffect<SimpleState> effect_state_t;
00210     effect_state_t neState(state);
00211     Move lastMove=newMove(newSquare(4,4),newSquare(4,3),PROOK,
00212                           PTYPE_EMPTY,false,BLACK);
00213     nextMoves<WHITE,effect_state_t,false,true>(neState,0,lastMove);
00214   }
00215 #endif
00216 #if 0
00217   else if(nullMode){
00218     std::cerr << "nullBoardEffectMode" << std::endl;
00219     typedef NullBoardEffect<SimpleState> effect_state_t;
00220     effect_state_t neState(state);
00221     Move lastMove=newMove(newSquare(4,4),newSquare(4,3),PROOK,
00222                           PTYPE_EMPTY,false,BLACK);
00223     nextMoves<WHITE,effect_state_t,false,true>(neState,0,lastMove);
00224   }
00225 #endif
00226     else 
00227 #else /*  SIMPLE_STATE_ONLY */
00228       if(simpleMode){
00229       std::cerr << "nullBoardEffectMode" << std::endl;
00230       typedef SimpleState effect_state_t;
00231       effect_state_t neState(state);
00232     Move lastMove=newMove(newSquare(4,4),newSquare(4,3),PROOK,
00233                           PTYPE_EMPTY,false,BLACK);
00234       nextMoves<WHITE,effect_state_t,false,true>(neState,0,lastMove);
00235     }
00236 #endif
00237   clock_stop("total", moveCount+1);
00238   std::cerr << "maxLevel=" << maxLevel << ",moveCount=" << moveCount 
00239             << std::endl;
00240 }
00241 // ;;; Local Variables:
00242 // ;;; mode:c++
00243 // ;;; c-basic-offset:2
00244 // ;;; End:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines