Compare ⋅ JuliaCollections/LRUCache.jl

No flags found

Use flags to group coverage reports by test type, project and/or folders.
Then setup custom commit statuses and notifications for each flag.

e.g., #unittest #integration

#production #enterprise

#frontend #backend

Learn more about Codecov Flags here.

Showing 1 of 8 files from the diff.

96.60% 100.00% -0.05%

src/LRUCache.jl changed.

Other files ignored by Codecov

test/runtests.jl has changed.

.github/workflows/ci-julia-nightly.yml is new.

.github/workflows/ci.yml is new.

.travis.yml was deleted.

Project.toml has changed.

README.md has changed.

.appveyor.yml was deleted.

@@ -7,7 +7,6 @@

Loading

using Base: Callable

_constone(x) = 1
function _no_callback end

# Default cache size
mutable struct LRU{K,V} <: AbstractDict{K,V}

@@ -16,20 +15,18 @@

Loading

    currentsize::Int
    maxsize::Int
    lock::SpinLock
    by::Callable
    eviction_callback::Callable
    by::Any
    finalizer::Any

    LRU{K, V}(; maxsize::Int, by::Callable = _constone,
              eviction_callback::Callable = _no_callback) where {K, V} =
        new{K, V}(Dict{K, V}(), CyclicOrderedSet{K}(), 0, maxsize, SpinLock(),
                  by, eviction_callback)
    function LRU{K, V}(; maxsize::Int, by = _constone, finalizer = nothing) where {K, V}
        dict = Dict{K, V}()
        keyset = CyclicOrderedSet{K}()
        new{K, V}(dict, keyset , 0, maxsize, SpinLock(), by, finalizer)
    end
end

function LRU(; maxsize::Int, by::Callable = _constone,
             eviction_callback::Callable = _no_callback)
    return LRU{Any,Any}(maxsize=maxsize, by=by,
                        eviction_callback=eviction_callback)
end
LRU(; maxsize::Int, by = _constone, finalizer = nothing) =
    LRU{Any,Any}(maxsize = maxsize, by = by, finalizer = finalizer)

Base.show(io::IO, lru::LRU{K, V}) where {K, V} =
    print(io, "LRU{$K, $V}(; maxsize = $(lru.maxsize))")

@@ -93,7 +90,7 @@

Loading

        _unsafe_resize!(lru, evictions)
        return v
    end
    _notify_evictions!(lru.eviction_callback, evictions)
    _finalize_evictions!(lru.finalizer, evictions)
    return v
end
function Base.get!(default::Callable, lru::LRU{K, V}, key) where {K, V}

@@ -116,7 +113,7 @@

Loading

        _unsafe_resize!(lru, evictions)
    end
    unlock(lru.lock)
    _notify_evictions!(lru.eviction_callback, evictions)
    _finalize_evictions!(lru.finalizer, evictions)
    return v
end


@@ -147,7 +144,7 @@

Loading

    lock(lru.lock) do
        if _unsafe_haskey(lru, key)
            old_v, n, s = lru.dict[key]
            if lru.eviction_callback !== _no_callback
            if lru.finalizer !== nothing
                push!(evictions, (key, old_v))
            end
            lru.currentsize -= s

@@ -160,7 +157,7 @@

Loading

        end
        _unsafe_resize!(lru, evictions)
    end
    _notify_evictions!(lru.eviction_callback, evictions)
    _finalize_evictions!(lru.finalizer, evictions)
    return lru
end


@@ -170,7 +167,7 @@

Loading

    while lru.currentsize > lru.maxsize
        key = pop!(lru.keyset)
        v, n, s = pop!(lru.dict, key)
        if lru.eviction_callback !== _no_callback
        if lru.finalizer !== nothing
            push!(evictions, (key, v))
        end
        lru.currentsize -= s

@@ -183,57 +180,54 @@

Loading

    lock(lru.lock) do
        _unsafe_resize!(lru, evictions, maxsize)
    end
    _notify_evictions!(lru.eviction_callback, evictions)
    _finalize_evictions!(lru.finalizer, evictions)
    return lru
end

function Base.delete!(lru::LRU{K, V}, key) where {K, V}
    evictions = Tuple{K, V}[]
    lock(lru.lock) do
    v = lock(lru.lock) do
        v, n, s = pop!(lru.dict, key)
        if lru.eviction_callback !== _no_callback
            push!(evictions, (key, v))
        end
        lru.currentsize -= s
        _delete!(lru.keyset, n)
        return v
    end
    if lru.finalizer !== nothing
        lru.finalizer(key, v)
    end
    _notify_evictions!(lru.eviction_callback, evictions)
    return lru
end
function Base.pop!(lru::LRU{K, V}, key) where {K, V}
    evictions = Tuple{K, V}[]
    v = lock(lru.lock) do
    (key, v) = lock(lru.lock) do
        v, n, s = pop!(lru.dict, key)
        if lru.eviction_callback !== _no_callback
            push!(evictions, (key, v))
        end
        lru.currentsize -= s
        _delete!(lru.keyset, n)
        return v
        return (key, v)
    end
    if lru.finalizer !== nothing
        lru.finalizer(key, v)
    end
    _notify_evictions!(lru.eviction_callback, evictions)
    return v
end

function Base.empty!(lru::LRU{K, V}) where {K, V}
    evictions = Tuple{K, V}[]
    lock(lru.lock) do
        if lru.eviction_callback === _no_callback
        if lru.finalizer === nothing
            lru.currentsize = 0
            empty!(lru.dict)
            empty!(lru.keyset)
        else
            sizehint!(evictions, length(lru))
            _unsafe_resize!(lru, evictions, 0)
        end
    end
    _notify_evictions!(lru.eviction_callback, evictions)
    _finalize_evictions!(lru.finalizer, evictions)
    return lru
end

function _notify_evictions!(callback, evictions)
    while !isempty(evictions)
        key, value = pop!(evictions)
        callback(key, value)
function _finalize_evictions!(finalizer, evictions)
    for (key, value) in evictions
        finalizer(key, value)
    end
    return
end

Learn more Showing 1 files with coverage changes found.

Changes in src/LRUCache.jl

-1

→

Loading file...

Hiding 2 contexual commits

76.42% ø ø

modify and rename part of the eviction / finalizer implementation (#25)

Jutho

0bc1a49

-2

76.61% 100.00% +3.80%

Implement eviction callback. (#23)

GunnarFarneback

9c806d4

CI Passed

Files		•	•	•	Coverage
src	-2	-2	ø	ø	^-0.19% 76.42%
Project Totals (2 files)	246	188	0	58	76.42%

116	113		_unsafe_resize!(lru, evictions)
117	114		end
118	115		unlock(lru.lock)
119		-	_notify_evictions!(lru.eviction_callback, evictions)
	116	+	_finalize_evictions!(lru.finalizer, evictions)
120	117		return v
121	118		end
122	119

160	157		end
161	158		_unsafe_resize!(lru, evictions)
162	159		end
163		-	_notify_evictions!(lru.eviction_callback, evictions)
	160	+	_finalize_evictions!(lru.finalizer, evictions)
164	161		return lru
165	162		end
166	163

183	180		lock(lru.lock) do
184	181		_unsafe_resize!(lru, evictions, maxsize)
185	182		end
186		-	_notify_evictions!(lru.eviction_callback, evictions)
	183	+	_finalize_evictions!(lru.finalizer, evictions)
187	184		return lru
188	185		end
189	186
190	187		function Base.delete!(lru::LRU{K, V}, key) where {K, V}
191		-	evictions = Tuple{K, V}[]
192		-	lock(lru.lock) do
	188	+	v = lock(lru.lock) do
193	189		v, n, s = pop!(lru.dict, key)
194		-	if lru.eviction_callback !== _no_callback
195		-	push!(evictions, (key, v))
196		-	end
197	190		lru.currentsize -= s
198	191		_delete!(lru.keyset, n)
	192	+	return v
	193	+	end
	194	+	if lru.finalizer !== nothing
	195	+	lru.finalizer(key, v)
199	196		end
200		-	_notify_evictions!(lru.eviction_callback, evictions)
201	197		return lru
202	198		end
203	199		function Base.pop!(lru::LRU{K, V}, key) where {K, V}
204		-	evictions = Tuple{K, V}[]
205		-	v = lock(lru.lock) do
	200	+	(key, v) = lock(lru.lock) do
206	201		v, n, s = pop!(lru.dict, key)
207		-	if lru.eviction_callback !== _no_callback
208		-	push!(evictions, (key, v))
209		-	end
210	202		lru.currentsize -= s
211	203		_delete!(lru.keyset, n)
212		-	return v
	204	+	return (key, v)
	205	+	end
	206	+	if lru.finalizer !== nothing
	207	+	lru.finalizer(key, v)
213	208		end
214		-	_notify_evictions!(lru.eviction_callback, evictions)
215	209		return v
216	210		end
217	211
218	212		function Base.empty!(lru::LRU{K, V}) where {K, V}
219	213		evictions = Tuple{K, V}[]
220	214		lock(lru.lock) do
221		-	if lru.eviction_callback === _no_callback
	215	+	if lru.finalizer === nothing
222	216		lru.currentsize = 0
223	217		empty!(lru.dict)
224	218		empty!(lru.keyset)
225	219		else
	220	+	sizehint!(evictions, length(lru))
226	221		_unsafe_resize!(lru, evictions, 0)
227	222		end
228	223		end
229		-	_notify_evictions!(lru.eviction_callback, evictions)
	224	+	_finalize_evictions!(lru.finalizer, evictions)
230	225		return lru
231	226		end
232	227
233		-	function _notify_evictions!(callback, evictions)
234		-	while !isempty(evictions)
235		-	key, value = pop!(evictions)
236		-	callback(key, value)
	228	+	function _finalize_evictions!(finalizer, evictions)
	229	+	for (key, value) in evictions
	230	+	finalizer(key, value)
237	231		end
238	232		return
239	233		end

Navigation	Overlay
`t` Navigate files	`h` Toggle hits
`y` Change url to tip of branch	`m` Toggle misses
`b / v` Jump to prev/next hit line	`p` Toggle partial
`z / x` Jump to prev/next missed or partial line	`1..9` Toggle flags
`shift + o` Open current page in GitHub	`a` Toggle all on
`/ or ?` Show keyboard shortcuts dialog	`c` Toggle context lines or commits

Compare `9c806d4 ... +2 ... c55095c`

No flags found

Show failed CI and contexual commits `c`

4 Commits

7	7		using Base: Callable
8	8
9	9		_constone(x) = 1
10		-	function _no_callback end
11	10
12	11		# Default cache size
13	12		mutable struct LRU{K,V} <: AbstractDict{K,V}

16	15		currentsize::Int
17	16		maxsize::Int
18	17		lock::SpinLock
19		-	by::Callable
20		-	eviction_callback::Callable
	18	+	by::Any
	19	+	finalizer::Any
21	20
22		-	LRU{K, V}(; maxsize::Int, by::Callable = _constone,
23		-	eviction_callback::Callable = _no_callback) where {K, V} =
24		-	new{K, V}(Dict{K, V}(), CyclicOrderedSet{K}(), 0, maxsize, SpinLock(),
25		-	by, eviction_callback)
	21	+	function LRU{K, V}(; maxsize::Int, by = _constone, finalizer = nothing) where {K, V}
	22	+	dict = Dict{K, V}()
	23	+	keyset = CyclicOrderedSet{K}()
	24	+	new{K, V}(dict, keyset , 0, maxsize, SpinLock(), by, finalizer)
	25	+	end
26	26		end
27	27
28		-	function LRU(; maxsize::Int, by::Callable = _constone,
29		-	eviction_callback::Callable = _no_callback)
30		-	return LRU{Any,Any}(maxsize=maxsize, by=by,
31		-	eviction_callback=eviction_callback)
32		-	end
	28	+	LRU(; maxsize::Int, by = _constone, finalizer = nothing) =
	29	+	LRU{Any,Any}(maxsize = maxsize, by = by, finalizer = finalizer)
33	30
34	31		Base.show(io::IO, lru::LRU{K, V}) where {K, V} =
35	32		print(io, "LRU{$K, $V}(; maxsize = $(lru.maxsize))")

147	144		lock(lru.lock) do
148	145		if _unsafe_haskey(lru, key)
149	146		old_v, n, s = lru.dict[key]
150		-	if lru.eviction_callback !== _no_callback
	147	+	if lru.finalizer !== nothing
151	148		push!(evictions, (key, old_v))
152	149		end
153	150		lru.currentsize -= s

170	167		while lru.currentsize > lru.maxsize
171	168		key = pop!(lru.keyset)
172	169		v, n, s = pop!(lru.dict, key)
173		-	if lru.eviction_callback !== _no_callback
	170	+	if lru.finalizer !== nothing
174	171		push!(evictions, (key, v))
175	172		end
176	173		lru.currentsize -= s

Compare 9c806d4 ... +2 ... c55095c

No flags found

Show failed CI and contexual commits c 4 Commits

Compare `9c806d4 ... +2 ... c55095c`

Show failed CI and contexual commits `c`

4 Commits