ISearch.h

Go to the documentation of this file.

#pragma once

 
#include "../Types.h"
#include <atomic>
#include <chrono>
#include <cstdint>
#include <functional>
#include <string>
#include <vector>

struct SearchSharedData {
  std::atomic<bool> stop{false};            
  std::atomic<bool> disableTablebase{false}; 
  std::atomic<uint64_t> totalNodes{0};       
  std::atomic<int> selDepth{0};              
  std::atomic<uint64_t> tbHits{0};           
  std::atomic<uint64_t> ttHits{0};           
 
  // =========================================================================
  // LAZY SMP: Shared state for thread coordination
  // =========================================================================
  
  std::atomic<int> mainThreadScore{0}; 
  std::atomic<int> mainThreadDepth{0}; 
  std::atomic<int> targetDepth{0};     
  int numThreads{1};                   
 
  // Time management (written by Main, read by Helpers)
  std::atomic<int64_t> startTimeNs{0}; 
  int64_t softLimit = 0;               
  int64_t hardLimit = 0;               

  struct SearchConfig {
    int razorMarginD1 = 350;             
    int razorMarginD2 = 700;             
    int razorMarginD3 = 900;             
    int futilityMargin = 200;            
    int reverseFutilityMargin = 120;     
    int lmpBase = 3;                     
    int lmrThreshold = 4;                
    int nullMoveR = 3;                   
    int deltaMargin = 200;               
    int singularMargin = 50;             
    int singularMinDepth = 6;            
    int internalPruningMargin = 150;     
    int corrWeight = 10;                 
    bool enableCorrHist = true;          
  } config;
 
  // Lazy Eval Tuning
  int lazyEvalMaxDepth = 6;      
  int lazyEvalBaseMargin = 350;  
  int lazyEvalDepthMargin = 60;  
  int lazyEvalMinMargin = 200;   
  bool enableLazyEval = false;   

  enum class PruneReason : uint8_t {
    NONE = 0,           
    LMP,                
    FUTILITY,           
    SEE,                
    DRAW,               
    RAZOR,              
    REVERSE_FUTILITY,   
    NULL_MOVE,          
    INTERNAL,           
    LAZY_EVAL,          
    TB_CUTOFF,          
    TT_CUTOFF,          
    BETA_CUTOFF,        
    DEPTH_LIMIT,        
    SINGULAR_SKIP       
  };

  struct VizNode {
    uint64_t parentHash;       
    uint64_t childHash;        
    std::string move;          
    int staticEval;            
    int searchScore;           
    int depth;                 
    int ply;                   
    int moveOrder;             
    uint64_t subtreeNodes;     
    bool isPV;                 
    PruneReason pruneReason;   
  };
  
  std::vector<VizNode> vizTree; 
  bool exportTree = false;      
  int exportTreeDepth = 4;      
};

struct SearchParams {
  int wtime = 0;     
  int btime = 0;     
  int winc = 0;      
  int binc = 0;      
  int movestogo = 0; 
  int depth = SearchConstants::DEFAULT_DEPTH; 
  int nodes = 0;     
  int movetime = 0;  
  bool infinite = false; 
  bool ponder = false;   
  int multiPV = 1;       
 
  std::vector<Move> searchMoves; 
};

using InfoCallback = std::function<void(int depth, int score, int nodes,
                                        int nps, const std::vector<Move> &pv)>;

class ISearch {
public:
  virtual ~ISearch() = default;

  virtual Move startSearch(Board &root, const SearchParams &params) = 0;

  virtual void stop() = 0;

  virtual bool isSearching() const = 0;

  virtual void setInfoCallback(InfoCallback callback) = 0;

  virtual uint64_t getNodes() const = 0;
};