Merge pull request #32 from boraaros/feature/time-based-search

Feature/time based search

Author: boraaros

Alligator.ConnectFour/Configuration.cs

@@ -4,6 +4,7 @@ namespace Alligator.ConnectFour
 {
     internal class Configuration : IConfiguration
     {
-        public int MaxDepth => 13;
+        public int MaxDepth => 43;
+        public TimeSpan? TimeBudget => TimeSpan.FromSeconds(5);
     }
 }

Alligator.Solver/Algorithms/AlphaBetaPruning.cs

@@ -8,7 +8,6 @@ internal class AlphaBetaPruning<TPosition, TStep> : IAlphaBetaPruning<TPosition>
         private readonly IHeuristicTables<TStep> heuristicTables;
         private readonly ISearchManager searchManager;
 
-        private const int MaxSearchDepth = 16;
         private readonly List<TStep>[] orderedStepBuffers;
 
         public AlphaBetaPruning(
@@ -22,8 +21,8 @@ public AlphaBetaPruning(
             this.heuristicTables = heuristicTables ?? throw new ArgumentNullException(nameof(heuristicTables));
             this.searchManager = searchManager ?? throw new ArgumentNullException(nameof(searchManager));
 
-            orderedStepBuffers = new List<TStep>[MaxSearchDepth];
-            for (int i = 0; i < MaxSearchDepth; i++)
+            orderedStepBuffers = new List<TStep>[searchManager.MaxDepth];
+            for (int i = 0; i < searchManager.MaxDepth; i++)
             {
                 orderedStepBuffers[i] = new List<TStep>();
             }
@@ -36,11 +35,17 @@ public int Search(TPosition position, int alpha, int beta)
 
         private int SearchRecursively(TPosition position, int depth, int alpha, int beta)
         {
+            searchManager.CheckTimeBudget();
+            if (searchManager.IsAborted)
+            {
+                return 0;
+            }
+
             if (depth <= 0)
             {
                 if (rules.IsGoal(position))
                 {
-                    return -(sbyte.MaxValue + depth);
+                    return -WinValue(depth);
                 }
                 return -HeuristicValue(position, depth);
             }
@@ -73,7 +78,7 @@ private int SearchRecursively(TPosition position, int depth, int alpha, int beta
 
             if (orderedSteps.Count == 0)
             {
-                return -(rules.IsGoal(position) ? sbyte.MaxValue + depth : 0);
+                return -(rules.IsGoal(position) ? WinValue(depth) : 0);
             }
 
             var bestValue = -int.MaxValue;
@@ -98,7 +103,7 @@ private int SearchRecursively(TPosition position, int depth, int alpha, int beta
                     break;
                 }
             }
-            if (depth > 1)
+            if (depth > 1 && !searchManager.IsAborted)
             {
                 var newTransposition = new Transposition<TStep>(GetEvaluationMode(bestValue, originalAlpha, beta), bestValue, depth, bestStep);
                 cacheTables.AddTransposition(position, newTransposition);
@@ -182,5 +187,12 @@ private bool IsOpponentsTurn(int depth)
             int distanceFromRoot = searchManager.DepthLimit - depth;
             return distanceFromRoot % 2 != 0;
         }
+
+        // Distance-from-root makes this value independent of DepthLimit (important for TT consistency)
+        private int WinValue(int depth)
+        {
+            int distanceFromRoot = searchManager.DepthLimit - depth;
+            return sbyte.MaxValue + searchManager.MaxDepth - distanceFromRoot;
+        }
     }
 }

Alligator.Solver/Algorithms/AlphaBetaSolver.cs

@@ -9,20 +9,17 @@ internal class AlphaBetaSolver<TPosition, TStep> : ISolver<TStep>
         private readonly IRules<TPosition, TStep> rules;
         private readonly ISearchManager searchManager;
         private readonly Action<string> logger;
-        private readonly int maxDepth;
 
         public AlphaBetaSolver(
             AlphaBetaPruning<TPosition, TStep> alphaBetaPruning,
             IRules<TPosition, TStep> rules,
             ISearchManager searchManager,
-            Action<string> logger,
-            int maxDepth)
+            Action<string> logger)
         {
             this.alphaBetaPruning = alphaBetaPruning ?? throw new ArgumentNullException(nameof(alphaBetaPruning));
             this.rules = rules ?? throw new ArgumentNullException(nameof(rules));
             this.searchManager = searchManager ?? throw new ArgumentNullException(nameof(searchManager));
             this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
-            this.maxDepth = maxDepth;
         }
 
         public TStep OptimizeNextStep(IList<TStep> history)
@@ -32,12 +29,20 @@ public TStep OptimizeNextStep(IList<TStep> history)
             var position = CreatePosition(history);
 
             TStep? bestStep = default;
+            searchManager.StartSearch();
             var guess = 0;
 
-            for (int i = 2; i < maxDepth; i += 2) 
+            for (int i = 2; i < searchManager.MaxDepth; i += 2)
             {
                 searchManager.DepthLimit = i;
                 var (OptimalSteps, Value) = BestNodeSearch(position, guess);
+
+                if (searchManager.IsAborted)
+                {
+                    logger($"Search aborted at depth {i} after {sw.ElapsedMilliseconds} ms");
+                    break;
+                }
+
                 bestStep = OptimalSteps.First();
                 guess = Value;
                 logger($"Iteration has been completed in {sw.ElapsedMilliseconds} ms (value: {Value}, step: {bestStep}, depth: {i})");
@@ -48,8 +53,9 @@ public TStep OptimizeNextStep(IList<TStep> history)
 
         private (ICollection<TStep> OptimalSteps, int Value) BestNodeSearch(TPosition position, int guess)
         {
-            int alpha = -sbyte.MaxValue - maxDepth;
-            int beta = sbyte.MaxValue + maxDepth;
+            int winScore = sbyte.MaxValue + searchManager.MaxDepth;
+            int alpha = -winScore;
+            int beta = winScore;
 
             IList<TStep> candidates = rules.LegalStepsAt(position).ToList();
 
@@ -61,6 +67,11 @@ public TStep OptimizeNextStep(IList<TStep> history)
 
                 foreach (var move in candidates)
                 {
+                    if (searchManager.IsAborted)
+                    {
+                        break;
+                    }
+
                     if (newCandidates.Count > 1)
                     {
                         newCandidates.Add(move);
@@ -75,6 +86,11 @@ public TStep OptimizeNextStep(IList<TStep> history)
                     }
                 }
 
+                if (searchManager.IsAborted)
+                {
+                    break;
+                }
+
                 if (newCandidates.Count > 0)
                 {
                     optimalValue = guess;

Alligator.Solver/Algorithms/ISearchManager.cs

@@ -2,6 +2,11 @@
 {
     internal interface ISearchManager
     {
+        int MaxDepth { get; }
         int DepthLimit { get; set; }
+        bool IsAborted { get; }
+
+        void StartSearch();
+        void CheckTimeBudget();
     }
 }

Alligator.Solver/Algorithms/SearchManager.cs

@@ -1,12 +1,42 @@
-namespace Alligator.Solver.Algorithms
+using System.Diagnostics;
+
+namespace Alligator.Solver.Algorithms
 {
     internal class SearchManager : ISearchManager
     {
+        private const int TimeBudgetCheckInterval = 1024;
+
+        private readonly Stopwatch stopwatch = new();
+        private readonly TimeSpan timeBudget;
+        private int nodeCount;
+
+        public int MaxDepth { get; }
         public int DepthLimit { get; set; }
+        public bool IsAborted { get; private set; }
+
+        public SearchManager(int maxDepth, TimeSpan? timeBudget = null)
+        {
+            MaxDepth = maxDepth;
+            this.timeBudget = timeBudget ?? TimeSpan.Zero;
+        }
+
+        public void StartSearch()
+        {
+            nodeCount = 0;
+            IsAborted = false;
+            if (timeBudget > TimeSpan.Zero)
+            {
+                stopwatch.Restart();
+            }
+        }
 
-        public SearchManager(int depthLimit)
+        public void CheckTimeBudget()
         {
-            DepthLimit = depthLimit;
+            if (timeBudget > TimeSpan.Zero && ++nodeCount % TimeBudgetCheckInterval == 0
+                && stopwatch.Elapsed >= timeBudget)
+            {
+                IsAborted = true;
+            }
         }
     }
 }

Alligator.Solver/IConfiguration.cs

@@ -10,5 +10,12 @@ public interface IConfiguration
         /// The solver searches at even depths: 2, 4, 6, ... up to the largest even less than this value.
         /// </summary>
         int MaxDepth => 7;
+
+        /// <summary>
+        /// Optional time budget per move. When set, the solver aborts mid-search
+        /// once the budget is exceeded and returns the best result found so far.
+        /// When null, only MaxDepth limits the search.
+        /// </summary>
+        TimeSpan? TimeBudget => null;
     }
 }

Alligator.Solver/SolverProvider.cs

@@ -41,14 +41,15 @@ public ISolver<TStep> Create()
 
         internal ISolver<TStep> Create(ICacheTables<TPosition, TStep> cacheTables, IHeuristicTables<TStep> heuristicTables)
         {
-            var searchManager = new SearchManager(6); // TODO: remove this ctor parameter
+            var searchManager = new SearchManager(
+                solverConfiguration.MaxDepth,
+                solverConfiguration.TimeBudget);
 
             return new AlphaBetaSolver<TPosition, TStep>(
-                new AlphaBetaPruning<TPosition, TStep>(rules, cacheTables, heuristicTables, searchManager), 
-                rules, 
-                searchManager, 
-                logger,
-                solverConfiguration.MaxDepth);
+                new AlphaBetaPruning<TPosition, TStep>(rules, cacheTables, heuristicTables, searchManager),
+                rules,
+                searchManager,
+                logger);
         }
     }
 }

Alligator.Test/SolverTests.cs

@@ -16,11 +16,11 @@ private static int Solve(TreeNode root, int maxDepth = 7)
             var rules = new TreeRules(root);
             var cacheTables = new CacheTables<TreePosition, int>();
             var heuristicTables = new HeuristicTables<int>();
-var searchManager = new SearchManager(maxDepth - 1);
+var searchManager = new SearchManager(maxDepth);
 var alphaBeta = new AlphaBetaPruning<TreePosition, int>(
     rules, cacheTables, heuristicTables, searchManager);
 var solver = new AlphaBetaSolver<TreePosition, int>(
-    alphaBeta, rules, searchManager, _ => { }, maxDepth);
+    alphaBeta, rules, searchManager, _ => { });
 
             return solver.OptimizeNextStep([]);
         }