pub struct Stack {
    borrows: Vec<Item>,
    unknown_bottom: Option<SbTag>,
    cache: StackCache,
    unique_range: Range<usize>,
}
Expand description

Extra per-location state.

Fields

borrows: Vec<Item>

Used mostly as a stack; never empty. Invariants:

  • Above a SharedReadOnly there can only be more SharedReadOnly.
  • Except for Untagged, no tag occurs in the stack more than once.
unknown_bottom: Option<SbTag>

If this is Some(id), then the actual current stack is unknown. This can happen when wildcard pointers are used to access this location. What we do know is that borrows are at the top of the stack, and below it are arbitrarily many items whose tag is strictly less than id. When the bottom is unknown, borrows always has a SharedReadOnly or Unique at the bottom; we never have the unknown-to-known boundary in an SRW group.

cache: StackCache

A small LRU cache of searches of the borrow stack.

unique_range: Range<usize>

On a read, we need to disable all Unique above the granting item. We can avoid most of this scan by keeping track of the region of the borrow stack that may contain Uniques.

Implementations

Panics if any of the caching mechanisms have broken,

  • The StackCache indices don’t refer to the parallel items,
  • There are no Unique items outside of first_unique..last_unique

Find the item granting the given kind of access to the given tag, and return where it is on the stack. For wildcard tags, the given index is approximate, but if no index is given it means the match was not in the known part of the stack. Ok(None) indicates it matched the “unknown” part of the stack. Err indicates it was not found.

Construct a new Stack using the passed Item as the base tag.

Find all Unique elements in this borrow stack above granting_idx, pass a copy of them to the visitor, then set their Permission to Disabled.

Produces an iterator which iterates over range in reverse, and when dropped removes that range of Items from this Stack.

Core per-location operations: access, dealloc, reborrow.

Find the first write-incompatible item above the given one – i.e, find the height to which the stack will be truncated when writing to granting.

Check if the given item is protected.

The provoking_access argument is only used to produce diagnostics. It is Some when we are granting the contained access for said tag, and it is None during a deallocation. Within provoking_access, the AllocRangerefers the entire operation, and theSizerefers to the specific location in theAllocRange` that we are currently checking.

Test if a memory access using pointer tagged tag is granted. If yes, return the index of the item that granted it. range refers the entire operation, and offset refers to the specific offset into the allocation that we are currently checking.

Deallocate a location: Like a write access, but also there must be no active protectors at all because we will remove all items.

Derive a new pointer from one with the given tag. weak controls whether this operation is weak or strong: weak granting does not act as an access, and they add the new item directly on top of the one it is derived from instead of all the way at the top of the stack. range refers the entire operation, and offset refers to the specific location in range that we are currently checking.

Trait Implementations

Returns a copy of the value. Read more
Performs copy-assignment from source. Read more
Formats the value using the given formatter. Read more
This method tests for self and other values to be equal, and is used by ==. Read more
This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The resulting type after obtaining ownership.
Creates owned data from borrowed data, usually by cloning. Read more
Uses borrowed data to replace owned data, usually by cloning. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.

Size: 560 bytes