Merge pull request #727 from AayushSabharwal/as/fix-cache

fix: fix keyword syntax for `@cache` options

Author: AayushSabharwal

.github/workflows/Downstream.yml

@@ -18,7 +18,11 @@ jobs:
         julia-version: [1]
         os: [ubuntu-latest]
         package:
-          - {user: SciML, repo: ModelingToolkit.jl, group: All}
+          - {user: SciML, repo: ModelingToolkit.jl, group: InterfaceI}
+          - {user: SciML, repo: ModelingToolkit.jl, group: InterfaceII}
+          - {user: SciML, repo: ModelingToolkit.jl, group: Initialization}
+          - {user: SciML, repo: ModelingToolkit.jl, group: SymbolicIndexingInterface}
+          - {user: SciML, repo: ModelingToolkit.jl, group: FMI}
           - {user: SciML, repo: Catalyst.jl, group: All}
           - {user: SciML, repo: NeuralPDE.jl, group: NNPDE}
           - {user: SciML, repo: DataDrivenDiffEq.jl, group: Core}

src/cache.jl

@@ -102,6 +102,7 @@ resets the stats.
 function clear_cache!(fn)
     dict, stats = associated_cache(fn).tlv[]
     empty!(dict)
+    sizehint!(dict, get_limit(fn))
     reset_stats!(stats)
 end
 
@@ -193,7 +194,7 @@ macro cache(args...)
     # parse configuration options
     config = Dict(:limit => 100_000, :retain_fraction => 0.5, :allow_any_return => false, :enabled => true)
     for carg in configargs
-        if !Meta.isexpr(carg, :())
+        if !Meta.isexpr(carg, :(=))
             throw(ArgumentError("Expected `key = value` syntax, got $carg"))
         end
         k, v = carg.args
@@ -339,7 +340,7 @@ macro cache(args...)
     end)
 
     # instantiation of the TaskLocalValue
-    tlvctor = :($tlvT(() -> ($cacheT(), $CacheStats())))
+    tlvctor = :($tlvT(() -> ((dict = $cacheT(); sizehint!(dict, $get_limit($name)); dict), $CacheStats())))
     # instantiation expression for the constant value
     cachector = Expr(:call, structT, tlvctor, config[:limit], config[:retain_fraction], config[:enabled])
 

src/small_array.jl

@@ -32,7 +32,7 @@ GC'ed when removed.
 defaultval(::Type{T}) where {T <: Number} = zero(T)
 defaultval(::Type{Any}) = nothing
 
-function Base.getindex(x::Backing, i::Int)
+Base.@propagate_inbounds function Base.getindex(x::Backing, i::Int)
     @boundscheck 1 <= i <= x.len
     if i == 1
         x.x1
@@ -43,7 +43,7 @@ function Base.getindex(x::Backing, i::Int)
     end
 end
 
-function Base.setindex!(x::Backing, v, i::Int)
+Base.@propagate_inbounds function Base.setindex!(x::Backing, v, i::Int)
     @boundscheck 1 <= i <= x.len
     if i == 1
         setfield!(x, :x1, v)
@@ -54,20 +54,65 @@ function Base.setindex!(x::Backing, v, i::Int)
     end
 end
 
-function Base.push!(x::Backing, v)
-    x.len < 3 || throw(ArgumentError("`Backing` is full"))
+Base.@propagate_inbounds function Base.push!(x::Backing, v)
+    @boundscheck x.len < 3
     x.len += 1
     x[x.len] = v
 end
 
-function Base.pop!(x::Backing{T}) where {T}
-    x.len > 0 || throw(ArgumentError("Array is empty"))
+Base.@propagate_inbounds function Base.pop!(x::Backing{T}) where {T}
+    @boundscheck x.len > 0
     v = x[x.len]
     x[x.len] = defaultval(T)
     x.len -= 1
     v
 end
 
+function Base.any(f::Function, x::Backing)
+    if x.len == 0
+        false
+    elseif x.len == 1
+        f(x.x1)
+    elseif x.len == 2
+        f(x.x1) || f(x.x2)
+    elseif x.len == 3
+        f(x.x1) || f(x.x2) || f(x.x3)
+    end
+end
+
+function Base.all(f::Function, x::Backing)
+    if x.len == 0
+        true
+    elseif x.len == 1
+        f(x.x1)
+    elseif x.len == 2
+        f(x.x1) && f(x.x2)
+    elseif x.len == 3
+        f(x.x1) && f(x.x2) && f(x.x3)
+    end
+end
+
+function Base.map(f, x::Backing{T}) where {T}
+    if x.len == 0
+        # StaticArrays does this, so we are only as bad as they are
+        Backing{Core.Compiler.return_type(f, Tuple{T})}()
+    elseif x.len == 1
+        x1 = f(x.x1)
+        Backing{typeof(x1)}(x1)
+    elseif x.len == 2
+        x1 = f(x.x1)
+        x2 = f(x.x2)
+        Backing{Base.promote_typejoin(typeof(x1), typeof(x2))}(x1, x2)
+    elseif x.len == 3
+        x1 = f(x.x1)
+        x2 = f(x.x2)
+        x3 = f(x.x3)
+        _T = Base.promote_typejoin(typeof(x1), typeof(x2))
+        _T = Base.promote_typejoin(_T, typeof(x3))
+        Backing{_T}(x1, x2, x3)
+    end
+end
+
 """
     $(TYPEDSIGNATURES)
 
@@ -94,6 +139,10 @@ mutable struct SmallVec{T, V <: AbstractVector{T}} <: AbstractVector{T}
         end
     end
 
+    function SmallVec{T, V}(x::Backing{T}) where {T, V}
+        new{T, V}(x)
+    end
+
     function SmallVec{T, V}() where {T, V}
         new{T, V}(Backing{T}())
     end
@@ -113,21 +162,24 @@ Base.convert(::Type{SmallVec{T, V}}, x::SmallVec{T, V}) where {T, V} = x
 
 Base.size(x::SmallVec) = size(x.data)
 Base.isempty(x::SmallVec) = isempty(x.data)
-Base.getindex(x::SmallVec, i::Int) = x.data[i]
-Base.setindex!(x::SmallVec, v, i::Int) = setindex!(x.data, v, i)
+Base.@propagate_inbounds Base.getindex(x::SmallVec, i::Int) = x.data[i]
+Base.@propagate_inbounds Base.setindex!(x::SmallVec, v, i::Int) = setindex!(x.data, v, i)
 
-function Base.push!(x::SmallVec{T, V}, v) where {T, V}
+Base.@propagate_inbounds function Base.push!(x::SmallVec{T, V}, v) where {T, V}
     buf = x.data
     buf isa Backing{T} || return push!(buf::V, v)
     isfull(buf) || return push!(buf::Backing{T}, v)
     x.data = V(buf)
     return push!(x.data::V, v)
 end
 
-Base.pop!(x::SmallVec) = pop!(x.data)
+Base.@propagate_inbounds Base.pop!(x::SmallVec) = pop!(x.data)
 
 function Base.sizehint!(x::SmallVec{T, V}, n; kwargs...) where {T, V}
     x.data isa Backing && return x
     sizehint!(x.data, n; kwargs...)
     x
 end
+
+Base.any(f::Function, x::SmallVec) = any(f, x.data)
+Base.all(f::Function, x::SmallVec) = all(f, x.data)

src/types.jl

@@ -332,14 +332,10 @@ function isequal_with_metadata(a::NamedTuple, b::NamedTuple)
     a === b && return true
     typeof(a) == typeof(b) || return false
 
-    for (k, v) in pairs(a)
-        haskey(b, k) || return false
-        isequal_with_metadata(v, b[k]) || return false
-    end
-
-    for (k, v) in pairs(b)
-        haskey(a, k) || return false
-        isequal_with_metadata(v, a[k]) || return false
+    # same type, so same keys and value types
+    # either everything works or it fails and early exits
+    for (av, bv) in zip(values(a), values(b))
+        isequal_with_metadata(av, bv) || return false
     end
 
     return true
@@ -350,27 +346,28 @@ function isequal_with_metadata(a::AbstractDict, b::AbstractDict)
     typeof(a) == typeof(b) || return false
     length(a) == length(b) || return false
 
-    akeys = collect(keys(a))
-    avisited = falses(length(akeys))
-    bkeys = collect(keys(b))
-    bvisited = falses(length(bkeys))
+    # they have same length, so either `b` has all the same keys
+    # or this will fail. Can't use `get(b, k, nothing)` because if
+    # `a[k] === nothing` it will result in a false positive.
+    for (k, v) in a
+        k2 = getkey(b, k, nothing)
+        isequal_with_metadata(k, k2) || return false
+        isequal_with_metadata(v, b[k2]) || return false
+    end
+    return true
+end
+
+function isequal_with_metadata(a::Base.ImmutableDict, b::Base.ImmutableDict)
+    a === b && return true
+    typeof(a) == typeof(b) || return false
+    length(a) == length(b) || return false
 
-    for k in akeys
-        idx = findfirst(eachindex(bkeys)) do i
-            !bvisited[i] && isequal_with_metadata(k, bkeys[i])
-        end
-        idx === nothing && return false
-        bvisited[idx] = true
-        isequal_with_metadata(a[k], b[bkeys[idx]]) || return false
-    end
-    for (j, k) in enumerate(bkeys)
-        bvisited[j] && continue
-        idx = findfirst(eachindex(akeys)) do i
-            !avisited[i] && isequal_with_metadata(k, akeys[i])
+    for (k, v) in a
+        match = false
+        for (k2, v2) in b
+            match |= isequal_with_metadata(k, k2) && isequal_with_metadata(v, v2) 
         end
-        idx === nothing && return false
-        avisited[idx] = true
-        isequal_with_metadata(b[k], a[akeys[idx]]) || return false
+        match || return false
     end
     return true
 end

test/cache_macro.jl

@@ -196,3 +196,12 @@ end
 Base.delete_method(only(methods(objectid, @__MODULE__)))
 @syms x
 @test objectid(x) != 0x42
+
+@cache limit = 10 retain_fraction = 0.1 function f6(x::BasicSymbolic, y::Union{BasicSymbolic, Int}, z)::BasicSymbolic
+    return x + y + z
+end
+
+@testset "Keyword argument syntax works" begin
+    @test SymbolicUtils.get_limit(f6) == 10
+    @test SymbolicUtils.get_retain_fraction(f6) ≈ 0.1
+end