shardmap 0.2.1

Sharded embedded in-memory map with optional cache, protocol, and server internals
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

use std::cell::RefCell;
use std::fmt;
use std::marker::PhantomData;
use std::ops::ControlFlow;
use std::rc::Rc;

use crate::cuda::{
    CudaChunkTransferHit, CudaSessionChunkEvent, CudaSessionTransferRequest,
    CudaSessionTransferStats,
};
use crate::storage::{
    Bytes, EmbeddedKeyRoute, EmbeddedReadSlice, EmbeddedRouteMode, EmbeddedSessionRoute,
    EmbeddedStore, OwnedEmbeddedBatchReadView, OwnedEmbeddedReadView, OwnedEmbeddedRefMut,
    OwnedEmbeddedSessionPackedView, OwnedEmbeddedWorkerShards, PackedBatch, PackedSessionWrite,
    PreparedPointKey, TierStatsSnapshot,
};

thread_local! {
    static THREAD_LOCAL_EMBEDDED_STORE: RefCell<Option<WorkerLocalEmbeddedStore>> = const { RefCell::new(None) };
}

/// Worker-owned view of the shards assigned to one local server worker.
///
/// This is the sharded counterpart to [`EmbeddedStore`]. An `EmbeddedStore` can
/// be split into one `WorkerLocalEmbeddedStore` per worker. Each handle owns
/// only its assigned shards and exposes local operations through `&mut self`,
/// letting hot paths skip shared `RwLock` traffic when the key or session route
/// belongs to this worker.
///
/// Methods ending in `_if_local` return [`LocalRouteError`] when a key/session
/// routes to another worker. Methods ending in `_local` assume the caller has
/// already checked routing and use debug assertions for that contract.
#[derive(Debug)]
pub struct WorkerLocalEmbeddedStore {
    inner: OwnedEmbeddedWorkerShards,
}

/// Temporary container produced while partitioning an [`EmbeddedStore`] across workers.
///
/// `from_embedded` consumes the shared store and produces one
/// [`WorkerLocalEmbeddedStore`] per requested worker. Call [`Self::into_stores`]
/// to hand those stores to worker threads or runtimes.
#[derive(Debug)]
pub struct WorkerLocalEmbeddedStoreBootstrap {
    stores: Vec<WorkerLocalEmbeddedStore>,
}

/// Mutable point-key guard tied to a worker-local embedded store borrow.
pub type WorkerLocalEmbeddedRefMut<'a> = OwnedEmbeddedRefMut<'a>;

mod bootstrap;
mod core;
mod errors;
mod lifecycle;
mod read;
#[cfg(test)]
mod tests;
mod thread_local;
mod views;
mod write;

pub use errors::{LocalRouteError, LocalStoreAccessError, LocalStoreInstallError};
pub use thread_local::{take_thread_local_embedded_store, with_thread_local_embedded_store};
use views::worker_local_batch_view_from_embedded;
pub use views::{
    WorkerLocalBatchReadView, WorkerLocalReadSlice, WorkerLocalReadView,
    WorkerLocalSessionBatchView,
};