home *** CD-ROM | disk | FTP | other *** search
/ Dream 57 / Amiga_Dream_57.iso / Amiga / Jeux / Reflexion / Crafty-15.19.lha / crafty-15.19 / src / store.c < prev    next >
C/C++ Source or Header  |  1998-09-13  |  10KB  |  237 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include "chess.h"
  4. #include "data.h"
  5.  
  6. /* last modified 08/20/98 */
  7. /*
  8. ********************************************************************************
  9. *                                                                              *
  10. *   Store_*() is used to store entries into the transposition table so that    *
  11. *   this sub-tree won't have to be searched again if the same position is      *
  12. *   reached.  a transposition/refutation table position contains the following *
  13. *   data packed into 128 bits, with each item taking the number of bits given  *
  14. *   in the table below.                                                        *
  15. *                                                                              *
  16. *     bits     name  SL  description                                           *
  17. *       3       age  61  search id to identify old trans/ref entried.          *
  18. *       2      type  59  0->value is worthless; 1-> value represents a fail-   *
  19. *                        low bound; 2-> value represents a fail-high bound;    *
  20. *                        3-> value is an exact score.                          *
  21. *       1    threat  58  threat extension flag, 1 -> extend this position.     *
  22. *      16     value  21  unsigned integer value of this position + 32767.      *
  23. *                        this might be a good score or search bound.           *
  24. *      21      move   0  best move from the current position, according to the *
  25. *                        search at the time this position was stored.          *
  26. *                                                                              *
  27. *      16     draft  48  the depth of the search below this position, which is *
  28. *                        used to see if we can use this entry at the current   *
  29. *                        position.  note that this is in units of 1/8th of a   *
  30. *                        ply.                                                  *
  31. *      48       key   0  leftmost 48 bits of the 64 bit hash key.  this is     *
  32. *                        used to "verify" that this entry goes with the        *
  33. *                        current board position.                               *
  34. *                                                                              *
  35. *   StoreBest() is called when a ply has been completed, and we are ready to   *
  36. *   back up a new best move and score to the previous ply.  we can extract the *
  37. *   best move from the current search path.                                    *
  38. *                                                                              *
  39. ********************************************************************************
  40. */
  41. void StoreBest(TREE *tree, int ply, int depth, int wtm, int value,
  42.                int alpha, int threat) {
  43.   register HASH_ENTRY *htablea, *htableb;
  44.   register BITBOARD word1, word2;
  45.   register int draft, age;
  46. /*
  47.  ----------------------------------------------------------
  48. |                                                          |
  49. |   "fill in the blank" and build a table entry from       |
  50. |   current search information.                            |
  51. |                                                          |
  52.  ----------------------------------------------------------
  53. */
  54.   if (value > alpha) {
  55.     if (abs(value) < MATE-100) word1=Shiftl((BITBOARD) (value+65536),21);
  56.     else if (value > 0) word1=Shiftl((BITBOARD) (value+ply-1+65536),21);
  57.     else word1=Shiftl((BITBOARD) (value-ply+1+65536),21);
  58.     word1=Or(word1,Shiftl((BITBOARD) ((transposition_id<<2)+EXACT_SCORE),59));
  59.     if ((int) tree->pv[ply].path_length >= ply) 
  60.       word1=Or(word1,(BITBOARD) tree->pv[ply].path[ply]);
  61.   }
  62.   else {
  63.     word1=Shiftl((BITBOARD) (value+65536),21);
  64.     word1=Or(word1,Shiftl((BITBOARD) ((transposition_id<<2)+UPPER_BOUND),59));
  65.   }
  66.   if (threat) word1=Or(word1,threat_flag);
  67.  
  68.   word2=Or(HashKey>>16,Shiftl((BITBOARD) depth,48));
  69. /*
  70.  ----------------------------------------------------------
  71. |                                                          |
  72. |   if the draft of this entry is greater than the draft   |
  73. |   of the entry in the "depth-priority" table, or if the  |
  74. |   entry in the depth-priority table is from an old       |
  75. |   search, move that entry to the always-store table and  |
  76. |   then replace the depth-priority table entry by the new |
  77. |   hash result.                                           |
  78. |                                                          |
  79.  ----------------------------------------------------------
  80. */
  81.   if (wtm) {
  82.     htablea=trans_ref_wa+(((int) HashKey) & hash_maska);
  83.     htableb=trans_ref_wb+(((int) HashKey) & hash_maskb);
  84.   }
  85.   else {
  86.     htablea=trans_ref_ba+(((int) HashKey) & hash_maska);
  87.     htableb=trans_ref_bb+(((int) HashKey) & hash_maskb);
  88.   }
  89.   draft=(int) Shiftr(htablea->word2,48);
  90.   age=(unsigned int) Shiftr(htablea->word1,61);
  91.   age=age && (age!=transposition_id);
  92.   if (age || (depth >= draft)) {
  93. # if defined(SMP)
  94.     Lock(lock_hasha);
  95.     Lock(lock_hashb);
  96. #endif
  97.     htableb->word1=htablea->word1;
  98.     htableb->word2=htablea->word2;
  99. # if defined(SMP)
  100.     UnLock(lock_hashb);
  101. #endif
  102.     htablea->word1=word1;
  103.     htablea->word2=word2;
  104. # if defined(SMP)
  105.     UnLock(lock_hasha);
  106. #endif
  107.   }
  108.   else {
  109. # if defined(SMP)
  110.     Lock(lock_hashb);
  111. #endif
  112.     htableb->word1=word1;
  113.     htableb->word2=word2;
  114. # if defined(SMP)
  115.     UnLock(lock_hashb);
  116. #endif
  117.   }
  118. }
  119.  
  120. /* last modified 03/11/98 */
  121. /*
  122. ********************************************************************************
  123. *                                                                              *
  124. *   StorePV() is called by Iterate() to insert the PV moves so they will be    *
  125. *   searched before any other moves.                                           *
  126. *                                                                              *
  127. ********************************************************************************
  128. */
  129. void StorePV(TREE *tree, int ply, int wtm) {
  130.   register BITBOARD temp_hash_key;
  131.   register HASH_ENTRY *htable;
  132. /*
  133.  ----------------------------------------------------------
  134. |                                                          |
  135. |   first, compute the initial hash address and choose     |
  136. |   which hash table (based on color) to probe.            |
  137. |                                                          |
  138.  ----------------------------------------------------------
  139. */
  140.   temp_hash_key=HashKey;
  141.   htable=((wtm) ? trans_ref_wb : trans_ref_bb)+(((int) temp_hash_key)&hash_maskb);
  142.   temp_hash_key=temp_hash_key>>16;
  143. /*
  144.  ----------------------------------------------------------
  145. |                                                          |
  146. |   now "fill in the blank" and build a table entry from   |
  147. |   current search information.                            |
  148. |                                                          |
  149.  ----------------------------------------------------------
  150. */
  151.   htable->word1=Shiftl((BITBOARD) 65536,21);
  152.   htable->word1=Or(htable->word1,Shiftl((BITBOARD) ((transposition_id<<2)+WORTHLESS),59));
  153.   htable->word1=Or(htable->word1,(BITBOARD) tree->pv[ply].path[ply]);
  154.   htable->word2=temp_hash_key;
  155. }
  156.  
  157. /* last modified 08/20/98 */
  158. /*
  159. ********************************************************************************
  160. *                                                                              *
  161. *   StoreRefutation() is called when a move at the current ply is so good it   *
  162. *   "refutes" the move made at the previous ply.  we then remember this so it  *
  163. *   can be used to do the same the next time this position is reached.         *
  164. *                                                                              *
  165. ********************************************************************************
  166. */
  167. void StoreRefutation(TREE *tree, int ply, int depth, int wtm,
  168.                      int bound, int threat) {
  169.   register HASH_ENTRY *htablea, *htableb;
  170.   register BITBOARD word1, word2;
  171.   register int draft, age;
  172. /*
  173.  ----------------------------------------------------------
  174. |                                                          |
  175. |   "fill in the blank" and build a table entry from       |
  176. |   current search information.                            |
  177. |                                                          |
  178.  ----------------------------------------------------------
  179. */
  180.   word1=Shiftl((BITBOARD) (bound+65536),21);
  181.   word1=Or(word1,Shiftl((BITBOARD) ((transposition_id<<2)+LOWER_BOUND),59));
  182.   word1=Or(word1,(BITBOARD) tree->current_move[ply]);
  183.   if (threat) word1=Or(word1,threat_flag);
  184.  
  185.   word2=Or(HashKey>>16,Shiftl((BITBOARD) depth,48));
  186. /*
  187.  ----------------------------------------------------------
  188. |                                                          |
  189. |   if the draft of this entry is greater than the draft   |
  190. |   of the entry in the "depth-priority" table, or if the  |
  191. |   entry in the depth-priority table is from an old       |
  192. |   search, move that entry to the always-store table and  |
  193. |   then replace the depth-priority table entry by the new |
  194. |   hash result.                                           |
  195. |                                                          |
  196.  ----------------------------------------------------------
  197. */
  198.   if (wtm) {
  199.     htablea=trans_ref_wa+(((int) HashKey) & hash_maska);
  200.     htableb=trans_ref_wb+(((int) HashKey) & hash_maskb);
  201.   }
  202.   else {
  203.     htablea=trans_ref_ba+(((int) HashKey) & hash_maska);
  204.     htableb=trans_ref_bb+(((int) HashKey) & hash_maskb);
  205.   }
  206.   draft=(int) Shiftr(htablea->word2,48);
  207.   age=(unsigned int) Shiftr(htablea->word1,61);
  208.   age=age && (age!=transposition_id);
  209.  
  210.   if (age || (depth >= draft)) {
  211. # if defined(SMP)
  212.     Lock(lock_hasha);
  213.     Lock(lock_hashb);
  214. #endif
  215.     htableb->word1=htablea->word1;
  216.     htableb->word2=htablea->word2;
  217. # if defined(SMP)
  218.     UnLock(lock_hashb);
  219. #endif
  220.     htablea->word1=word1;
  221.     htablea->word2=word2;
  222. # if defined(SMP)
  223.     UnLock(lock_hasha);
  224. #endif
  225.   }
  226.   else {
  227. # if defined(SMP)
  228.     Lock(lock_hashb);
  229. #endif
  230.     htableb->word1=word1;
  231.     htableb->word2=word2;
  232. # if defined(SMP)
  233.     UnLock(lock_hashb);
  234. #endif
  235.   }
  236. }
  237.