Class global_state

numexpr3/module.hpp:32–112

thread_data (aka th_params) was merged into global_state, as they both did the same thing. ARRAYS that need realloc on thread number change: threads, tids, params, stridesArray, iter, reduce_iter

// ARRAYS that need realloc on thread number change:
// threads, tids, params, stridesArray, iter, reduce_iter
struct global_state {
    // Global variables for threads 
    int n_thread;                    // number of desired threads in pool
    int init_threads_done;           // pool of threads initialized?
    pthread_t* threads;              // ARRAY, opaque structure for threads
    int* tids;                       // ARRAY, ID per each thread
    npy_intp gindex;                 // global index for all threads
    int init_sentinels_done;         // Flag, sentinels initialized?
    int giveup;                      // Flag, should parallel code giveup?
    int force_serial;                // Flag, force serial code instead of parallel?
    int pid;                         // the PID for this process

    // Program control and registry structs
    NumExprObject* params;           // ARRAY, copies the programs and registers for each thread.
    char* registerArena;             // Holds n_threads * MAXARGS * sizeof(NumExprReg) memory in a block

    // Temporaries in a pre-allocated block
    // A private pool/arena for temporaries so the interpreter does not have to 
    // allocate and deallocate memory with each execution.
    char* tempArena;                 // The pointer to the temporary memory region
    Py_ssize_t tempSize;             // The size of the temporary memory region

    // Syncronization variables 
    pthread_mutex_t global_mutex;    // Previously was a Python threading.Lock()
    pthread_mutex_t count_mutex;
    int count_threads;
    int barrier_passed;              // Indicates if the thread pool's thread barrier 
                                     // is unlocked and ready for the VM to process
                                     // to prevent spurious wakeups on `nix systems.
                                     // 0 indicates not past barrier, 1 indicates
                                     // the VM is running.
                                     // -1 indicates the thread has been ordered to 
                                     // exit, a function previously occupied by `end_threads`
    pthread_mutex_t count_threads_mutex;
    pthread_cond_t count_threads_cv;

    // NumPy iterator handles
    npy_intp start;
    npy_intp vlen;
    npy_intp task_size;

    npy_intp* stridesArray;              // ARRAY, one strides array per thread
    NpyIter** iter;                      // ARRAY, one iterator per thread
    NpyIter** reduce_iter;               // ARRAY, when doing nested iteration for a reduction
    bool reduction_outer_loop;           // Flag indicating reduction is the outer loop instead of the inner
    bool need_output_buffering;          // Flag indicating whether output buffering is needed

    // Global return and error handling
    int ret_code;
    int *pc_error;
    char **errorMessage;

    global_state() {
        // Initialize mutex and condition variable objects
        pthread_mutex_init(&count_mutex, NULL);
        pthread_mutex_init(&global_mutex, NULL);
        // Barrier initialization
        pthread_mutex_init(&count_threads_mutex, NULL);