Hangs on re-entrant cache decorators?

[jaens]

My code has a @cachebox.cached decorator attached to a function, which then calls another (nested) @cachebox.cached in its scope. (both decorators are using the same cachebox.Cache(maxsize=0))

Both functions are called simultaneously (mixed) from multiple threads.

When there are a lot of those function calls, the entire application hangs. This is fixed by removing the @cachebox.cached decorator from one of the functions.

So I'm guessing there's some sort of race condition or deadlock somewhere...

(the application itself has no locks at all, it's purely data-parallel via ThreadPoolExecutor)

[awolverp]

Hello. thank you for your report and sorry for the delay.

I have to make time to test and find the problem, but I will do it ASAP.

[awolverp]

@jaens
Can you give a simple example of how you are using it? I haven't found any situation that causes this bug.

[jaens]

It occurs non-deterministically under high loads, therefore of course there isn't a simple reproducer...
(this is why writing threaded code can generally not really rely on tests, but requires some sort of formal modeling / verification.)

Simplified, the code is:

type MemoizeCache = cachebox.Cache[str, object]
cache_cache = cachebox.Cache[Path, MemoizeCache](maxsize=0)

@cachebox.cached(cache=cache_cache)
def get_cache(cache_file: Path):
    cache: MemoizeCache | None = None
    if cache_file.exists():
        with cache_file.open("rb") as f:
            cache = pickle.load(f)

    if cache is None:
        cache = cachebox.Cache(maxsize=0)

    return cache

@cachebox.cached(lambda p, *args, **kwargs: get_cache(p))
def cached_fn(p, ...):
    # Heavy code doing lots of subprocess I/O, called from multiple threads
    # (code itself is trivially thread-safe, does not use locks or synchronization)
    ...

[awolverp]

I could not found the bug, and any situation to trigger it happen.
I'll be refactoring this library (#40), so hopefully this bug wont occur with it anymore.