LruClockCache VS ScaleStore

Is it feasible to write a fast caching library for Python in pure Python codes or does its function calling overhead limit the performance of cache access? What about linking a C++ caching function to Python environment to be called? Does it cause worse latency or better latency than the pure-Python version? (I'm considering converting my C++ caching tool to Python: https://github.com/tugrul512bit/LruClockCache which has performance between 50M - 2B lookups per second depending on use-cases)

Hi, I implemented a multi-level LRU+direct mapped cache (https://github.com/tugrul512bit/LruClockCache/wiki/How-To-Do-Multithreading-With-a-Read-Only-Multi-Level-Cache) and it works as a single threaded read-write cache or multi-threaded read-only cache. Now I'm going to add cache-coherence to it (so it will be read-write multithreaded) but by using smart pointers as "value" cells. So, a get method will return shared_ptr and I can change its data by dereferencing and it instantly visible on other L1 caches in other threads. But there are some problems.

Implementation: https://github.com/tugrul512bit/LruClockCache/blob/main/LruClockCache.h

I don't remember exactly why I have any of them saved, but these are some experimental data stores that seems to be fitting what you're looking for somewhat:

- https://github.com/DataManagementLab/ScaleStore - "A Fast and Cost-Efficient Storage Engine using DRAM, NVMe, and RDMA"

- https://github.com/unum-cloud/udisk - "The fastest ACID-transactional persisted Key-Value store designed for NVMe block-devices with GPU-acceleration and SPDK to bypass the Linux kernel."

- https://github.com/capsuleman/ssd-nvme-database - "Columnar database on SSD NVMe"

The linked blog post at the top of this article - https://muratbuffalo.blogspot.com/2023/01/is-scalable-oltp-i... - provides graphics that give extremely useful context. And here's the repo for the paper that discusses: https://github.com/DataManagementLab/ScaleStore

The idea that one of many writer-compute-nodes can literally reach into a memory buffer that is shared across machines, atomically flip some lock bits and propagate some cache-coherence messages, and use that to build a multi-writer distributed database without needing to partition (and where any writer-compute-node can handle any message, so you can just round-robin a firehose of messages at them)... and that there's a chance (though not yet implemented) that one could implement ACID on top of this? It's absolute madness, and wildly exciting.