Struct KVStore 

pub struct KVStore<T> { /* private fields */ }

A distributed Key, Value store which is generic for type T. Since this is a distributed KVStore, Keys know which node the values ‘belong’ to.

Internally KVStores store their data in memory as serialized blobs (Vec<u8>). The KVStore caches deserialized Values into their type T on a least-recently used basis. There is a hard limit on the cache size that is set to 1/3 the total memory of the machine.

Implementations

impl<T: Serialize + DeserializeOwned + Sync + Send + PartialEq + DeepSizeOf + 'static> KVStore<T>

pub async fn new( server_addr: String, my_addr: String, blob_sender: Sender<Value>, num_clients: usize, ) -> Arc<Self>

Creates a new distributed KVStore. Note that you likely do not want to use a KVStore directly, and instead would have a much easier time using the application layer directly via the LiquidML struct.

Parameters

• server_addr: the IP:Port of the registration Server, used for orchestrating the connection of all distributed nodes in the system.
• my_addr is the IP:Port of this KVStore.
• blob_sender: is the sending half of an mpsc channel that is passed in by components using this KVStore to facilitate lower level messages. In the case of liquid_ml, it will use the blob_sender to forward the blob to LiquidML. If you are not using LiquidML, you must store the receiving half of the mpsc channel so you may process blobs that are received.
• kill_notifier: When using the application layer directly, this is passed in for you by the LiquidML struct and is used to perform orderly shutdown when the Client receives Kill messages from the Server
• num_clients: the number of nodes in the distributed system, including this one.
• wait_for_all_clients: whether or not to wait for all other nodes to connect to this one before returning the new KVStore.

pub async fn get(&self, key: &Key) -> Result<Arc<T>, LiquidError>

Used to retrieve the deserialized Value associated with the given key if the data is held locally on this node in either the cache or the store itself.

The difference between get and wait_and_get is that get returns an error if the data is not owned by this KVStore or if it is not owned by this KVStore and it is not in its cache.

Errors

If key is not in this KVStores cache or is not owned by this KVStore, then the error LiquidError::NotPresent is returned

pub async fn wait_and_get(&self, key: &Key) -> Result<Arc<T>, LiquidError>

Get the data for the given key. If the key belongs on a different node then the data will be requested from the node that owns the key and awaiting this method will block until that node responds with the data.

Make sure that you use this function in only one of the two following ways:

1. You know that the data was put some microseconds around when wait_and_get was called, but can’t guarantee it happened exactly before wait_and_get is called. In this case, this function can be awaited
2. The data will be put on this KVStore sometime in the future at an unknown time. In this case, this function should not be awaited but instead given a callback closure via calling and_then on the returned future

If you do not do that, for example in the second case you await despite our warning, then you will waste a lot of time waiting for the data to be transferred over the network.

pub async fn put( &self, key: Key, value: T, ) -> Result<Option<Value>, LiquidError>

Puts the data held in value to the KVStore with the id in key.home.

If key belongs to this KVStore

If this KVStore did not have this key present, Ok(None) is returned.

If this KVStore does have this key present, the associated Value is updated, and Ok(Some<Value>) of the old Value is returned. The key is not updated, though; this matters for types that can be == without being identical.

If key belongs to another KVStore

Ok(None) is returned after the value was successfully sent

pub async fn send_blob( &self, target_id: usize, blob: Value, ) -> Result<(), LiquidError>

Sends the given blob to the KVStore with the given target_id This provides a lower level interface to facilitate other kinds of messages

Trait Implementations

impl<T: Debug> Debug for KVStore<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.