Reset threads before search + exit search early

Timmoth · Timmoth · commit 000b05598d8a · 2025-04-22T10:34:11.000+01:00
diff --git a/.github/workflows/release-pipeline.yaml b/.github/workflows/release-pipeline.yaml
@@ -25,7 +25,7 @@ jobs:
         working-directory: src/Sapling
         id: get_version
         run: |
-          VERSION=1.2.4
+          VERSION=1.2.5
           echo "Application version: $VERSION"
           echo "::set-output name=version::$VERSION"
 
diff --git a/src/Sapling.Engine/DataGen/Bench.cs b/src/Sapling.Engine/DataGen/Bench.cs
@@ -99,7 +99,8 @@ public static unsafe void Run(int depth = 14)
                 Console.WriteLine(fen);
                 gameState.ResetToFen(fen);
                 stopwatch.Restart();
-                var result = searcher.Search(gameState, depthLimit: depth, writeInfo: true);
+                searcher.Reset(gameState);
+                var result = searcher.Search(gameState, searcher.Stop, depthLimit: depth, threadId: 0);
 
                 totalTime += stopwatch.ElapsedMilliseconds;
                 totalNodes += result.nodes;
diff --git a/src/Sapling.Engine/DataGen/DataGenerator.cs b/src/Sapling.Engine/DataGen/DataGenerator.cs
@@ -179,7 +179,8 @@ private unsafe void RunWorker(DataGeneratorStats stats)
             }
             else
             {
-                var (pv, _, s, _) = searcher.Search(gameState, nodeLimit: 6500, depthLimit: 60, writeInfo: false);
+                searcher.Reset(gameState);
+                var (pv, _, s, _) = searcher.Search(gameState, searcher.Stop, nodeLimit: 6500, depthLimit: 60);
                 move = pv[0];
                 score = s;
 
diff --git a/src/Sapling.Engine/Search/ParallelSearcher.cs b/src/Sapling.Engine/Search/ParallelSearcher.cs
@@ -46,11 +46,20 @@ public void Stop()
         }
     }
 
+    public void CancelSearch()
+    {
+        foreach (var searcher in Searchers)
+        {
+            searcher.Stop();
+        }
+    }
+
     public (List<uint> pv, int depthSearched, int score, long nodes, TimeSpan duration) NodeBoundSearch(
         GameState state, int nodeLimit = 0, int maxDepth = 0)
     {
         var start = DateTime.Now;
-        var searchResult = Searchers[0].Search(state, nodeLimit: nodeLimit, depthLimit: maxDepth);
+        Searchers[0].Reset(state);
+        var searchResult = Searchers[0].Search(state, CancelSearch, nodeLimit: nodeLimit, depthLimit: maxDepth);
         return (searchResult.pv, searchResult.depthSearched, searchResult.score,
             searchResult.nodes, DateTime.Now - start);
     }
@@ -69,7 +78,6 @@ public void Stop()
                     // Prevent a previous searches timeout cancelling a new search
                     return;
                 }
-
                 // Stop all searchers once think time has been reached
                 foreach (var searcher in Searchers)
                 {
@@ -79,10 +87,12 @@ public void Stop()
         }
 
         var start = DateTime.Now;
+        DateTime? end = thinkTime > 0 ? DateTime.Now.AddMilliseconds(thinkTime) : null;
 
         if (Searchers.Count == 1)
         {
-            var searchResult = Searchers[0].Search(state, writeInfo: true);
+            Searchers[0].Reset(state);
+            var searchResult = Searchers[0].Search(state, CancelSearch, timeLimit: end, threadId: 0);
             return (searchResult.pv, searchResult.depthSearched, searchResult.score,
                 searchResult.nodes, DateTime.Now - start);
         }
@@ -92,10 +102,28 @@ public void Stop()
             new ThreadLocal<(List<uint> move, int depthSearched, int score, long nodes)>(
                 () => (new List<uint>(), 0, int.MinValue, 0), true);
 
+        foreach (var searcher in Searchers)
+        {
+            searcher.Reset(state);
+        }
 
         // Parallel search, with thread-local best move
-        Parallel.For(0, Searchers.Count,
-            i => { results.Value = Searchers[i].Search(state, searchers: Searchers, writeInfo: i == 0); });
+        var threads = new Thread[Searchers.Count];
+        for (int i = 0; i < Searchers.Count; i++)
+        {
+            int threadId = i;
+            threads[i] = new Thread(() =>
+            {
+                results.Value = Searchers[threadId].Search(state, CancelSearch, timeLimit: end, threadId: threadId);
+            });
+            threads[i].Start();
+        }
+
+        // Wait for all to complete
+        foreach (var thread in threads)
+        {
+            thread.Join();
+        }
 
         var dt = DateTime.Now - start;
 
@@ -120,7 +148,8 @@ public void Stop()
 
         if (resultList.Count == 0)
         {
-            var searchResult = Searchers[0].Search(state, depthLimit:0, writeInfo: true);
+            Searchers[0].Reset(state);
+            var searchResult = Searchers[0].Search(state, CancelSearch, depthLimit:0, threadId: 0);
             return (searchResult.pv, searchResult.depthSearched, searchResult.score,
                 searchResult.nodes, DateTime.Now - start);
         }
@@ -161,17 +190,22 @@ public void Stop()
         var searchId = Guid.NewGuid();
         _prevSearchId = searchId;
 
-
         // Thread-local storage for best move in each thread
         var results =
             new ThreadLocal<(List<uint> move, int depthSearched, int score, long nodes)>(
                 () => (new List<uint>(), 0, int.MinValue, 0), true);
 
         var start = DateTime.Now;
 
+
+        foreach (var searcher in Searchers)
+        {
+            searcher.Reset(state);
+        }
+
         // Parallel search, with thread-local best move
         Parallel.For(0, Searchers.Count,
-            i => { results.Value = Searchers[i].Search(state, depthLimit: depth, writeInfo: i == 0); });
+            i => { results.Value = Searchers[i].Search(state, CancelSearch, depthLimit: depth, threadId: i); });
         var dt = DateTime.Now - start;
 
         Span<int> voteMap = stackalloc int[64 * 64];
diff --git a/src/Sapling.Engine/Search/Searcher.cs b/src/Sapling.Engine/Search/Searcher.cs
@@ -208,15 +208,12 @@ public static int GetAsperationWindow(int index)
         };
     }
 
-    public (List<uint> pv, int depthSearched, int score, long nodes) Search(GameState inputBoard, List<Searcher>? searchers = null, int nodeLimit = 0,
-        int depthLimit = 0, bool writeInfo = false)
+    public void Reset(GameState inputBoard)
     {
+        _searchCancelled = false;
         NodesVisited = 0;
         BestSoFar = 0;
 
-        var depthSearched = 0;
-        _searchCancelled = false;
-
         NativeMemory.Clear(History, (nuint)HistoryLength * sizeof(int));
         NativeMemory.Clear(Counters, (nuint)CountersLength * sizeof(uint));
         NativeMemory.Clear(killers, (nuint)KillersLength * sizeof(uint));
@@ -230,6 +227,12 @@ public static int GetAsperationWindow(int index)
         NativeMemory.Clear(BucketCacheBlackBoards, (nuint)sizeof(BoardStateData) * NnueWeights.InputBuckets * 2);
 
         Unsafe.CopyBlock(HashHistory, inputBoard.HashHistory, sizeof(ulong) * (uint)inputBoard.Board.TurnCount);
+    }
+
+    public (List<uint> pv, int depthSearched, int score, long nodes) Search(GameState inputBoard, Action cancellSearch, List<Searcher>? searchers = null, int nodeLimit = 0,
+        int depthLimit = 0, int threadId = -1, DateTime? timeLimit = null)
+    {
+        var depthSearched = 0;
 
         var alpha = Constants.MinScore;
         var beta = Constants.MaxScore;
@@ -252,6 +255,8 @@ public static int GetAsperationWindow(int index)
         var startTime = DateTime.Now;
         for (var j = 1; j < maxDepth; j++)
         {
+            var iterationStart = DateTime.Now;
+
             if (_searchCancelled || (nodeLimit > 0 && NodesVisited > nodeLimit))
             {
                 break;
@@ -297,7 +302,7 @@ public static int GetAsperationWindow(int index)
             depthSearched = j;
             bestEval = lastIterationEval;
 
-            if (writeInfo)
+            if (threadId == 0)
             {
                 var nodes = searchers?.Sum(s =>s.NodesVisited) ?? NodesVisited;
 
@@ -316,15 +321,21 @@ public static int GetAsperationWindow(int index)
                 }
 
                 Console.WriteLine(
-                    $"info depth {depthSearched} score {ScoreToString(bestEval)} nodes {nodes} nps {nps} time {(int)dt.TotalMilliseconds} pv{sb}");
+                     $"info depth {depthSearched} score {ScoreToString(bestEval)} nodes {nodes} nps {nps} time {(int)dt.TotalMilliseconds} pv{sb}");
+
+                var iterationDuration = DateTime.Now - iterationStart;
+                var timeRemaining = timeLimit - DateTime.Now;
+                if (timeRemaining.HasValue && timeRemaining.Value.TotalMilliseconds < iterationDuration.TotalMilliseconds * 1.5)
+                {
+                    cancellSearch();
+                    break;
+                }
             }
 
             if (_searchCancelled || (nodeLimit > 0 && NodesVisited > nodeLimit))
-            {
                 break;
-            }
         }
-
+        
         return (GetPvMoveList(pvMoves), depthSearched, bestEval, NodesVisited);
     }
 
diff --git a/src/Sapling/UciEngine.cs b/src/Sapling/UciEngine.cs
@@ -61,8 +61,8 @@ private void SetOption(string[] tokens)
             case "threads":
                 if (tokens[3] == "value" && int.TryParse(tokens[4], out var searchThreads))
                 {
-                    _threadCount = searchThreads;
-                    _parallelSearcher.SetThreads(searchThreads);
+                    _threadCount = Math.Clamp(searchThreads, 1, Environment.ProcessorCount);
+                    _parallelSearcher.SetThreads(_threadCount);
                     LogToFile($"[Debug] Set Threads '{searchThreads}'");
                 }
 

Original file line number	Diff line number	Diff line change
`@@ -179,7 +179,8 @@ private unsafe void RunWorker(DataGeneratorStats stats)`
`179`	`179`	`}`
`180`	`180`	`else`
`181`	`181`	`{`
`182`		`- var (pv, _, s, _) = searcher.Search(gameState, nodeLimit: 6500, depthLimit: 60, writeInfo: false);`
	`182`	`+ searcher.Reset(gameState);`
	`183`	`+ var (pv, _, s, _) = searcher.Search(gameState, searcher.Stop, nodeLimit: 6500, depthLimit: 60);`
`183`	`184`	`move = pv[0];`
`184`	`185`	`score = s;`
`185`	`186`
Original file line number	Diff line number	Diff line change
`@@ -61,8 +61,8 @@ private void SetOption(string[] tokens)`
`61`	`61`	`case "threads":`
`62`	`62`	`if (tokens[3] == "value" && int.TryParse(tokens[4], out var searchThreads))`
`63`	`63`	`{`
`64`		`- _threadCount = searchThreads;`
`65`		`- _parallelSearcher.SetThreads(searchThreads);`
	`64`	`+ _threadCount = Math.Clamp(searchThreads, 1, Environment.ProcessorCount);`
	`65`	`+ _parallelSearcher.SetThreads(_threadCount);`
`66`	`66`	`LogToFile($"[Debug] Set Threads '{searchThreads}'");`
`67`	`67`	`}`
`68`	`68`