Problem with Threading Overhead Using ThreadGroupWait to Find Spare Threads

Binning([variables and waves])

Threadstart mt, ti, Binning([variables and waves])

Function/D MTPrepare_Binning([variables and waves])
Wave [waves]
Variable [variables]


//Determine how many threads we're going to spawn, which is equal to the number of
//  processors (generally).
Variable i, dummy, nthreads = ThreadProcessorCount  //various variables
Variable mt = ThreadGroupCreate(nthreads)               //create the set of threads
Variable tgs, ti                                            //other threading variables (short for <400-character limit)

//Set up the variables which will say the first and end point per thread.
Variable i_start = 0
Variable i_end

//Main part.  Because of thread overhead, it's faster to just divide everything up
//  amongst the processors a priori if the number of bins is comparable to the number
//  of threads we can spawn.  This really takes experimentation to figure out the proper
//  number, but ≈5 seems to be reasonable.
Variable i_thread_interval = 5
if(num_bins_lon < i_thread_interval*nthreads)
    //If we're here, it's possible that the number of bins is not evenly divisible into
    //  the number of processors.  Count down 'til they are.
    do
        dummy = mod(num_bins_lon,nthreads)
        if(dummy != 0)
            nthreads -= 1
        endif
    while(dummy != 0)
   
    printf "Using %d threads (evenly dividing %d longitude bins into %d per thread).\r", nthreads, num_bins_lon, num_bins_lon/nthreads
   
    //Create the threads and have them do their duty.
    for(i=0; i<nthreads; i+=1)
        i_start = num_bins_lon/nthreads*i
        i_end = num_bins_lon/nthreads*(i+1) - 1

        ThreadStart mt, i, Binning([variables and waves],i_start, i_end)
    endfor
   
    //Some threads will end before others, so wait and check every 100 ms to check for
    //  when everything is done.
    do
        tgs = ThreadGroupWait(mt, 100)
    while(tgs != 0)

//Okay, the number of bins is >> the number of processors (or threads we can spawn),
//  so g'head and do the threads one at a time.
else
    printf "Using %d threads (UNevenly dividing %d longitude bins into *roughly* %d per thread).\r", nthreads, num_bins_lon, num_bins_lon/nthreads
   
    //First, spawn every thread that we can.
    i = 0
    do
        i_start = i*i_thread_interval
        i_end = (i+1)*i_thread_interval - 1
       
        ThreadStart mt, i, Binning([variables and waves],i_start, i_end)
        i += 1
    while(i < nthreads)
    dummy = i_end+1
   
    //Spawn threads as they become available.
    for(i=dummy; i<num_bins_lon; i+=i_thread_interval)
        i_start = i
        i_end = i+i_thread_interval-1

        //Get the index of the first free thread (only works with Igor Pro 6.23 or later).
        if(ThreadGroupWait(mt,50) != 0)     //to reduce the thread overhead (time spent in the for-endfor loop), only check every 100 ms to see if there's an available thread
            ti = ThreadGroupWait(mt,-2)-1   //store the index of the first available thread (or <0 if there isn't any)
            if(ti < 0)                          //if there's nothing available ...
                i -= i_thread_interval          //... then reset the for-endfor loop to where we were before this ...
                continue                        //... and go back to the beginning of it
            endif
        endif
       
        ThreadStart mt, ti, Binning([variables and waves],i_start, i_end)
    endfor
   
    //The last couple threads will keep going outside of that for-endfor loop, so wait and
    //  check every 100 ms to check for when everything is done.
    do
        tgs = ThreadGroupWait(mt, 100)
    while(tgs != 0)
endif

//Release the threads.
dummy = ThreadGroupRelease(mt)

End