3 #ifndef _ALPHABETA2PARALLEL_H 
    4 #define _ALPHABETA2PARALLEL_H 
   11 #include <boost/shared_ptr.hpp> 
   12 #include <boost/thread/thread.hpp> 
   13 #include <boost/thread/mutex.hpp> 
   14 #include <boost/thread/condition.hpp> 
   15 #include <boost/ptr_container/ptr_vector.hpp> 
   25     struct AlphaBeta2ParallelCommon : boost::noncopyable
 
   31         MoveLogProb best_move;
 
   32         AlphaBeta2Window window;
 
   34         size_t nodes_searched;
 
   38       struct TreeInfo : 
public TreeInfoCommon
 
   40         CArray<volatile int, OslConfig::MaxThreads> siblings;
 
   42         MoveLogProbVector 
moves;
 
   43         volatile int move_index, search_value;
 
   44         int alpha_update, last_alpha_update;
 
   52         void set(
const TreeInfo& parent, 
int max_threads)
 
   54           TreeInfoCommon::operator=(parent);
 
   56           for (
int i=0; i<max_threads; i++)
 
   61       struct LivingThreadLock;
 
   63       static const int MaxBlocksPerCpu = 16;
 
   65       CArray<volatile int, OslConfig::MaxThreads> job;
 
   66       CArray<checkmate_t*, OslConfig::MaxThreads> checkmate;
 
   68       CArray<TreeInfo,MaxBlocks> info;
 
   70       CArray<volatile int,OslConfig::MaxThreads> waiting;
 
   71       CArray<boost::thread*,OslConfig::MaxThreads> threads;
 
   72       boost::mutex lock_smp;
 
   73       boost::condition condition_smp;
 
   74       volatile int smp_idle;
 
   76       unsigned int parallel_splits;
 
   77       unsigned int max_split_depth, descendant_reject, descendant_test;
 
   79       boost::mutex living_threads_lock;
 
   80       boost::condition living_threads_condition;
 
   81       volatile int living_threads;
 
   83       int max_threads, max_thread_group;
 
   87       AtomicCounter parallel_abort;
 
   88       AtomicCounter cancelled_splits;
 
   91       AlphaBeta2ParallelCommon();
 
   92       ~AlphaBeta2ParallelCommon();
 
   93       static checkmate_t*& checkmateSearcher(SearchState2& state) { 
return state.checkmate_searcher; }
 
   96       bool isDescendant(
int elder, 
int younger);
 
   98       struct SplitFailed {};
 
  100     template <
class EvalT>
 
  101     struct AlphaBeta2Parallel : 
public AlphaBeta2ParallelCommon
 
  105         AlphaBeta2Parallel *shared;
 
  107         Worker(
int tid, AlphaBeta2Parallel *shared);
 
  111       typedef AlphaBeta2Tree<EvalT> tree_t;
 
  112       CArray<tree_t*,MaxBlocks> tree;
 
  115       explicit AlphaBeta2Parallel(tree_t *master);
 
  116       ~AlphaBeta2Parallel();
 
  122       void threadWait(
int thread_id, 
int waiting);
 
  124       bool split(tree_t *tree, 
int tree_id, 
int thread_id, 
int max_split);
 
  125       void stopThread(
int tree_id);
 
  126       void copyToParent(
int parent, 
int child);
 
  128       int copyToChild(
int parent, 
int thread_id);
 
  130       int treeId(tree_t *tree);
 
  131       int parentID(
int tree_id) { 
return info[tree_id].parent; }
 
  132       TreeInfo* parent(
int tree_id) { 
return &info[parentID(tree_id)]; }
 
  133       const std::pair<MoveLogProb,size_t> nextMove(
int tree_id);
 
  134       size_t checkmateCount() 
const;
 
  135       size_t mainCheckmateCount() 
const;