1 files changed, 117 insertions, 1 deletions

diff --git a/src/dynamic.c b/src/dynamic.c
index 694fe50..5915721 100755
--- a/src/dynamic.c
+++ b/src/dynamic.c
@@ -43,6 +43,7 @@ Revision History:
 extern double log(double);
 
 ULONG g_HistoryCounters[14][128];
+ULONG g_ContinuationHistory[CONTINUATION_TABLE_SIZE];
 SCORE g_iLMRQuietReduction[MAX_PLY_PER_SEARCH + 1][LMR_TABLE_MAX_MOVES + 1];
 
 // Keyed by (cFrom, cTo, pMoved) -- the low 20 bits of mv.uMove -- rather
@@ -178,6 +179,7 @@ Return value:
     ULONG u;
 
     memset(g_HistoryCounters, 0, sizeof(g_HistoryCounters));
+    memset(g_ContinuationHistory, 0, sizeof(g_ContinuationHistory));
     for (u = 0; u < FH_STATS_TABLE_SIZE; u++) 
     {
         g_FailHighs[u].uWholeThing = 0x00010001;
@@ -780,6 +782,111 @@ Return value:
 }
 
 
+static void
+_IncrementContinuationCounter(MOVE mvPrev, MOVE mv, ULONG uRemainingDepth)
+/**
+
+Routine description:
+
+    Continuation-history counterpart to _IncrementMoveHistoryCounter --
+    same (depth+1)^2 growth, same overflow-driven rescale, but keyed by
+    (mvPrev, mv) instead of mv alone. No-op if there was no previous
+    move (root).
+
+Parameters:
+
+    MOVE mvPrev,
+    MOVE mv,
+    ULONG uRemainingDepth
+
+Return value:
+
+    void
+
+**/
+{
+    ULONG uVal;
+    ULONG *pu;
+    ULONG x;
+
+    ASSERT(!IS_CAPTURE_OR_PROMOTION(mv));
+    if (0 == mvPrev.uMove)
+    {
+        return;
+    }
+    uVal = uRemainingDepth / ONE_PLY;
+    ASSERT(uVal >= 0);
+    ASSERT(uVal <= MAX_PLY_PER_SEARCH);
+    uVal += 1;
+    uVal *= uVal;
+    ASSERT(uVal > 0);
+
+    pu = &(g_ContinuationHistory[(MOVE_TO_CONT_KEY(mvPrev) * CONT_KEY_RANGE) +
+                                  MOVE_TO_CONT_KEY(mv)]);
+    LOCK_DYN;
+    *pu += uVal;
+    while (*pu & ~STRIP_OFF_FLAGS)
+    {
+        for (x = 0; x < CONTINUATION_TABLE_SIZE; x++)
+        {
+            g_ContinuationHistory[x] >>= 4;
+        }
+    }
+    UNLOCK_DYN;
+}
+
+
+static void
+_DecrementContinuationCounter(MOVE mvPrev, MOVE mv, ULONG uRemainingDepth)
+/**
+
+Routine description:
+
+    Continuation-history counterpart to _DecrementMoveHistoryCounter.
+    No-op if there was no previous move (root).
+
+Parameters:
+
+    MOVE mvPrev,
+    MOVE mv,
+    ULONG uRemainingDepth
+
+Return value:
+
+    void
+
+**/
+{
+    ULONG uVal;
+    ULONG *pu;
+
+    ASSERT(!IS_CAPTURE_OR_PROMOTION(mv));
+    if (0 == mvPrev.uMove)
+    {
+        return;
+    }
+    uVal = uRemainingDepth / ONE_PLY;
+    ASSERT(uVal >= 0);
+    ASSERT(uVal <= MAX_PLY_PER_SEARCH);
+    uVal /= 4;
+    uVal += 1;
+    ASSERT(uVal > 0);
+
+    pu = &(g_ContinuationHistory[(MOVE_TO_CONT_KEY(mvPrev) * CONT_KEY_RANGE) +
+                                  MOVE_TO_CONT_KEY(mv)]);
+    LOCK_DYN;
+    if (*pu >= uVal)
+    {
+        *pu -= uVal;
+    }
+    else
+    {
+        *pu = 0;
+    }
+    UNLOCK_DYN;
+}
+
+
 void 
 UpdateDynamicMoveOrdering(IN SEARCHER_THREAD_CONTEXT *ctx,
                           IN ULONG uRemainingDepth,
@@ -811,6 +918,9 @@ Return value:
 {
     ULONG u;
     MOVE mv;
+    MOVE mvPrev;
+
+    mvPrev.uMove = (ctx->uPly > 0) ? (ctx->sPlyInfo[ctx->uPly - 1]).mv.uMove : 0;
 
     //
     // Add this move to the killer list and increment its history count
@@ -820,6 +930,7 @@ Return value:
         _NewKillerMove(ctx, mvBest, iScore);
         _NewCounterMove(ctx, mvBest, uRemainingDepth);
         _IncrementMoveHistoryCounter(mvBest, uRemainingDepth);
+        _IncrementContinuationCounter(mvPrev, mvBest, uRemainingDepth);
     }
 
     //
@@ -838,6 +949,7 @@ Return value:
         if (!IS_CAPTURE_OR_PROMOTION(mv))
         {
             _DecrementMoveHistoryCounter(mv, uRemainingDepth);
+            _DecrementContinuationCounter(mvPrev, mv, uRemainingDepth);
         }
     }
 }
@@ -923,7 +1035,7 @@ Return value:
 **/
 {
     ULONG x, y;
-    
+
     LOCK_DYN;
     for (x = 0; x <= WHITE_KING; x++)
     {
@@ -932,5 +1044,9 @@ Return value:
             g_HistoryCounters[x][y] >>= 1;
         }
     }
+    for (x = 0; x < CONTINUATION_TABLE_SIZE; x++)
+    {
+        g_ContinuationHistory[x] >>= 1;
+    }
     UNLOCK_DYN;
 }