feat: create ErrorLockable for erroring upon multithreaded access

Author: MilesCranmer

src/Convert/Convert.jl

@@ -9,7 +9,7 @@ using ..Core
 using ..Core:
     C,
     Utils,
-    Lockable,
+    ErrorLockable,
     @autopy,
     getptr,
     incref,

src/Convert/pyconvert.jl

@@ -12,8 +12,8 @@ struct PyConvertRule
     priority::PyConvertPriority
 end
 
-const PYCONVERT_RULES = Lockable(Dict{String,Vector{PyConvertRule}}())
-const PYCONVERT_EXTRATYPES = Lockable(Py[])
+const PYCONVERT_RULES = ErrorLockable(Dict{String,Vector{PyConvertRule}}())
+const PYCONVERT_EXTRATYPES = ErrorLockable(Py[])
 
 """
     pyconvert_add_rule(tname::String, T::Type, func::Function, priority::PyConvertPriority=PYCONVERT_PRIORITY_NORMAL)
@@ -261,7 +261,7 @@ function _pyconvert_get_rules(pytype::Py)
     return rules
 end
 
-const PYCONVERT_PREFERRED_TYPE = Lockable(Dict{Py,Type}())
+const PYCONVERT_PREFERRED_TYPE = ErrorLockable(Dict{Py,Type}())
 
 pyconvert_preferred_type(pytype::Py) =
     Base.@lock PYCONVERT_PREFERRED_TYPE get!(PYCONVERT_PREFERRED_TYPE[], pytype) do
@@ -307,7 +307,7 @@ end
 
 pyconvert_fix(::Type{T}, func) where {T} = x -> func(T, x)
 
-const PYCONVERT_RULES_CACHE = Lockable(IdDict{Any,Dict{C.PyPtr,Vector{Function}}}())
+const PYCONVERT_RULES_CACHE = ErrorLockable(IdDict{Any,Dict{C.PyPtr,Vector{Function}}}())
 
 function pyconvert_rules_cache(::Type{T}) where {T}
     Base.@lock PYCONVERT_RULES_CACHE get!(

src/Core/Core.jl

@@ -11,7 +11,7 @@ const ROOT_DIR = dirname(dirname(@__DIR__))
 using ..PythonCall: PythonCall  # needed for docstring cross-refs
 using ..C: C
 using ..GC: GC
-using ..Utils: Utils, Lockable
+using ..Utils: Utils, ErrorLockable
 using Base: @propagate_inbounds, @kwdef
 using Dates:
     Date,

src/Core/Py.jl

@@ -56,7 +56,7 @@ decref(x::Py) = Base.GC.@preserve x (decref(getptr(x)); x)
 
 Base.unsafe_convert(::Type{C.PyPtr}, x::Py) = getptr(x)
 
-const PYNULL_CACHE = Lockable(Py[])
+const PYNULL_CACHE = ErrorLockable(Py[])
 
 """
     pynew([ptr])

src/Core/builtins.jl

@@ -1206,7 +1206,7 @@ export pyfraction
 
 ### eval/exec
 
-const MODULE_GLOBALS = Lockable(Dict{Module,Py}())
+const MODULE_GLOBALS = ErrorLockable(Dict{Module,Py}())
 
 function _pyeval_args(code, globals, locals)
     if code isa AbstractString

src/JlWrap/C.jl

@@ -1,7 +1,7 @@
 module Cjl
 
 using ...C: C
-using ...Utils: Utils, Lockable
+using ...Utils: Utils, ErrorLockable
 using Base: @kwdef
 using UnsafePointers: UnsafePtr
 using Serialization: serialize, deserialize
@@ -16,7 +16,7 @@ const PyJuliaBase_Type = Ref(C.PyNULL)
 
 # we store the actual julia values here
 # the `value` field of `PyJuliaValueObject` indexes into here
-const PYJLVALUES = Lockable((; values=IdDict{Int,Any}(), free_slots=Int[], next_slot=Ref(1)))
+const PYJLVALUES = ErrorLockable((; values=IdDict{Int,Any}(), free_slots=Int[], next_slot=Ref(1)))
 
 function _pyjl_new(t::C.PyPtr, ::C.PyPtr, ::C.PyPtr)
     o = ccall(UnsafePtr{C.PyTypeObject}(t).alloc[!], C.PyPtr, (C.PyPtr, C.Py_ssize_t), t, 0)
@@ -39,7 +39,7 @@ function _pyjl_dealloc(o::C.PyPtr)
     nothing
 end
 
-const PYJLMETHODS = Lockable([])
+const PYJLMETHODS = ErrorLockable([])
 
 function PyJulia_MethodNum(f)
     @nospecialize f
@@ -65,7 +65,7 @@ function _pyjl_callmethod(o::C.PyPtr, args::C.PyPtr)
     return _pyjl_callmethod(f, o, args, nargs)::C.PyPtr
 end
 
-const PYJLBUFCACHE = Lockable(Dict{Ptr{Cvoid},Any}())
+const PYJLBUFCACHE = ErrorLockable(Dict{Ptr{Cvoid},Any}())
 
 @kwdef struct PyBufferInfo{N}
     # data

src/Utils/Utils.jl

@@ -308,30 +308,38 @@ function Base.iterate(x::StaticString{UInt32,N}, i::Int = 1) where {N}
     end
 end
 
-@static if !isdefined(Base, :Lockable)
-    """
-    Compat for `Base.Lockable` (introduced in Julia 1.11)
-    """
-    struct Lockable{T,L}
-        value::T
-        lock::L
+struct RaceConditionError <: Exception
+    msg::String
+end
+Base.showerror(io::IO, e::RaceConditionError) = print(io, e.msg)
+
+
+struct ErrorLock
+    x::ReentrantLock
+    ErrorLock() = new(ReentrantLock())
+end
+Base.trylock(l::ErrorLock) = trylock(l.x)
+Base.unlock(l::ErrorLock) = unlock(l.x)
+Base.islocked(l::ErrorLock) = islocked(l.x)
+
+function Base.lock(l::ErrorLock)
+    did_lock = trylock(l.x)
+    if !did_lock
+        throw(RaceConditionError("unsafe concurrent access to global mutable"))
     end
+    return l
+end
 
-    Lockable(value) = Lockable(value, ReentrantLock())
-
-    # function Base.lock(f, l::Lockable)
-    #     lock(l.lock) do
-    #         f(l.value)
-    #     end
-    # end
-
-    Base.lock(l::Lockable) = lock(l.lock)
-    # Base.trylock(l::Lockable) = trylock(l.lock)
-    Base.unlock(l::Lockable) = unlock(l.lock)
-    Base.islocked(l::Lockable) = islocked(l.lock)
-    Base.getindex(l::Lockable) = (@assert islocked(l); l.value)
-else
-    const Lockable = Base.Lockable
+struct ErrorLockable{T,L}
+    value::T
+    lock::L
 end
 
+ErrorLockable(value) = ErrorLockable(value, ErrorLock())
+
+Base.lock(l::ErrorLockable) = lock(l.lock)
+Base.unlock(l::ErrorLockable) = unlock(l.lock)
+Base.islocked(l::ErrorLockable) = islocked(l.lock)
+Base.getindex(l::ErrorLockable) = (@assert islocked(l); l.value)
+
 end