fast-cache 0.1.0

Embedded-first thread-per-core in-memory cache with optional Redis-compatible server
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

[package]
name = "fast-cache"
version.workspace = true
edition.workspace = true
authors.workspace = true
homepage.workspace = true
license.workspace = true
repository.workspace = true
rust-version.workspace = true
description = "Embedded-first thread-per-core in-memory cache with optional Redis-compatible server"
documentation = "https://docs.rs/fast-cache"
keywords = ["cache", "redis", "kv", "storage", "wal"]
categories = ["caching", "database-implementations"]
readme = "README.md"
autobins = false
autotests = false
autobenches = false
exclude = [
    "bench/**",
    "fuzz/**",
    "tests/**",
    "src/bin/bench_*.rs",
    ".DS_Store",
]

[features]
# The crate defaults to the embedded Rust API. The TCP server is available as
# an explicit feature for deployments that want Redis/FCNP network ingress.
default = ["embedded", "sharded"]
embedded = []
sharded = ["embedded"]
server = [
    "sharded",
    "dep:bytes-handoff",
    "dep:clap",
    "dep:flume",
    "dep:socket2",
    "dep:tracing-subscriber",
]
# Linux-only runtime for the TCP server. It uses bytes-handoff's monoio read
# adapter while monoio owns the socket driver and shard-local worker runtime.
# Plain `server` remains the portable tokio implementation.
monoio = ["server", "dep:monoio", "bytes-handoff?/monoio"]
cuda = ["sharded"]
telemetry = ["embedded"]
fast-point-map = []
# Benchmark-only comparison knob for the shared embedded store lock.
# Default builds use `rblock`; enabling this swaps those stripes to
# `parking_lot::RwLock` so cache-level lock behavior can be A/B measured.
shared-parking-lot-lock = []
# Benchmark-only comparison knob for the server/direct `EmbeddedStore` lock.
# Default builds keep `parking_lot::RwLock`; enabling this swaps shard locks to
# `rblock::RwLock` so the server path can be A/B measured.
embedded-read-biased-lock = []
# Opt into reviewed unsafe hot paths for maximum throughput. This enables
# direct single-worker lock bypass, unchecked flat-map indexing/comparison
# helpers, and raw response-buffer writes.
unsafe = []

[dependencies]
bytes = "1"
bytes-handoff = { version = "1.2.0", optional = true }
clap = { workspace = true, optional = true }
core_affinity = { workspace = true }
crc32fast = { workspace = true }
crossbeam-channel = { workspace = true }
crossbeam-utils = { workspace = true }
fast-telemetry = { workspace = true }
hashbrown = { workspace = true }
itoa = "1"
log = { workspace = true }
libc = { workspace = true }
lz4_flex = { workspace = true }
memchr = "2"
parking_lot = { workspace = true }
rblock = { workspace = true }
serde = { workspace = true }
smallvec = "1"
socket2 = { version = "0.5", features = ["all"], optional = true }
serde_json = { workspace = true }
thiserror = { workspace = true }
tokio = { workspace = true }
toml = { workspace = true }
tracing = { workspace = true }
tracing-subscriber = { workspace = true, optional = true }
xxhash-rust = { workspace = true }
zstd = { workspace = true }

[dev-dependencies]
tempfile = { workspace = true }

# Runtime-agnostic mpsc used by the tokio fanout acceptor. Monoio and tokio
# direct-shard workers bind their own shard-local listeners instead.
[dependencies.flume]
version = "0.11"
default-features = false
features = ["async"]
optional = true

# Linux-only monoio runtime, gated via FAST_CACHE_USE_MONOIO=1 at runtime.
[target.'cfg(target_os = "linux")'.dependencies]
monoio = { version = "0.2", optional = true }

[[bin]]
name = "fast-cache-server"
required-features = ["server"]