cachegrand VS rio

https://github.com/danielealbano/cachegrand/blob/main/docs/a...

When tested with memtier_benchmark, using the Redis protocol, cachegrand itself, on the benchmarking hardware, thanks to the implemented hashtable can reach up to 5 million GET op/s and up to 4.5 million UPSERT op/s without batching, with it up to 60 million GET op/s and up to 26 million UPSERT op/s!

I am the author of the platform, happy to reply to any question you might have! Here a direct link to the latest release https://github.com/danielealbano/cachegrand/releases/tag/v0.1.4 Although it can easily used via docker. Currently it's focused on supporting Redis, here the list of commands currently implemented https://github.com/danielealbano/cachegrand/blob/main/docs/architecture/modules/redis.md

https://github.com/danielealbano/cachegrand/releases/tag/v0....

Although it can easily used via docker.

Currently it's focused on supporting Redis, here the list of commands currently implemented

cachegrand ( https://cachegrand.io/ ), my OSS caching platform, uses io_uring & fibers

https://github.com/danielealbano/cachegrand :)

I am not going to get into what's better and what's not, especially because I haven't released the v0.1 yet and therefore it's not usable, but I am working on cachegrand which is aims to be (also) a redis compatible platform.

I have done A LOT of research and development before picking up the current architecture (you can see it from the amounts of commits) and I am trying to test as much as possible (Almost 1000 unit tests so far, but there is still plenty to do).

if you look at the repository please bare in mind that:

Also, not to be too bad about a reputation fallacy, but I found the author to be flippant and disrespectful when good-faith unsoundness was pointed out in his crates: https://github.com/spacejam/rio/issues/30

In my previous post on linear types I spent quite a bit of time motivating linear types. For example the ergonomic rio io_uring library could be made sound if it could guarantee destructors are run. Or performing FFI with async C++ could be made more efficient if it could rely directly on destructors rather than having to involve an intermediate runtime for each call.

It's like cargo should have a way to mark a dependency as unsafe. That way, you could have a safe mmap crate as an unsafe dependency. Or something like rio which is deliberately unsound (but is fine if you abide by its rules through the entirety of the program)

for completeness there is also rio, but:

Here are some posts about the design. https://without.boats/blog/io-uring/ https://github.com/spacejam/rio/issues/30 https://github.com/axboe/liburing/issues/109

The author of sled[1], an embedded database in Rust which has a number of promising features, has also written parts of rio[2], an underlying pure Rust io_uring library, which is intended to become the core write path for sled. rio has support for files but also has a demo for TCP (on Linux 5.5 and later) and O_DIRECT.

I tested rio recently as I had a Brilliant but Bad Idea™ involving file access and was pleasantly surprised by the API, as I have been with sled's.

I'm excited for the experimentation in the Rust ecosystem and for such low level crates to handle the complex io_uring tasks (relatively) safely!

[1]: https://github.com/spacejam/sled

[2]: https://github.com/spacejam/rio