Iterating a cache segfaults on 3.*t while another thread writes to it

src/policies/fifopolicy.rs

@@ -38,8 +38,12 @@ impl traits::OccupiedExt for Occupied<'_> {
 
     #[inline]
     fn replace(self, new: Self::Handle) -> Self::Handle {
-        // In update we don't need to increment this; because this does not change the memory address ranges
-        // self.shared.generation_version().increment();
+        // The replace operation does not modify memory range here in the normal case,
+        // but when the GIL is disabled, concurrent modification can cause a segfault.
+        // Therefore, in free-threaded versions we have to change the generation version
+        // before manipulating memory.
+        #[cfg(Py_GIL_DISABLED)]
+        self.shared.generation_version().increment();
 
         let item = unsafe { get_handle!(&mut self.policy, *self.bucket.as_ref()) };
 

src/policies/lfupolicy.rs

@@ -147,8 +147,12 @@ impl traits::OccupiedExt for Occupied<'_> {
     type Shared = Shared;
 
     fn replace(self, new: Self::Handle) -> Self::Handle {
-        // Here we don't need to increment generation version
-        // self.shared.generation_version().increment();
+        // The replace operation does not modify memory range here in the normal case,
+        // but when the GIL is disabled, concurrent modification can cause a segfault.
+        // Therefore, in free-threaded versions we have to change the generation version
+        // before manipulating memory.
+        #[cfg(Py_GIL_DISABLED)]
+        self.shared.generation_version().increment();
 
         unsafe {
             let cursor = self.bucket.as_mut();

src/policies/nopolicy.rs

@@ -33,6 +33,13 @@ impl traits::OccupiedExt for Occupied<'_> {
     }
 
     fn replace(self, new: Self::Handle) -> Self::Handle {
+        // The replace operation does not modify memory range here in the normal case,
+        // but when the GIL is disabled, concurrent modification can cause a segfault.
+        // Therefore, in free-threaded versions we have to change the generation version
+        // before manipulating memory.
+        #[cfg(Py_GIL_DISABLED)]
+        self.shared.generation_version().increment();
+
         self.policy.currsize = self.policy.currsize.saturating_add(new.size());
         let old = unsafe { std::mem::replace(self.bucket.as_mut(), new) };
         self.policy.currsize = self.policy.currsize.saturating_sub(old.size());

src/policies/rrpolicy.rs

@@ -35,6 +35,13 @@ impl traits::OccupiedExt for Occupied<'_> {
 
     #[inline]
     fn replace(self, new: Self::Handle) -> Self::Handle {
+        // The replace operation does not modify memory range here in the normal case,
+        // but when the GIL is disabled, concurrent modification can cause a segfault.
+        // Therefore, in free-threaded versions we have to change the generation version
+        // before manipulating memory.
+        #[cfg(Py_GIL_DISABLED)]
+        self.shared.generation_version().increment();
+
         self.policy.currsize = self.policy.currsize.saturating_add(new.size());
         let old = unsafe { std::mem::replace(self.bucket.as_mut(), new) };
         self.policy.currsize = self.policy.currsize.saturating_sub(old.size());

src/policies/ttlpolicy.rs

@@ -151,8 +151,12 @@ impl traits::OccupiedExt for Occupied<'_> {
 
     #[inline]
     fn replace(self, new: Self::Handle) -> Self::Handle {
-        // In update we don't need to increment this; because this does not change the memory address ranges
-        // self.shared.generation_version().increment();
+        // The replace operation does not modify memory range here in the normal case,
+        // but when the GIL is disabled, concurrent modification can cause a segfault.
+        // Therefore, in free-threaded versions we have to change the generation version
+        // before manipulating memory.
+        #[cfg(Py_GIL_DISABLED)]
+        self.shared.generation_version().increment();
 
         let item = unsafe { get_handle!(&mut self.policy, *self.bucket.as_ref()) };
 

src/policies/vttlpolicy.rs

@@ -152,8 +152,12 @@ impl traits::OccupiedExt for Occupied<'_> {
     type Shared = Shared;
 
     fn replace(self, new: Self::Handle) -> Self::Handle {
-        // Here we don't need to increment generation version
-        // self.shared.generation_version().increment();
+        // The replace operation does not modify memory range here in the normal case,
+        // but when the GIL is disabled, concurrent modification can cause a segfault.
+        // Therefore, in free-threaded versions we have to change the generation version
+        // before manipulating memory.
+        #[cfg(Py_GIL_DISABLED)]
+        self.shared.generation_version().increment();
 
         unsafe {
             let cursor = self.bucket.as_mut();

tests/mixins.py

@@ -5,6 +5,7 @@
 import platform
 import subprocess
 import sys
+import sysconfig
 import threading
 import time
 import typing
@@ -669,13 +670,16 @@ def test_generation_version_on_insert(self):
             for _ in cache.items():
                 cache.insert("C", 1)
 
-        if isinstance(cache, cachebox.LRUCache):
-            return
+        if not isinstance(cache, cachebox.LRUCache) and not sysconfig.get_config_var(
+            "Py_GIL_DISABLED"
+        ):
+            for i in cache:
+                cache.insert(i, "hello")
 
-        for i in cache:
-            # It should not increment the generation version
-            # in replacing value
-            cache.insert(i, "hello")
+        else:
+            with pytest.raises(RuntimeError):
+                for i in cache:
+                    cache.insert(i, "hello")
 
     def test_generation_version_on_shrink_to_fit(self):
         cache = self.create_cache(10, {i: i for i in range(3)})