simpleMovePerf.cc
Go to the documentation of this file.
00001 
00007 #include "osl/record/csaString.h"
00008 #include "osl/state/numEffectState.h"
00009 
00010 #ifdef MORE_STATE
00011 #  include "osl/boardBitEffect.h"
00012 #  include "osl/signatureEffect.h"
00013 #endif 
00014 
00015 #ifdef PPAIR_PERF
00016 #  include "osl/piecePairEval.h"
00017 #  include "osl/pieceEval.h"
00018 #endif
00019 
00020 #include "osl/player.h"
00021 #include "osl/move_generator/allMoves.h"
00022 #include "osl/move_generator/allMoves.tcc"
00023 #include "osl/move_action/store.h"
00024 #include "osl/misc/perfmon.h"
00025 #include <iostream>
00026 #include <time.h>
00027 #include <sys/time.h>
00028 #include <cstdio>
00029 
00030 using namespace osl;
00031 
00032 int moveCount;
00033 int dropCount;
00034 int maxLevel;
00035 
00036 int maxVal=0;
00037 
00038 #ifdef PPAIR_PERF
00039 bool noPair = false;
00040 bool piecePair = false;
00041 int value;
00042 #endif
00043 
00044 template<Player P,typename State,bool isMoveEval>
00045 void nextMoves(State& state,int level);
00046 
00047 template<class State, Player P,bool isMoveEval>
00048 struct DoUndoHelper{
00049   State& state;
00050   int level;
00051     
00052   DoUndoHelper(State& s, int level) : state(s), level(level){}
00053   void operator()(Square p){
00054     nextMoves<P,State,isMoveEval>(state,level);
00055   }
00056 };
00057 
00058 template<Player P,typename State>
00059 void callValWithMove(State& state,Move move,Int2Type<false>){
00060 }
00061 
00062 template<Player P,typename State>
00063 void callValWithMove(State& state,Move move,Int2Type<true>){
00064   typename State::eval_t ev = state.getEval();
00065   const int ret = ev.template computeValWithMove<State,P>(state, move);
00066   if(ret>maxVal){maxVal=ret;}
00067 }
00068 
00069 
00070 template<Player P,typename State,bool isMoveEval>
00071 void nextMoves(State& state,int level){
00072   if(level>maxLevel) return;
00073   MoveVector moves;
00074   DoUndoHelper<State,PlayerTraits<P>::opponent,isMoveEval> helper(state, level+1);
00075   GenerateAllMoves::generate(P,state,moves);
00076 
00077   size_t size=moves.size();
00078   for(size_t i=0;i<size;i++){
00079     callValWithMove<P,State>(state,moves[i],Int2Type<isMoveEval>());
00080     moveCount++;
00081 #ifdef PPAIR_PERF
00082     const int prevValue = value;
00083     if (noPair)
00084       value += PieceEval::diffWithMove(state, moves[i]);
00085     else if (piecePair)
00086       value += PiecePairEval::diffWithMove(state, moves[i]);
00087 #endif    
00088     state.makeUnmakeMove(Player2Type<P>(),moves[i],helper);
00089 #ifdef PPAIR_PERF
00090     value = prevValue;
00091 #endif    
00092   }
00093 }
00094 
00095 #ifdef ENABLE_DIRECT_MODE
00096 template<Player P,typename State,bool isMoveEval>
00097 void nextMovesDirect(State& state,int level);
00098 
00099 template<class State,Player P,bool isMoveEval>
00100 struct CallNextMoves{
00101   State& state;
00102   int level;
00103   CallNextMoves(State& s, int level) : state(s), level(level){}
00104 
00105   void operator()(Square p){
00106     nextMovesDirect<P,State,isMoveEval>(state,level);
00107   }
00108 };
00109 
00110 template<typename State,Player P,bool isMoveEval>
00111 struct DirectCallAction{
00112   State& state;
00113   int level;
00114   DirectCallAction(State& s, int level) : state(s), level(level){}
00115   typedef CallNextMoves<State,PlayerTraits<P>::opponent,isMoveEval> next_t;
00116   void receiveSimpleMove(Square from,Square to,Ptype ptype, bool isPromote,Player p){
00117 
00118     moveCount++;
00119     next_t caller(state,level);
00120     ApplyDoUndoSimpleMove<P,State>::template doUndoSimpleMove<next_t>
00121       (state,from,to,promoteMask(isPromote),caller);
00122   }
00123   void receiveUnknownMove(Square from,Square to,Piece p1,Ptype ptype,bool isPromote,Player p){
00124     next_t  caller(state,level);
00125     moveCount++;
00126     if(p1==PIECE_EMPTY)
00127       ApplyDoUndoSimpleMove<P,State>::template doUndoSimpleMove<next_t>
00128         (state,from,to,promoteMask(isPromote),caller);
00129     else
00130       ApplyDoUndoCaptureMove<P,State>::template doUndoCaptureMove<next_t>
00131         (state,from,to,p1,promoteMask(isPromote),caller);
00132   }
00133   void receiveDropMove(Square to,Ptype ptype,Player p){
00134     moveCount++;
00135     next_t  caller(state, level);
00136     ApplyDoUndoDropMove<P,State>::template doUndoDropMove<next_t>(state,to,ptype,caller);
00137   }
00138 };
00139 
00140 template<Player P,typename State,bool isMoveEval>
00141 void nextMovesDirect(State& state,int level){
00142   if(level>maxLevel) return;
00143   DirectCallAction<State,P,isMoveEval> action(state, level+1);
00144   typedef move_generator::AllMoves<State,DirectCallAction<State,P,isMoveEval> > generate_t;
00145   generate_t::template generateMoves<P>(state,action);
00146 }
00147 #endif /* ENABLE_DIRECT_MODE */
00148 
00149 int main(int argc,char **argv){
00150   bool directMode=false;
00151   bool effectMode=false;
00152   bool hashMode=false;
00153   bool boardBitMode=false;
00154   bool signatureMode=false;
00155   int level=3;
00156   extern char *optarg;
00157 
00158   char c;
00159   while ((c = getopt(argc, argv, "l:dehpPbS")) != EOF)
00160     {
00161       switch(c)
00162         {
00163         case 'l':       level=atoi(optarg);
00164           break;
00165         case 'd':       directMode=true;
00166           break;
00167         case 'e':       effectMode=true;
00168           break;
00169         case 'h':       hashMode=true;
00170           break;
00171         case 'b':       boardBitMode=true;
00172           break;
00173         case 'S':       signatureMode=true;
00174           break;
00175 #ifdef PPAIR_PERF
00176         case 'p':       noPair=true;
00177           break;
00178         case 'P':       piecePair=true;
00179           break;
00180 #endif
00181         default:
00182           std::cerr << "unknown option\n";
00183           return 1;
00184         }
00185     }
00186   SimpleState state=CsaString(
00187                               "P1+RY *  *  *  *  *  * -KE-KY\n"
00188                               "P2 *  *  * +GI * -KI-KI-OU *\n"
00189                               "P3 *  * +TO *  *  * -GI-FU-FU\n"
00190                               "P4-FU * -UM * -FU * -FU *  *\n"
00191                               "P5 *  * +GI *  * -FU * +FU+FU\n"
00192                               "P6+FU+OU+GI+FU+FU * +FU *  *\n"
00193                               "P7 * +FU * +KE *  *  *  *  *\n"
00194                               "P8 *  *  *  *  *  *  *  *  * \n"
00195                               "P9-RY *  *  *  *  *  *  * +KY\n"
00196                               "P+00KA00KY00FU00FU00FU00FU\n"
00197                               "P-00KI00KI00KE00KE00KY\n"
00198                               "+\n").getInitialState();
00199   maxLevel=level;
00200   moveCount=0;
00201   dropCount=0;
00202   misc::PerfMon timer;
00203   if(effectMode){
00204     std::cerr << "effectMode" << std::endl;
00205     NumEffectState neState(state);
00206     
00207     if(directMode){
00208       std::cerr << "directMode" << std::endl;
00209 #ifdef ENABLE_DIRECT_MODE
00210       nextMovesDirect<BLACK,NumEffectState,false>(neState,0);
00211 #endif
00212     }
00213     else{
00214       nextMoves<BLACK,NumEffectState,false>(neState,0);
00215     }
00216   }
00217   else
00218 #ifdef MORE_STATE
00219 #ifndef PPAIR_PERF
00220     if(signatureMode){
00221       std::cerr << "signatureMode" << std::endl;
00222       SimpleState sState(state);
00223       typedef SignatureEffect<BoardBitEffect<SimpleState> > state_t;
00224       state_t bState(sState);
00225     
00226       if(directMode){
00227         std::cerr << "directMode" << std::endl;
00228 #ifdef ENABLE_DIRECT_MODE
00229         nextMovesDirect<BLACK,state_t,false>(bState,0);
00230 #endif
00231       }
00232       else{
00233         nextMoves<BLACK,state_t,false>(bState,0);
00234       }
00235     }
00236     else
00237       if(boardBitMode){
00238         std::cerr << "boardBitMode" << std::endl;
00239         SimpleState sState(state);
00240         typedef BoardBitEffect<SimpleState> state_t;
00241         state_t bState(sState);
00242     
00243         if(directMode){
00244           std::cerr << "directMode" << std::endl;
00245 #ifdef ENABLE_DIRECT_MODE
00246           nextMovesDirect<BLACK,state_t,false>(bState,0);
00247 #endif
00248         }
00249         else{
00250           nextMoves<BLACK,state_t,false>(bState,0);
00251         }
00252       }
00253       else
00254 #endif /* ifndef PPAIR_PERF */
00255         if(simpleMode){
00256           std::cerr << "simpleMode" << std::endl;
00257           SimpleState sState(state);
00258     
00259           if(directMode){
00260             std::cerr << "directMode" << std::endl;
00261 #ifdef ENABLE_DIRECT_MODE
00262             nextMovesDirect<BLACK,SimpleState,false>(sState,0);
00263 #endif
00264           }
00265           else{
00266             nextMoves<BLACK,SimpleState,false>(sState,0);
00267           }
00268         }
00269         else
00270 #endif /* MORE_STATE */
00271         {
00272         }
00273   timer.stop("total", moveCount+1);
00274   std::cerr << "maxLevel=" << maxLevel << ",moveCount=" << moveCount <<
00275     ",dropCount=" << dropCount << std::endl;
00276 
00277 }
00278 // ;;; Local Variables:
00279 // ;;; mode:c++
00280 // ;;; c-basic-offset:2
00281 // ;;; End:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines