Struct VnodeMapping

pub struct VnodeMapping<T: VnodeMappingItem> {
    original_indices: Vec<u32>,
    data: Vec<T::Item>,
}

Generic mapping from virtual nodes to items.

The representation is compressed as described in compress_data, which is optimized for the mapping with a small number of items and good locality.

Fields

original_indices: Vec<u32>

data: Vec<T::Item>

Implementations

impl<T: VnodeMappingItem> VnodeMapping<T>

pub fn new_uniform( items: impl ExactSizeIterator<Item = T::Item>, vnode_count: usize, ) -> Self

Create a uniform vnode mapping with a set of items.

For example, if items is [0, 1, 2], and the total vnode count is 10, we’ll generate mapping like [0, 0, 0, 0, 1, 1, 1, 2, 2, 2].

pub fn new_single(item: T::Item) -> Self

Create a vnode mapping with the single item and length of 1.

Should only be used for singletons. If you want a different vnode count, call VnodeMapping::new_uniform with std::iter::once(item) and desired length.

pub fn len(&self) -> usize

The length (or count) of the vnode in this mapping.

pub fn get(&self, vnode: VirtualNode) -> T::Item

Get the item mapped to the given vnode by binary search.

Note: to achieve better mapping performance, one should convert the mapping to the ExpandedMapping first and directly access the item by index.

pub fn get_matched(&self, bitmap: &Bitmap) -> Option<T::Item>

Get the item matched by the virtual nodes indicated by high bits in the given bitmap. Returns None if the no virtual node is set in the bitmap.

pub fn iter(&self) -> impl Iterator<Item = T::Item> + '_

Iterate over all items in this mapping, in the order of vnodes.

pub fn iter_with_vnode( &self, ) -> impl Iterator<Item = (VirtualNode, T::Item)> + '_

Iterate over all vnode-item pairs in this mapping.

pub fn iter_unique(&self) -> impl Iterator<Item = T::Item> + '_

Iterate over all unique items in this mapping. The order is deterministic.

pub fn to_single(&self) -> Option<T::Item>

Returns the item if it’s the only item in this mapping, otherwise returns None.

pub fn to_bitmaps(&self) -> HashMap<T::Item, Bitmap>

Convert this vnode mapping to a mapping from items to bitmaps, where each bitmap represents the vnodes mapped to the item.

pub fn from_bitmaps(bitmaps: &HashMap<T::Item, Bitmap>) -> Self

Create a vnode mapping from the given mapping from items to bitmaps, where each bitmap represents the vnodes mapped to the item.

pub fn from_expanded(items: &[T::Item]) -> Self

Create a vnode mapping from the expanded slice of items.

pub fn to_expanded(&self) -> ExpandedMapping<T>

Convert this vnode mapping to a expanded vector of items.

pub fn transform<T2, M>(&self, to_map: &M) -> VnodeMapping<T2>

where T2: VnodeMappingItem, M: for<'a> Index<&'a T::Item, Output = T2::Item>,

Transform this vnode mapping to another type of vnode mapping, with the given mapping from items of this mapping to items of the other mapping.

impl VnodeMapping<Actor>

pub fn to_worker_slot( &self, actor_to_worker: &HashMap<ActorId, u32>, ) -> WorkerSlotMapping

Transform the actor mapping to the worker slot mapping. Note that the parameter is a mapping from actor to worker.

pub fn from_protobuf(proto: &ActorMappingProto) -> Self

Create an actor mapping from the protobuf representation.

pub fn to_protobuf(&self) -> ActorMappingProto

Convert this actor mapping to the protobuf representation.

impl VnodeMapping<WorkerSlot>

pub fn build_from_ids( worker_slot_ids: &[WorkerSlotId], vnode_count: usize, ) -> Self

Create a uniform worker mapping from the given worker ids

pub fn from_protobuf(proto: &PbWorkerSlotMapping) -> Self

Create a worker mapping from the protobuf representation.

pub fn to_protobuf(&self) -> PbWorkerSlotMapping

Convert this worker mapping to the protobuf representation.

impl VnodeMapping<WorkerSlot>

pub fn to_actor(&self, to_map: &HashMap<WorkerSlotId, ActorId>) -> ActorMapping

Transform this worker slot mapping to an actor mapping, essentially transform.

Trait Implementations

impl<T: VnodeMappingItem> Clone for VnodeMapping<T>

where Vec<u32>: Clone, Vec<T::Item>: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: VnodeMappingItem> Debug for VnodeMapping<T>

where Vec<u32>: Debug, Vec<T::Item>: Debug,

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

Formats the value using the given formatter.

impl<T: VnodeMappingItem> Hash for VnodeMapping<T>

where Vec<u32>: Hash, Vec<T::Item>: Hash,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: VnodeMappingItem> Index<VirtualNode> for VnodeMapping<T>

type Output = <T as VnodeMappingItem>::Item

The returned type after indexing.

fn index(&self, vnode: VirtualNode) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: VnodeMappingItem> PartialEq for VnodeMapping<T>

where Vec<u32>: PartialEq, Vec<T::Item>: PartialEq,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: VnodeMappingItem> Eq for VnodeMapping<T>

where Vec<u32>: PartialEq, Vec<T::Item>: PartialEq,