Solved mutithread issue and bumped v0.12.6

There were an issue on multithreaded code that would have crashed when the number of interactive threads
would have been set >1 (from command line).
This commit correctly account for whatever the number of interactive threads is.

Author: sylvaticus

Project.toml

@@ -1,7 +1,7 @@
 name = "BetaML"
 uuid = "024491cd-cc6b-443e-8034-08ea7eb7db2b"
 authors = ["Antonello Lobianco <antonello@lobianco.org>"]
-version = "0.12.5"
+version = "0.12.6"
 
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"

src/Trees/RandomForests.jl

@@ -224,11 +224,11 @@ function buildForest(x, y::AbstractArray{Ty,1}, n_trees=30; max_depth = size(x,1
     end
 
     masterSeed = rand(rng,100:Int(floor(typemax(Int64)/10000))) # Some RNG have problems with very small seed. Also, the master seed has to be computed _before_ generate_parallel_rngs
-    rngs = generate_parallel_rngs(rng,Threads.nthreads()+1)
+    rngs = generate_parallel_rngs(rng,Threads.nthreads())
 
     #for i in 1:n_trees # for easier debugging/profiling...
     Threads.@threads for i in 1:n_trees
-        tsrng = rngs[Threads.threadid()] # Thread safe random number generator
+        tsrng = rngs[Threads.threadid()-Threads.nthreads(:interactive)] # Thread safe random number generator
         Random.seed!(tsrng,masterSeed+i*10)
         toSample = rand(tsrng, 1:N, Int(round(N*sampling_share)))
         notToSample = setdiff(1:N,toSample)

src/Utils/Processing.jl

@@ -1223,11 +1223,11 @@ function tune!(m,method::GridSearch,data)
     subs = partition([data...],[res_share,1-res_share],rng=rng, copy=true)
     sampleddata = (collect([subs[i][1] for i in 1:length(subs)])...,)
     masterSeed = rand(rng,100:typemax(Int64))
-    rngs       = generate_parallel_rngs(rng,Threads.nthreads()+1) 
+    rngs       = generate_parallel_rngs(rng,Threads.nthreads()) 
     n_candidates = length(candidates)
     @threadsif multithreads for c in 1:n_candidates
         candidate = candidates[c]
-        tsrng = rngs[Threads.threadid()] 
+        tsrng = rngs[Threads.threadid()-Threads.nthreads(:interactive)] 
         Random.seed!(tsrng,masterSeed+c*10)
         options(m).verbosity == FULL && println("Testing candidate $candidate")
         mc = deepcopy(m)
@@ -1285,12 +1285,12 @@ function tune!(m,method::SuccessiveHalvingSearch,data)
         options(m).verbosity >= STD && println("(e $e / $epochs) N data / n candidates / n candidates to retain : $(n_orig * res_share) \t $ncandidates_thisepoch $ncandidates_tokeep")
         scores = Vector{Tuple{Float64,Dict}}(undef,ncandidates_thisepoch)
         masterSeed = rand(rng,100:typemax(Int64))
-        rngs       = generate_parallel_rngs(rng,Threads.nthreads()+1) 
+        rngs       = generate_parallel_rngs(rng,Threads.nthreads()) 
         n_candidates = length(candidates)
         ncandidates_thisepoch == n_candidates || error("Problem with number of candidates!")
         @threadsif multithreads for c in 1:n_candidates
             candidate=candidates[c]
-            tsrng = rngs[Threads.threadid()]
+            tsrng = rngs[Threads.threadid()-Threads.nthreads(:interactive)]
             Random.seed!(tsrng,masterSeed+c*10) 
             options(m).verbosity == FULL && println("(e $e) Testing candidate $candidate")
             mc = deepcopy(m)

src/Utils/Stochasticity.jl

@@ -15,14 +15,14 @@ For multi-threaded models, return n independent random number generators (one pe
 
 Note that each ring is a _copy_ of the original random ring. This means that code that _use_ these RNGs will not change the original RNG state.
 
-Use it with `rngs = generate_parallel_rngs(rng,Threads.nthreads()+1)` to have a separate rng per thread.
-**Attention**: the `+1` is necessary from Julia 1.12 onwards, because the main thread is counted differently. 
+Use it with `rngs = generate_parallel_rngs(rng,Threads.nthreads()` to have a separate rng per thread.
+**Attention**: `Threads.threadid()` of working threads is between `Threads.nthreads(:interactive)` and `Threads.nthreads(:interactive)+Threads.nthreads(:default)`
 By default the function doesn't re-seed the RNG, as you may want to have a loop index based re-seeding strategy rather than a threadid-based one (to guarantee the same result independently of the number of threads).
 If you prefer, you can instead re-seed the RNG here (using the parameter `reSeed=true`), such that each thread has a different seed. Be aware however that the stream  of number generated will depend from the number of threads at run time.
 """
 function generate_parallel_rngs(rng::AbstractRNG, n::Integer;reSeed=false)
     if reSeed
-        seeds = [rand(rng,100:18446744073709551615) for i in 1:n] # some RNGs have issues with too small seed
+        seeds = [rand(rng,100:Int(ceil(typemax(Int64)/1000))) for i in 1:n] # some RNGs have issues with too small seed
         rngs  = [deepcopy(rng) for i in 1:n]
         return Random.seed!.(rngs,seeds)
     else

test/Utils_tests.jl

@@ -729,10 +729,10 @@ function innerFunction(bootstrappedx; rng=Random.GLOBAL_RNG)
 end
 function outerFunction(x;rng = Random.GLOBAL_RNG)
     masterSeed = rand(rng,100:Int(floor(typemax(Int64)/10000))) # important: with some RNG it is important to do this before the generate_parallel_rngs to guarantee independance from number of threads
-    rngs       = generate_parallel_rngs(rng,Threads.nthreads()+1) # make new copy instances
+    rngs       = generate_parallel_rngs(rng,Threads.nthreads()) # make new copy instances
     results    = Array{Float64,1}(undef,30)
     Threads.@threads for i in 1:30
-        tsrng = rngs[Threads.threadid()]    # Thread safe random number generator: one RNG per thread
+        tsrng = rngs[Threads.threadid()-Threads.nthreads(:interactive)]    # Thread safe random number generator: one RNG per thread
         Random.seed!(tsrng,masterSeed+i*10) # But the seeding depends on the i of the loop not the thread: we get same results indipendently of the number of threads
         toSample = rand(tsrng, 1:100,100)
         bootstrappedx = x[toSample]