Merge pull request #3 from longemen3000/dev

reimplementation of the internals

Author: longemen3000

README.md

@@ -14,7 +14,7 @@ This package maybe can help you!
 
 This package works with implace functions of the form: `f(out,x)`, where:
 1. `eltype(x) == eltype(out)`
-2. `x` is of type Array.
+2. `x` is of type Array,Dict,SparseVector,or SparseArray
 3. by default, the caches are not thread-safe or async safe. future releases will add special cached types to deal with this. as a workaround, you can try creating new cached functions instances using `deepcopy(f)`
 
 help on easing those limits is appreciated.
@@ -50,13 +50,12 @@ julia> f
 cached version of f! (function with 2 cached methods)
 julia> calls(f)
 5
-julia> methods(f)
+julia> cached_methods(f)
 IdDict{DataType,Function} with 2 entries:
   Float64 => #198
   Float32 => #198
 ```
-All the cached methods are stored in `methods(f)`. you can take one and use it if you want. each method is a closure
-with the specific cache created. and if the cache doesn't exists, it's created on the fly during runtime.
+A dict with all cached closures for each type is stored in `cached_methods(f)`. you can take one and use it if you want. If the cache doesn't exists, it's created on the fly during runtime.
 
 What happens if i don't want to allocate during runtime?, The solution: use `allocate!(f,Type)`
 

src/CachedFunctions.jl

@@ -1,6 +1,6 @@
 module CachedFunctions
 using SparseArrays
-export CachedFunction, input, output, evaluate, evaluate!, calls, allocate!
+export CachedFunction, input, output, evaluate, evaluate!, calls, allocate!, cached_methods
 
 include("storage_constructors.jl")
 include("cached_function.jl")

src/cached_function.jl

@@ -4,66 +4,72 @@
 
 
 
-struct CachedFunction{F,S,I,O,L}
+struct CachedFunction{F,I,O,S}
     f!::F
-    storage_type::S ##by default, a plain array
-    in_size::SIZE{I} #a ntuple of ints
-    out_size::SIZE{O} #a ntuple of ints
+    input::I #prototype info for input
+    output::O #prototype info for input
     x_cache::IdDict{DataType, S}
     closures::IdDict{DataType, Function}
     f_calls::Vector{Int64}
-    lock::L
+    lock::ReentrantLock
 end
 
 
 
 
 
-function CachedFunction(f!,_in::SIZE,out::SIZE,stype=Array) 
-    storage_type = type_constructor(stype,out)
-    in_size = _in
-    out_size = out
-    x_cache =  IdDict{DataType,type_constructor(stype,in)}()
+
+function CachedFunction(f!,_in::SIZE{N1},_out::SIZE{N2}) where {N1,N2}
+    input = Prototype(Array{Float64,N1},_in)
+    output = Prototype(Array{Float64,N2},out)
+    x_cache =  IdDict{DataType,Array{Any,N1}}()
+    closures = IdDict{DataType, Function}()
+    f_calls = [0]
+    lock = ReentrantLock()
+    return CachedFunction(f!,input,output,x_cache,closures,f_calls,lock)
+end
+
+
+function CachedFunction(f!,_in::T1,out::T2) where {T1,T2}
+    input = prototype(_in)
+    output = prototype(out)
+    x_cache =  IdDict{DataType,T1.name.wrapper}()
     closures = IdDict{DataType, Function}()
     f_calls = [0]
     lock = ReentrantLock()
-    return CachedFunction(f!,storage_type,in_size,out_size,x_cache,closures,f_calls,lock)
+    return CachedFunction(f!,input,output,x_cache,closures,f_calls,lock)
 end
 
+
 #creates an instance of the cache, using the storage_type and the size. uses type constructor
 
 #generates an array of _eltype in
 
 
-function make_closure!(f!,stype,_eltype,_size)
-    out_cache = make_cache!(f!,stype,_eltype,_size)
+function make_closure!(f!,prototype,elem_type)
+    out_cache = make_cache!(f!,prototype,elem_type)
     return x -> f!(out_cache, x)
 end
 
 eval_f(f::F, x) where {F} = f(x) 
 
-function (cfn::CachedFunction{F,O})(x) where {F,O}
-    X = _eltype(x)
-    out = cfn.out_size
-    f = get!(() -> make_closure!(cfn.f!,O,X,out), cfn.closures, X)
+function (cfn::CachedFunction{F})(x) where {F}
+    X = valtype(x)
+    f = get!(() -> make_closure!(cfn.f!, cfn.output, X),cfn.closures,X)
     cfn.f_calls[1] +=1
     return eval_f(f, x)
 end
 
-function allocate!(cfn::CachedFunction{F,O},x)  where {F,O}
-    X = _eltype(x)
-    out = cfn.out_size
-    _in = cfn.in_size
-    get!(cfn.x_cache,X, x) #if x is not of the correct type, then it will throw an error.
-    get!(() ->  make_closure!(cfn.f!,O,X,out), cfn.closures, X)
+function allocate!(cfn::CachedFunction{F},x)  where {F}
+    X = valtype(x)
+    get!(() -> x,cfn.x_cache,X)
+    get!(() -> make_closure!(cfn.f!, cfn.output, X),cfn.closures,X)
     return nothing
 end
 
-function allocate!(cfn::CachedFunction{F,O},x::Type{X})  where {F,O,X}
-    out = cfn.out_size
-    _in = _size(cfn.in_size)
-    get!(cfn.x_cache,X, make_cache!(cfn.f!,O,X,_in))
-    get!(() -> make_closure!(cfn.f!,O,X,out), cfn.closures, X)
+function allocate!(cfn::CachedFunction{F},x::Type{X})  where {F,X}
+    get!(() -> make_cache!(cfn.f!, cfn.input, X),cfn.x_cache,X)
+    get!(() -> make_closure!(cfn.f!, cfn.output, X),cfn.closures,X)
     return nothing
 end
 #@btime c($[1.0,2.0])
@@ -85,21 +91,21 @@ returns the output cache stored in ´f´
 Returns `f(x)`, it doesn' t store the input.
 if your function has only one type cached, you can get the output cache without adding the type.
 """
-function output(f::CachedFunction)
-    if length(c.closures) == 1
-        return last(first(c.closures)).out_cache
-    elseif length(c.closures) == 0
+function output(cfn::CachedFunction)
+    if length(cfn.closures) == 1
+        return last(first(cfn.closures)).out_cache
+    elseif length(cfn.closures) == 0
         error("there aren't any output caches allocated in cached function")
     else
         error("there are more than one type of output cache stored in cached function.")
     end
 end
 
-function output(f::CachedFunction,x::Type{T}) where T
-    if length(c.closures) == 0
+function output(cfn::CachedFunction,x::Type{T}) where T
+    if length(cfn.closures) == 0
         error("there aren't any output caches allocated in cached function.")
     else
-        res = get(c.closures,T,nothing)
+        res = get(cfn.closures,T,nothing)
         if isnothing(res)
             TT = T.name.wrapper
         error("there aren't any output caches of type $TT in cached function.")
@@ -109,17 +115,17 @@ function output(f::CachedFunction,x::Type{T}) where T
     end
 end
 
-output(f::CachedFunction,x) = output(f,_eltype(x))
+output(f::CachedFunction,x) = output(f,valtype(x))
 
 
 
 ###input####
 
-function input(f::CachedFunction,x::Type{T}) where T
-    if length(c.x_cache) == 0
+function input(cfn::CachedFunction,x::Type{T}) where T
+    if length(cfn.x_cache) == 0
         error("there aren't any input caches allocated in cached function")
     else
-        res = get(c.x_cache,T,nothing)
+        res = get(cfn.x_cache,T,nothing)
         if isnothing(res)
         TT = T.name.wrapper
         error("there aren't any input caches of type $TT in cached function.")
@@ -129,7 +135,7 @@ function input(f::CachedFunction,x::Type{T}) where T
     end
 end
 
-input(f::CachedFunction,x) = input(f,_eltype(x))
+input(f::CachedFunction,x) = input(f,valtype(x))
 
 
 ####evaluate#####
@@ -152,20 +158,19 @@ Returns `f(x)` and stores the input value.
 
 """
 function evaluate!(cfn::CachedFunction,x)
-    X = _eltype(x)
+    X = valtype(x)
     out = cfn.out_size
     if haskey(cfn.x_cache,X)
         xx = get(cfn.x_cache,X,nothing)
         copyto!(xx,x)
     else
         xx = get!(cfn.x_cache,X,x)
     end
-    f = get!(() -> make_closure!(cfn.f!, x,out), cfn.closures, X)
+    f = get!(() -> make_closure!(cfn.f!, cfn.output, X),cfn.closures,X)
     cfn.f_calls[1] +=1
-    return eval_f(f, xx)
+    return eval_f(f, x)
 end
 
-
 function Base.show(io::IO, fn::CachedFunction)
     n_methods = length(fn.closures)
     _methods = n_methods == 1 ? "method" : "methods"
@@ -174,7 +179,7 @@ function Base.show(io::IO, fn::CachedFunction)
 end
 
 
-methods(f::CachedFunction) = f.closures
+cached_methods(f::CachedFunction) = f.closures
 
 
 #lock methods

src/storage_constructors.jl

@@ -2,115 +2,56 @@
 const SIZE = NTuple{N,Int} where N 
 const LENGTH = SIZE{1}
 
-#overload of size to always use tuples
-function _size(out::OUT) where OUT
-    if Base.IteratorSize(OUT) == Base.HasLength() #linear struct
-        return length(out)
-    elseif typeof(Base.IteratorSize(OUT)) <: Base.HasShape #sized struct
-        return size(out)
-    else
-        error("the size of the output is not known")
-    end
-end
-
-function _size(out::SIZE)
-    return out
-end
-
-function _size(out::Int)
-    return (out,)
-end
-
-
-
-#like eltype, but gives the value type with dicts
-_eltype(x) = eltype(x)
-function _eltype(x::T) where T<:AbstractDict{K,V} where {K,V}
-    return V 
-end
-
-#provide errors when the type cannot conform to the size
-function _only1d_error(type)
-    _type = type.name.wrapper
-    return error("incorrect size provided. The $_type type can only have length.")
-end
-
-#provide errors when the type cannot conform to the size
-function _only2d_error(type)
-    _type = type.name.wrapper
-    return error("incorrect size provided. The $_type type can only two dimensions.")
-end
 
+#prototype abstract, stores the storage type in S
+abstract type AbstractPrototype{S} end
 
 
-#used to generate an appropiate type constructor for storage
-#the storage should only depend on the element type and the size, nothing more, nothing less.
-
-
-
-#instance of type instead of type
-type_constructor(storage_type,size::SIZE) = type_constructor(typeof(storage_type),size)
-    
-#array
-function type_constructor(storage_type::Type{T1},size::SIZE) where T1 <: AbstractArray{T2,T3} where {T2,T3}
-    return storage_type.name.wrapper{T,prod(size)} where T
+#prototype stores the type to dispatch and the data necesary to create a new instance of other element types.
+struct Prototype{S,T}
+    type::S
+    data::T #a tuple to store associated data
 end
 
-#sparse vector
-function type_constructor(storage_type::Type{T1},size::LENGTH) where T1 <: SparseVector
-    return SparseVector{T,Int64} where T
-end
 
-#sparse vector error with different sizes
-function type_constructor(storage_type::Type{T1},size::SIZE) where T1 <: SparseVector
-    return _only1d_error(T1)
-end
+prototype(x::T) where T<:Array = Prototype(typeof(x),(eltype(x),size(x)))
+prototype(d::T) where T<:Dict = Prototype(typeof(d),(valtype(d),d.slots, d.keys, d.ndel, d.count, d.age, d.idxfloor, d.maxprobe))
+prototype(sv::T) where T<:SparseArrays.SparseVector = Prototype(typeof(sv),(eltype(sv),sv.n,sv.nzind))                            
+prototype(sm::T) where T<:SparseArrays.SparseMatrixCSC = Prototype(typeof(sm),(eltype(sm),size(sm),sm.rowval,sm.colptr))                            
 
-#sparse matrix
-function type_constructor(storage_type::Type{T1},size::SIZE{2}) where T1 <: SparseMatrixCSC
-    return SparseMatrixCSC{T,Int64} where T
+function make_cache!(f!,p::P,elem_type) where {P <: Prototype}
+    return make_cache!(p.type,f!,p,elem_type)
 end
 
-#sparse matrix  error with different sizes
-function type_constructor(storage_type::Type{T1},size::SIZE) where T1 <: SparseMatrixCSC
-    return _only2d_error(T1)
+function make_cache!(::Type{T1},f!,p::P,elem_type::Type{T2}) where {T1 <: Array, P <: Prototype, T2}
+    s = p.data[2]
+    n = length(s)
+    return Array{T2,n}(undef,s)
 end
 
-
-#abstract dict
-function type_constructor(storage_type::Type{T1},size::LENGTH) where T1 <: AbstractDict{K,V} where {K,V}
-    return storage_type.name.wrapper{K,T} where T
+#the approach here is more like Dictionaries.jl
+function make_cache!(::Type{T1},f!,p::P,elem_type::Type{T2}) where {T1 <: Dict, P <: Prototype, T2}
+    t, slots, keys, ndel, count, age, idxfloor, maxprobe = p.data
+    n = length(slots)
+    K = eltype(keys)
+    vals = Vector{T2}(undef,n)
+    return Dict{K,T2}(slots,keys,vals,ndel,count,age,idxfloor,maxprobe) 
 end
 
-#abstract dict error
-function type_constructor(storage_type::Type{T1},size::SIZE) where T1 <: AbstractDict{K,V} where {K,V}
-    return _only1d_error(T1)
+function make_cache!(::Type{T1},f!,p::P,elem_type::Type{T2}) where {T1 <: SparseArrays.SparseVector, P <: Prototype, T2,K,V}
+    t,n,nzind = p.data
+    nzval = Vector{T2}(undef,n)
+    return SparseArrays.SparseVector{T2,eltype(nzind)}(n,nzind,nzval)
 end
 
-
-
-
-#make_cache! generates an instance of the object, given its storage type and size
-
-#general constructor for arrays
-function make_cache!(f!,storage_type::T1,element_type,_size::SIZE) where T1 <: AbstractArray
-    t = type_constructor(storage_type,_size){element_type}
-    return t(undef,_size)
-end
-
-#sparse matrix
-function make_cache!(f!,storage_type::T1,element_type,_size::SIZE{2}) where T1 <: SparseMatrixCSC
-    return spzeros(storage_type,_size...)
+function make_cache!(::Type{T1},f!,p::P,elem_type::Type{T2}) where {T1 <: SparseArrays.SparseMatrixCSC, P <: Prototype, T2,K,V}
+    t,s,rowval,colptr = p.data
+    m,n = s
+    l = length(rowval)
+    t,n,nzind = p.data
+    nzval = Vector{T2}(undef,l)
+    return SparseArrays.SparseVector{T2,eltype(nzind)}(m,n,colptr,nzind,nzval)
 end
 
 
-#sparse vector
-function make_cache!(f!,storage_type::T1,element_type,_size::LENGTH) where T1 <: SparseVector
-    return spzeros(storage_type,first(_size))
-end
 
-#abstract dict
-function make_cache!(f!,storage_type::T1,element_type,_size::LENGTH) where T1 <: AbstractDict{K,V} where {K,V}
-    dict = type_constructor(storage_type,_size){element_type}()
-    sizehint!(dict,prod(_size))
-end