Remove code specific to older Julia versions

Author: oschulz

src/onthreads.jl

@@ -7,9 +7,6 @@ function _current_thread_selected(threadsel::Union{Integer,AbstractVector{<:Inte
 end
 
 
-@static if VERSION >= v"1.3.0-alpha.0"
-
-
 # From Julia PR 32477:
 function _run_on(t::Task, tid)
     @assert !istaskstarted(t)
@@ -52,82 +49,12 @@ function _thread_exec_func(threadsel, expr)
 end
 
 
-else #VERSION < v"1.3.0-alpha.0"
-
-
-const _thread_local_error_err = ThreadLocal{Any}(undef)
-const _thread_local_error_set = ThreadLocal{Bool}(undef)
-
-
-_clear_thread_local_errors() = fill!(getallvalues(_thread_local_error_set), false)
-
-function _check_thread_local_errors()
-    i = something(findfirst(isequal(true), getallvalues(_thread_local_error_set)), 0)
-    (i > 0) && throw(getallvalues(_thread_local_error_err)[i])
-    nothing
-end
-
-function _set_thread_local_error(err)
-    _thread_local_error_err[] = err
-    _thread_local_error_set[] = true
-end
-
-function _check_threadsel(threadsel::Union{Integer,AbstractVector{<:Integer}})
-    if !checkindex(Bool, allthreads(), threadsel)
-        throw(ArgumentError("Thread selection not within available threads"))
-    end
-    threadsel
-end
-
-
-function _run_on_threads(f)
-    try
-        @assert(!Base.Threads.in_threaded_loop[], "Can't nest threaded execution")
-        _clear_thread_local_errors()
-        Base.Threads.in_threaded_loop[] = true
-        ccall(:jl_threading_run, Ref{Cvoid}, (Any,), f)
-    finally
-        Base.Threads.in_threaded_loop[] = false
-        _check_thread_local_errors()
-    end
-end
-
-
-function _thread_exec_func(threadsel, expr)
-    quote
-        local thread_body_wrapper_fun
-        let threadsel_eval = $(esc(threadsel))
-            function thread_body_wrapper_fun()
-                try
-                    if Base.Threads.threadid() in threadsel_eval
-                        $(esc(expr))
-                    end
-                catch err
-                    _set_thread_local_error(err)
-                    rethrow()
-                end
-            end
-            if _current_thread_selected(threadsel_eval)
-                thread_body_wrapper_fun()
-            else
-                _run_on_threads(thread_body_wrapper_fun)
-            end
-            nothing
-        end
-    end
-end
-
-
-end # Julia version-dependent code
-
-
-
 """
     allthreads()
 
-Convencience function, returns `1:Base.Threads.nthreads()`.
+Convencience function, returns an equivalent of `1:Base.Threads.nthreads()`.
 """
-allthreads() = 1:nthreads()
+allthreads() = Base.OneTo(Base.Threads.nthreads())
 export allthreads
 
 
@@ -140,14 +67,6 @@ Execute code in `expr` in parallel on the threads in `threadsel`.
 If `threadsel == Base.Threads.threadid()`, `expr` is run on the current
 tread with only minimal overhead.
 
-Note: Currently, multiple `@onthreads` sections will not run in parallel
-to each other, even if they use disjunct sets of threads, due to limitations
-of the Julia multithreading implementation. This restriction is likely to
-disappear in future Julia versions.
-
-In contrast to `Base.Threads.@threads`, `@onthreads` does forward
-exceptions to the caller.
-
 Example 1:
 
 ```juliaexpr
@@ -191,8 +110,8 @@ end
 """
     @mt_out_of_order begin expr... end
 
-Runs all top-level expressions in `begin expr... end` on parallel tasks.
-On Julia >= v1.3, the tasks will run multi-threaded.
+Runs all top-level expressions in `begin expr... end` on parallel
+multi-threaded tasks.
 
 Example:
 

src/threadlocal.jl

@@ -124,13 +124,5 @@ Base.get!(x::ThreadLocal, default) = get!(() -> default, x)
 Base.isassigned(x::ThreadLocal) = isassigned(x.value, threadid())
 
 function getallvalues(x::ThreadLocal)
-    @static if VERSION >= v"1.3.0-alpha.0"
-        x.value
-    else
-        if !Base.Threads.in_threaded_loop[]
-            x.value
-        else
-            throw(InvalidStateException("Can not access thread local values across threads in multi-threaded code sections"))
-        end
-    end
+    x.value
 end

src/threadsafe.jl

@@ -6,39 +6,7 @@ abstract type ThreadSafe{T} end
 
 
 export ThreadSafeReentrantLock
-
-@static if VERSION >= v"1.2-DEV.28"
-    const ThreadSafeReentrantLock = ReentrantLock
-else
-    struct ThreadSafeReentrantLock
-        thread_lock::RecursiveSpinLock
-        task_lock::ReentrantLock
-
-        ThreadSafeReentrantLock() = new(RecursiveSpinLock(), ReentrantLock())
-    end
-
-    function Base.lock(l::ThreadSafeReentrantLock)
-        # @debug "LOCKING $l"
-        lock(l.thread_lock)
-        try
-            lock(l.task_lock)
-        catch err
-            unlock(l.thread_lock)
-            rethrow()
-        end
-    end
-
-
-    function Base.unlock(l::ThreadSafeReentrantLock)
-        # @debug "UNLOCKING $l"
-        try
-            unlock(l.task_lock)
-        finally
-            unlock(l.thread_lock)
-        end
-    end
-end
-
+const ThreadSafeReentrantLock = ReentrantLock
 
 
 export LockableValue

test/test_threadsafe.jl

@@ -9,14 +9,6 @@ using Base.Threads
 
     @testset "ThreadSafeReentrantLock" begin
         tsReLock = @inferred ThreadSafeReentrantLock()
-        @static if VERSION < v"1.2-DEV.28"
-            lock(tsReLock)
-            @test islocked(tsReLock.thread_lock)
-            @test islocked(tsReLock.task_lock)
-            unlock(tsReLock)
-            @test !islocked(tsReLock.thread_lock)
-            @test !islocked(tsReLock.task_lock)
-        end
     end
 
     @testset "LockableValue" begin