Modify code for unlimited number of threads.

Author: danielabdi-noaa

src/Makefile

@@ -32,7 +32,6 @@ STRIP_CMD = strip
 # DCLUSTER        -- Compile MPI cluster code
 # DCLUSTER_TT_TYPE=n -- Distributed transposition table type
 #                    (0 - global, 1 - distributed, 2 - local) default=2
-# DMAX_CPUS=n     -- Compile for maximum of n cpus
 # DYBW            -- Compile with YBW
 # DTUNE           -- Compile evaluation tuning code [NOT recommended]
 # DMYDEBUG        -- Turn on some MPI debugging
@@ -44,7 +43,6 @@ ARCH_DEFINES = -DARC_64BIT -DHAS_POPCNT
 
 # Feature options
 FEATURE_DEFINES = -DNNUE_INC
-#FEATURE_DEFINES += -DMAX_CPUS=1360
 
 # Conditional options based on compiler
 CONDITIONAL_DEFINES = 

src/mcts.cpp

@@ -73,8 +73,9 @@ static std::atomic_int n_collisions = {0};
 static std::atomic_int n_terminals = {0};
 
 /*Nodes and edges of tree*/
-std::vector<Node*> Node::mem_[MAX_CPUS];
-std::vector<uint16_t*>  Edges::mem_[MAX_CPUS][MAX_MOVES_NN >> 3];
+std::vector<std::vector<Node*>> Node::mem_;
+std::vector<std::vector<Node*>> Node::gc;
+std::vector<std::array<std::vector<uint16_t*>, (MAX_MOVES_NN >> 3)>> Edges::mem_;
 std::atomic_uint Node::total_nodes = {0};
 unsigned int Node::max_tree_nodes = 0;
 unsigned int Node::max_tree_depth = 0;
@@ -270,12 +271,12 @@ void Node::reset_bounds(Node* n) {
     }
 }
 
-void Node::split(Node* n, std::vector<Node*>* pn, const int S, int& T) {
+void Node::split(Node* n, const int S, int& T) {
     static int id = 0;
     Node* current = n->child;
     while(current) {
         if(current->visits <= (unsigned)S || !current->child) {
-            pn[id].push_back(current);
+            Node::gc[id].push_back(current);
             current->set_dead();
 
             T += current->visits;
@@ -284,7 +285,7 @@ void Node::split(Node* n, std::vector<Node*>* pn, const int S, int& T) {
                 if(++id >= PROCESSOR::n_processors) id = 0;
             }
         } else {
-            split(current,pn,S,T);
+            split(current,S,T);
         }
         current = current->next;
     }
@@ -1765,31 +1766,29 @@ void SEARCHER::search_mc(bool single, unsigned int nodes_limit) {
 /*
 Traverse tree in parallel
 */
-static std::vector<Node*> gc[MAX_CPUS+1];
-
 void CDECL gc_thread_proc(void* seid_) {
     int* seid = (int*)seid_;
     for(int proc_id = seid[0]; proc_id < seid[1]; proc_id++) {
-        for(unsigned int i = 0; i < gc[proc_id].size(); i++) {
-            Node::reclaim(gc[proc_id][i],proc_id);
+        for(unsigned int i = 0; i < Node::gc[proc_id].size(); i++) {
+            Node::reclaim(Node::gc[proc_id][i],proc_id);
         }
     }
 }
 void CDECL rank_reset_thread_proc(void* seid_) {
     int* seid = (int*)seid_;
     for(int proc_id = seid[0]; proc_id < seid[1]; proc_id++) {
-        for(unsigned int i = 0; i < gc[proc_id].size(); i++) {
-            Node::rank_children(gc[proc_id][i]);
-            Node::reset_bounds(gc[proc_id][i]);
+        for(unsigned int i = 0; i < Node::gc[proc_id].size(); i++) {
+            Node::rank_children(Node::gc[proc_id][i]);
+            Node::reset_bounds(Node::gc[proc_id][i]);
         }
     }
 }
 
 void CDECL convert_score_thread_proc(void* seid_) {
     int* seid = (int*)seid_;
     for(int proc_id = seid[0]; proc_id < seid[1]; proc_id++) {
-        for(unsigned int i = 0; i < gc[proc_id].size(); i++) {
-            Node::convert_score(gc[proc_id][i]);
+        for(unsigned int i = 0; i < Node::gc[proc_id].size(); i++) {
+            Node::convert_score(Node::gc[proc_id][i]);
         }
     }
 }
@@ -1803,15 +1802,15 @@ void Node::parallel_job(Node* n, PTHREAD_PROC func, bool recursive) {
     for(int i = 1;i < PROCESSOR::n_processors;i++)
         PROCESSOR::park(i);
 
-    Node::split(n, gc, S, T);
+    Node::split(n, S, T);
 
     int* seid = new int[2 * ncores];
     std::thread* tid = new std::thread[ncores];
 
     if(!recursive)
-        gc[0].push_back(n);
+        Node::gc[0].push_back(n);
     else {
-        gc[nprocs].push_back(n);
+        Node::gc[nprocs].push_back(n);
         seid[0] = nprocs;
         seid[1] = nprocs + 1;
         tid[0] = t_create(*func,&seid[0]);
@@ -1830,10 +1829,10 @@ void Node::parallel_job(Node* n, PTHREAD_PROC func, bool recursive) {
     delete[] tid;
 
     for(int i = 0; i < nprocs;i++) {
-        for(unsigned int j = 0; j < gc[i].size(); j++) {
-            gc[i][j]->clear_dead();
+        for(unsigned int j = 0; j < Node::gc[i].size(); j++) {
+            Node::gc[i][j]->clear_dead();
         }
-        gc[i].clear();
+        Node::gc[i].clear();
     }
 
     for(int i = 1;i < PROCESSOR::n_processors;i++)

src/parallel.cpp

@@ -9,7 +9,7 @@
 *    at each node will create enough threads to engage all its processors.
 */
 
-static std::thread threads[MAX_CPUS];
+static std::vector<std::thread> threads;
 
 #ifdef CLUSTER
 
@@ -904,6 +904,12 @@ void SEARCHER::update_master(int skip) {
 * Copy board and other relevant data..
 */
 void SEARCHER::attach_processor(int new_proc_id) {
+    if(workers == 0) {
+        workers = new std::atomic<SEARCHER*>[PROCESSOR::n_processors];
+        for(int i = 0; i < PROCESSOR::n_processors; i++)
+            workers[i] = 0;
+    }
+
     int j = 0;
     for(j = 0; (j < MAX_SEARCHERS_PER_CPU) && processors[new_proc_id]->searchers[j].used; j++);
     if(j < MAX_SEARCHERS_PER_CPU) {
@@ -941,8 +947,6 @@ void SEARCHER::clear_block() {
     host_workers.clear();
 #endif
     n_workers = 0;
-    for(int i = 0; i < PROCESSOR::n_processors;i++)
-        workers[i] = 0;
     l_unlock(lock);
 
     /*reset counts*/
@@ -961,12 +965,14 @@ void SEARCHER::clear_block() {
 */
 void SEARCHER::stop_workers() {
     l_lock(lock);
-    for(int i = 0; i < PROCESSOR::n_processors; i++) {
-        SEARCHER* pworker = workers[i].load();
-        if(pworker) {
-            if(pworker->n_workers) 
-                pworker->stop_workers();
-            pworker->stop_searcher = 1;
+    if(workers) {
+        for(int i = 0; i < PROCESSOR::n_processors; i++) {
+            SEARCHER* pworker = workers[i].load();
+            if(pworker) {
+                if(pworker->n_workers) 
+                    pworker->stop_workers();
+                pworker->stop_searcher = 1;
+            }
         }
     }
 #ifdef CLUSTER
@@ -1126,6 +1132,13 @@ void PROCESSOR::wait(int id) {
 * Initialize mt number of threads by creating/deleting 
 * threads from the pool of processors.
 */
+static void resize_threads(int mt) {
+    threads.resize(mt);
+    processors.resize(mt, 0);
+    Node::mem_.resize(mt);
+    Node::gc.resize(mt+1);
+    Edges::mem_.resize(mt);
+}
 void init_smp(int mt) {
     PPROCESSOR proc = processors[0];
     int n_procs = PROCESSOR::n_processors;
@@ -1134,7 +1147,8 @@ void init_smp(int mt) {
     reset_tables(proc,0);
 
     if(n_procs < mt) {
-        for(int i = 1; i < MAX_CPUS;i++) {
+        resize_threads(mt);
+        for(int i = 1; i < mt;i++) {
             if(n_procs < mt) {
                 if(processors[i] == 0) {
                     PROCESSOR::create(i);
@@ -1145,14 +1159,15 @@ void init_smp(int mt) {
         while(PROCESSOR::n_idle_processors < mt - 1)
             t_yield();
     } else if(n_procs > mt) {
-        for(int i = MAX_CPUS - 1; i >= 1;i--) {
+        for(int i = n_procs - 1; i >= 1;i--) {
             if(n_procs > mt) {
                 if(processors[i] != 0) {
                     PROCESSOR::kill(i);
                     n_procs--;
                 }
             }
         }
+        resize_threads(mt);
     }
 }
 
@@ -1165,5 +1180,6 @@ void PROCESSOR::set_main() {
     proc->searcher->used = true;
     proc->searcher->processor_id = 0;
     proc->state = GO;
+    resize_threads(1);
     processors[0] = proc;
 }

src/probe.cpp

@@ -384,10 +384,10 @@ bool SEARCHER::bitbase_cutoff() {
 Neural network
 */
 
-static float* inp_planes[MAX_CPUS];
-static unsigned short* all_pindex[MAX_CPUS];
-static float* all_policy[MAX_CPUS];
-static float all_wdl[MAX_CPUS][3];
+static std::vector<float*> inp_planes;
+static std::vector<unsigned short*> all_pindex;
+static std::vector<float*> all_policy;
+static std::vector<std::array<float,3>> all_wdl;
 
 void init_input_planes() {
     static bool init_done = false;
@@ -399,6 +399,11 @@ void init_input_planes() {
                (8 * 8 * net_channels[NNUE] * 2) :
                (8 * 8 * net_channels[LCZERO]);
 
+    inp_planes.reserve(PROCESSOR::n_processors);
+    all_pindex.reserve(PROCESSOR::n_processors);
+    all_policy.reserve(PROCESSOR::n_processors);
+    all_wdl.reserve(PROCESSOR::n_processors);
+
     aligned_reserve<float>(planes, PROCESSOR::n_processors * N_PLANE);
     aligned_reserve<unsigned short>(index, PROCESSOR::n_processors * MAX_MOVES_NN);
     aligned_reserve<float>(policy, PROCESSOR::n_processors * MAX_MOVES_NN);

src/scorpio.cpp

@@ -34,7 +34,7 @@ int move_overhead = 1500;
 /*
 parallel search
 */
-PPROCESSOR processors[MAX_CPUS] = {0};
+std::vector<PPROCESSOR> processors;
 int PROCESSOR::n_processors;
 int PROCESSOR::n_cores;
 std::atomic_int PROCESSOR::n_idle_processors;
@@ -437,7 +437,7 @@ static void print_options() {
     print_check("log",log_on);
     print_button("clear_hash");
     print_spin("resign",SEARCHER::resign_value,100,30000);
-    print_spin("mt",PROCESSOR::n_processors,1,MAX_CPUS);
+    print_spin("mt",PROCESSOR::n_processors,1,(1<<20));
     print_spin("ht",ht,1,131072);
     print_spin("eht",eht,1,16384);
     print_spin("pht",pht,1,256);
@@ -537,7 +537,6 @@ int internal_commands(char** commands,char* command,int& command_num) {
         */
     } else if(!strcmp(command,"affinity")) {
         int affinity = atoi(commands[command_num]);
-        affinity = MIN(affinity, MAX_CPUS);
         PROCESSOR::n_cores = set_affinity(affinity);
         command_num++;
     } else if(!strcmp(command,"mt") || !strcmp(command,"cores") || !strcmp(command,"Threads") ) {
@@ -553,7 +552,6 @@ int internal_commands(char** commands,char* command,int& command_num) {
                 mt = PROCESSOR::n_cores / r;
             } else
                 mt = atoi(commands[command_num]);
-            mt = MIN(mt, MAX_CPUS);
             ht_setting_changed = true;
         }
         command_num++;

src/scorpio.h

@@ -33,6 +33,7 @@ Some definitions to include/remove code
 #   include <sys/time.h>
 #endif
 #include <vector>
+#include <array>
 #ifdef CLUSTER
 #  include <list>
 #  include "mpi.h"
@@ -42,9 +43,6 @@ Some definitions to include/remove code
 /*
 parallel search options
 */
-#if !defined(MAX_CPUS)
-#   define MAX_CPUS             512
-#endif
 #if defined(YBW)
 #   define MAX_SEARCHERS_PER_CPU 32
 #   define MAX_CPUS_PER_SPLIT     8
@@ -425,7 +423,7 @@ class Edges {
 
     static void allocate(Edges&, int, int);
     static void reclaim(Edges&, int);
-    static std::vector<uint16_t*> mem_[MAX_CPUS][MAX_MOVES_NN >> 3];
+    static std::vector<std::array<std::vector<uint16_t*>, (MAX_MOVES_NN >> 3)>> mem_;
 };
 /*
 * Nodes of the tree
@@ -517,9 +515,10 @@ struct Node {
     static unsigned int max_tree_nodes;
     static unsigned int max_tree_depth;
     static unsigned int sum_tree_depth;
-    static std::vector<Node*> mem_[MAX_CPUS];
+    static std::vector<std::vector<Node*>> mem_;
+    static std::vector<std::vector<Node*>> gc;
     static Node* allocate(int);
-    static void  split(Node*, std::vector<Node*>*, const int, int&);
+    static void  split(Node*, const int, int&);
     static void  reclaim(Node*,int);
     static void  rank_children(Node*);
     static void  convert_score(Node*);
@@ -882,7 +881,7 @@ typedef struct SEARCHER{
     void clear_block();
     LOCK lock;
     std::atomic_int n_workers;
-    std::atomic<SEARCHER*> workers[MAX_CPUS];
+    std::atomic<SEARCHER*>* workers;
 
     int get_smp_move();
     int check_split();
@@ -1220,7 +1219,7 @@ typedef struct PROCESSOR {
 
 } *PPROCESSOR;
 
-extern PPROCESSOR processors[MAX_CPUS];
+extern std::vector<PPROCESSOR> processors;
 
 /*
 multi processors

src/search.cpp

@@ -1342,7 +1342,7 @@ void SEARCHER::search() {
     /*alphabeta*/
     } else {
         bool split_work = 
-            (use_abdada_smp && search_depth > PROCESSOR::SMP_SPLIT_DEPTH);
+            (PROCESSOR::n_processors > 1 && use_abdada_smp && search_depth > PROCESSOR::SMP_SPLIT_DEPTH);
 
         /*attach helper processor here once for abdada*/
         if(split_work) {
@@ -2035,7 +2035,7 @@ MOVE SEARCHER::find_best() {
 
     /*park threads*/
     int n_end = (montecarlo && montecarlo_skipped) ? 
-        PROCESSOR::n_cores : PROCESSOR::n_processors;
+        MIN(PROCESSOR::n_cores, PROCESSOR::n_processors) : PROCESSOR::n_processors;
     for(int i = 1;i < n_end;i++)
         PROCESSOR::park(i);
 #if defined(CLUSTER)

src/util.cpp

@@ -1054,8 +1054,7 @@ SEARCHER::SEARCHER() : board(&temp_board[36])
     l_create(lock);
     used = false;
     n_workers = 0;
-    for(int i = 0; i < MAX_CPUS;i++)
-        workers[i] = NULL;
+    workers = 0;
     processor_id = 0;
 #ifdef CLUSTER
     host_workers.clear();