在 Julia 的函数中本地化记忆

Question

有没有一种方法可以在函数中本地化记忆（通过 Memoize.jl）？或者至少删除记忆创建的字典？

澄清：假设我定义了一个函数 f(x, y)。我想为每个新的 y 值创建一个新表。也就是说，给定 y = y0，f( . , y0) 对 x、x-1 等进行自我迭代，但给定一个新的 y = y1，我不需要为 y0 存储旧表，这样内存就可以被释放。我该怎么做？

解决方案：

cachedfib() = begin
    global dict = Dict()
    global dict2 = Dict()
    function _fib(n::Int, a::Int)
        if !haskey(dict2, a)
            dict2[a] = true
            dict = Dict()
        end
        if haskey(dict, (n, a))
            return dict[(n, a)]
        elseif n < 2
            dict[(0, a)] = 0
            dict[(1, a)] = 1
            return dict[(n, a)]
        else
            dict[(n, a)] = a*(_fib(n - 1, a) + _fib(n - 2, a))
            return dict[(n, a)]
        end
    end
end
fib = cachedfib()

fib(10, 1)
fib(10, 2)

现在调用dict 和dict2 并检查字典是否在每次第二个参数更改时刷新。当要存储的参数是整数并且使用Array 而不是Dict 时，您可以获得更好的性能

Answer 1

要使用记忆技术，您可以使用 let 或闭包。看看我对factorial 的快速实现（带闭包）。

with_cached_factorial() = begin
    local _cache = [1] #cache factorial(0)=1    
    function _factorial(n)          
        if n < length(_cache) 
            println("pull out from the cache factorial($n)=$(_cache[n+1])")
            _cache[n+1]
        else
            fres =  n * _factorial(n-1)
            push!(_cache, fres)
            println("put factorial($n)=$fres into the cache of the size=$(sizeof(_cache))") #a
            fres            
        end
    end 
end

现在，只需使用它：

julia> myf = with_cached_factorial()
_factorial (generic function with 1 method)

julia> myf(3)
pull out from the cache factorial(0)=1
put factorial(1)=1 into the cache of the size=16
put factorial(2)=2 into the cache of the size=24
put factorial(3)=6 into the cache of the size=32
6

julia> myf(5)
pull out from the cache factorial(3)=6
put factorial(4)=24 into the cache of the size=40
put factorial(5)=120 into the cache of the size=48
120

julia> myf(10)
pull out from the cache factorial(5)=120
put factorial(6)=720 into the cache of the size=56
put factorial(7)=5040 into the cache of the size=64
put factorial(8)=40320 into the cache of the size=72
put factorial(9)=362880 into the cache of the size=80
put factorial(10)=3628800 into the cache of the size=88
3628800

Answer 2

let Aold = nothing
global foo
function foo(A::AbstractArray)
    if A == Aold
        println("Same as last array")
    else
        Aold = A
    end
    nothing
end
end

结果：

julia> A = rand(2,2)
2x2 Array{Float64,2}:
 0.272936  0.153311
 0.299549  0.703668

julia> B = rand(2,2)
2x2 Array{Float64,2}:
 0.6762    0.377428
 0.493344  0.240194

julia> foo(A)

julia> foo(A)
Same as last array

julia> foo(B)

julia> foo(A)

julia> foo(A)
Same as last array

julia> Aold
ERROR: UndefVarError: Aold not defined