Skip to content

Commit 09b6eb5

Browse files
awolverpawolverp
committed
Change the behaviour of the iteratores
Previously, iterators used capacity and length of the cache to know "is cache have changes?" But now, each cache has a number called "state" that increments with each change; iterators now uses "state" number.
1 parent 193fd31 commit 09b6eb5

16 files changed

+207
-92
lines changed

Diff for: ‎cachebox/_cachebox.pyi

+1
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,7 @@ class BaseCacheImpl(typing.Generic[KT, VT]):
3232
def __class_getitem__(*args) -> None: ...
3333
@property
3434
def maxsize(self) -> int: ...
35+
def _state(self) -> int: ...
3536
def __len__(self) -> int: ...
3637
def __sizeof__(self) -> int: ...
3738
def __bool__(self) -> bool: ...

Diff for: ‎src/bridge/cache.rs

+15-9
Original file line numberDiff line numberDiff line change
@@ -54,6 +54,11 @@ impl Cache {
5454
lock.maxsize.get()
5555
}
5656

57+
pub fn _state(&self) -> usize {
58+
let lock = self.raw.lock();
59+
lock.state.get()
60+
}
61+
5762
/// Returns the number of elements in the table - len(self)
5863
pub fn __len__(&self) -> usize {
5964
let lock = self.raw.lock();
@@ -145,11 +150,11 @@ impl Cache {
145150
py: pyo3::Python<'_>,
146151
) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
147152
let lock = slf.raw.lock();
148-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
153+
let (len, state) = (lock.table.len(), lock.state.get());
149154
let iter = unsafe { lock.table.iter() };
150155

151156
let result = cache_iterator {
152-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
157+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
153158
iter: crate::mutex::Mutex::new(iter),
154159
typ: 0,
155160
};
@@ -338,7 +343,8 @@ impl Cache {
338343
/// Shrinks the cache to fit len(self) elements.
339344
pub fn shrink_to_fit(&self) {
340345
let mut lock = self.raw.lock();
341-
lock.table.shrink_to(0, |x| x.0.hash)
346+
lock.table.shrink_to(0, |x| x.0.hash);
347+
lock.state.change();
342348
}
343349

344350
/// Updates the cache with elements from a dictionary or an iterable object of key/value pairs.
@@ -367,11 +373,11 @@ impl Cache {
367373
py: pyo3::Python<'_>,
368374
) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
369375
let lock = slf.raw.lock();
370-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
376+
let (len, state) = (lock.table.len(), lock.state.get());
371377
let iter = unsafe { lock.table.iter() };
372378

373379
let result = cache_iterator {
374-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
380+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
375381
iter: crate::mutex::Mutex::new(iter),
376382
typ: 2,
377383
};
@@ -389,11 +395,11 @@ impl Cache {
389395
py: pyo3::Python<'_>,
390396
) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
391397
let lock = slf.raw.lock();
392-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
398+
let (len, state) = (lock.table.len(), lock.state.get());
393399
let iter = unsafe { lock.table.iter() };
394400

395401
let result = cache_iterator {
396-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
402+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
397403
iter: crate::mutex::Mutex::new(iter),
398404
typ: 0,
399405
};
@@ -411,11 +417,11 @@ impl Cache {
411417
py: pyo3::Python<'_>,
412418
) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
413419
let lock = slf.raw.lock();
414-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
420+
let (len, state) = (lock.table.len(), lock.state.get());
415421
let iter = unsafe { lock.table.iter() };
416422

417423
let result = cache_iterator {
418-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
424+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
419425
iter: crate::mutex::Mutex::new(iter),
420426
typ: 1,
421427
};

Diff for: ‎src/bridge/fifocache.rs

+17-8
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,11 @@ impl FIFOCache {
4848
lock.maxsize.get()
4949
}
5050

51+
pub fn _state(&self) -> usize {
52+
let lock = self.raw.lock();
53+
lock.state.get()
54+
}
55+
5156
/// Returns the number of elements in the table - len(self)
5257
pub fn __len__(&self) -> usize {
5358
let lock = self.raw.lock();
@@ -137,10 +142,11 @@ impl FIFOCache {
137142
py: pyo3::Python<'_>,
138143
) -> pyo3::PyResult<pyo3::Py<fifocache_iterator>> {
139144
let lock = slf.raw.lock();
140-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
145+
let state = lock.state.get();
146+
let len = lock.table.len();
141147

142148
let result = fifocache_iterator {
143-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
149+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
144150
iter: crate::mutex::Mutex::new(lock.iter()),
145151
typ: 0,
146152
};
@@ -365,10 +371,11 @@ impl FIFOCache {
365371
py: pyo3::Python<'_>,
366372
) -> pyo3::PyResult<pyo3::Py<fifocache_iterator>> {
367373
let lock = slf.raw.lock();
368-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
374+
let state = lock.state.get();
375+
let len = lock.table.len();
369376

370377
let result = fifocache_iterator {
371-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
378+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
372379
iter: crate::mutex::Mutex::new(lock.iter()),
373380
typ: 2,
374381
};
@@ -385,10 +392,11 @@ impl FIFOCache {
385392
py: pyo3::Python<'_>,
386393
) -> pyo3::PyResult<pyo3::Py<fifocache_iterator>> {
387394
let lock = slf.raw.lock();
388-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
395+
let state = lock.state.get();
396+
let len = lock.table.len();
389397

390398
let result = fifocache_iterator {
391-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
399+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
392400
iter: crate::mutex::Mutex::new(lock.iter()),
393401
typ: 0,
394402
};
@@ -405,10 +413,11 @@ impl FIFOCache {
405413
py: pyo3::Python<'_>,
406414
) -> pyo3::PyResult<pyo3::Py<fifocache_iterator>> {
407415
let lock = slf.raw.lock();
408-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
416+
let state = lock.state.get();
417+
let len = lock.table.len();
409418

410419
let result = fifocache_iterator {
411-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
420+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
412421
iter: crate::mutex::Mutex::new(lock.iter()),
413422
typ: 1,
414423
};

Diff for: ‎src/bridge/lfucache.rs

+13-8
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,11 @@ impl LFUCache {
4848
lock.maxsize.get()
4949
}
5050

51+
pub fn _state(&self) -> usize {
52+
let lock = self.raw.lock();
53+
lock.state.get()
54+
}
55+
5156
/// Returns the number of elements in the table - len(self)
5257
pub fn __len__(&self) -> usize {
5358
let lock = self.raw.lock();
@@ -144,10 +149,10 @@ impl LFUCache {
144149
py: pyo3::Python<'_>,
145150
) -> pyo3::PyResult<pyo3::Py<lfucache_iterator>> {
146151
let mut lock = slf.raw.lock();
147-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
152+
let (len, state) = (lock.table.len(), lock.state.get());
148153

149154
let result = lfucache_iterator {
150-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
155+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
151156
iter: crate::mutex::Mutex::new(lock.iter()),
152157
typ: 0,
153158
};
@@ -393,10 +398,10 @@ impl LFUCache {
393398
py: pyo3::Python<'_>,
394399
) -> pyo3::PyResult<pyo3::Py<lfucache_iterator>> {
395400
let mut lock = slf.raw.lock();
396-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
401+
let (len, state) = (lock.table.len(), lock.state.get());
397402

398403
let result = lfucache_iterator {
399-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
404+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
400405
iter: crate::mutex::Mutex::new(lock.iter()),
401406
typ: 2,
402407
};
@@ -413,10 +418,10 @@ impl LFUCache {
413418
py: pyo3::Python<'_>,
414419
) -> pyo3::PyResult<pyo3::Py<lfucache_iterator>> {
415420
let mut lock = slf.raw.lock();
416-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
421+
let (len, state) = (lock.table.len(), lock.state.get());
417422

418423
let result = lfucache_iterator {
419-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
424+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
420425
iter: crate::mutex::Mutex::new(lock.iter()),
421426
typ: 0,
422427
};
@@ -433,10 +438,10 @@ impl LFUCache {
433438
py: pyo3::Python<'_>,
434439
) -> pyo3::PyResult<pyo3::Py<lfucache_iterator>> {
435440
let mut lock = slf.raw.lock();
436-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
441+
let (len, state) = (lock.table.len(), lock.state.get());
437442

438443
let result = lfucache_iterator {
439-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
444+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
440445
iter: crate::mutex::Mutex::new(lock.iter()),
441446
typ: 1,
442447
};

Diff for: ‎src/bridge/lrucache.rs

+13-8
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,11 @@ impl LRUCache {
4848
lock.maxsize.get()
4949
}
5050

51+
pub fn _state(&self) -> usize {
52+
let lock = self.raw.lock();
53+
lock.state.get()
54+
}
55+
5156
/// Returns the number of elements in the table - len(self)
5257
pub fn __len__(&self) -> usize {
5358
let lock = self.raw.lock();
@@ -138,10 +143,10 @@ impl LRUCache {
138143
py: pyo3::Python<'_>,
139144
) -> pyo3::PyResult<pyo3::Py<lrucache_iterator>> {
140145
let lock = slf.raw.lock();
141-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
146+
let (len, state) = (lock.table.len(), lock.state.get());
142147

143148
let result = lrucache_iterator {
144-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
149+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
145150
iter: crate::mutex::Mutex::new(lock.list.iter()),
146151
typ: 0,
147152
};
@@ -387,10 +392,10 @@ impl LRUCache {
387392
py: pyo3::Python<'_>,
388393
) -> pyo3::PyResult<pyo3::Py<lrucache_iterator>> {
389394
let lock = slf.raw.lock();
390-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
395+
let (len, state) = (lock.table.len(), lock.state.get());
391396

392397
let result = lrucache_iterator {
393-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
398+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
394399
iter: crate::mutex::Mutex::new(lock.list.iter()),
395400
typ: 2,
396401
};
@@ -407,10 +412,10 @@ impl LRUCache {
407412
py: pyo3::Python<'_>,
408413
) -> pyo3::PyResult<pyo3::Py<lrucache_iterator>> {
409414
let lock = slf.raw.lock();
410-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
415+
let (len, state) = (lock.table.len(), lock.state.get());
411416

412417
let result = lrucache_iterator {
413-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
418+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
414419
iter: crate::mutex::Mutex::new(lock.list.iter()),
415420
typ: 0,
416421
};
@@ -427,10 +432,10 @@ impl LRUCache {
427432
py: pyo3::Python<'_>,
428433
) -> pyo3::PyResult<pyo3::Py<lrucache_iterator>> {
429434
let lock = slf.raw.lock();
430-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
435+
let (len, state) = (lock.table.len(), lock.state.get());
431436

432437
let result = lrucache_iterator {
433-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
438+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
434439
iter: crate::mutex::Mutex::new(lock.list.iter()),
435440
typ: 1,
436441
};

Diff for: ‎src/bridge/rrcache.rs

+15-9
Original file line numberDiff line numberDiff line change
@@ -83,6 +83,11 @@ impl RRCache {
8383
lock.maxsize.get()
8484
}
8585

86+
pub fn _state(&self) -> usize {
87+
let lock = self.raw.lock();
88+
lock.state.get()
89+
}
90+
8691
/// Returns the number of elements in the table - len(self)
8792
pub fn __len__(&self) -> usize {
8893
let lock = self.raw.lock();
@@ -174,11 +179,11 @@ impl RRCache {
174179
py: pyo3::Python<'_>,
175180
) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
176181
let lock = slf.raw.lock();
177-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
182+
let (len, state) = (lock.table.len(), lock.state.get());
178183
let iter = unsafe { lock.table.iter() };
179184

180185
let result = cache_iterator {
181-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
186+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
182187
iter: crate::mutex::Mutex::new(iter),
183188
typ: 0,
184189
};
@@ -376,7 +381,8 @@ impl RRCache {
376381
/// Shrinks the cache to fit len(self) elements.
377382
pub fn shrink_to_fit(&self) {
378383
let mut lock = self.raw.lock();
379-
lock.table.shrink_to(0, |x| x.0.hash)
384+
lock.table.shrink_to(0, |x| x.0.hash);
385+
lock.state.change();
380386
}
381387

382388
/// Updates the cache with elements from a dictionary or an iterable object of key/value pairs.
@@ -430,11 +436,11 @@ impl RRCache {
430436
py: pyo3::Python<'_>,
431437
) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
432438
let lock = slf.raw.lock();
433-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
439+
let (len, state) = (lock.table.len(), lock.state.get());
434440
let iter = unsafe { lock.table.iter() };
435441

436442
let result = cache_iterator {
437-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
443+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
438444
iter: crate::mutex::Mutex::new(iter),
439445
typ: 2,
440446
};
@@ -452,11 +458,11 @@ impl RRCache {
452458
py: pyo3::Python<'_>,
453459
) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
454460
let lock = slf.raw.lock();
455-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
461+
let (len, state) = (lock.table.len(), lock.state.get());
456462
let iter = unsafe { lock.table.iter() };
457463

458464
let result = cache_iterator {
459-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
465+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
460466
iter: crate::mutex::Mutex::new(iter),
461467
typ: 0,
462468
};
@@ -474,11 +480,11 @@ impl RRCache {
474480
py: pyo3::Python<'_>,
475481
) -> pyo3::PyResult<pyo3::Py<cache_iterator>> {
476482
let lock = slf.raw.lock();
477-
let (len, capacity) = (lock.table.len(), lock.table.capacity());
483+
let (len, state) = (lock.table.len(), lock.state.get());
478484
let iter = unsafe { lock.table.iter() };
479485

480486
let result = cache_iterator {
481-
ptr: _KeepForIter::new(slf.as_ptr(), capacity, len),
487+
ptr: _KeepForIter::new(slf.as_ptr(), state, len),
482488
iter: crate::mutex::Mutex::new(iter),
483489
typ: 1,
484490
};

0 commit comments

Comments
 (0)