Struct mmtk::util::address::Address

#[repr(transparent)]
pub struct Address(usize);

Address represents an arbitrary address. This is designed to represent address and do address arithmetic mostly in a safe way, and to allow mark some operations as unsafe. This type needs to be zero overhead (memory wise and time wise). The idea is from the paper High-level Low-level Programming (VEE09) and JikesRVM.

Tuple Fields

0: usize

Implementations

impl Address

pub const ZERO: Self = _

The lowest possible address.

pub const MAX: Self = _

The highest possible address.

pub fn from_ptr<T>(ptr: *const T) -> Address

creates Address from a pointer

pub fn from_ref<T>(r: &T) -> Address

creates Address from a Rust reference

pub fn from_mut_ptr<T>(ptr: *mut T) -> Address

creates Address from a mutable pointer

pub const unsafe fn zero() -> Address

creates a null Address (0)

Safety

It is unsafe and the user needs to be aware that they are creating an invalid address. The zero address should only be used as unininitialized or sentinel values in performance critical code (where you dont want to use Option<Address>).

pub unsafe fn max() -> Address

creates an Address of (usize::MAX)

Safety

It is unsafe and the user needs to be aware that they are creating an invalid address. The max address should only be used as unininitialized or sentinel values in performance critical code (where you dont want to use Option<Address>).

pub const unsafe fn from_usize(raw: usize) -> Address

creates an arbitrary Address

Safety

It is unsafe and the user needs to be aware that they may create an invalid address. This creates arbitrary addresses which may not be valid. This should only be used for hard-coded addresses. Any other uses of this function could be replaced with more proper alternatives.

pub fn shift<T>(self, offset: isize) -> Self

shifts the address by N T-typed objects (returns addr + N * size_of(T))

pub const fn get_extent(self, other: Address) -> ByteSize

Get the number of bytes between two addresses. The current address needs to be higher than the other address.

pub const fn get_offset(self, other: Address) -> ByteOffset

Get the offset from other to self. The result is negative is self is lower than other.

pub const fn add(self, size: usize) -> Address

Add an offset to the address.

pub const fn sub(self, size: usize) -> Address

Subtract an offset from the address.

pub const fn and(self, mask: usize) -> usize

Bitwise ‘and’ with a mask.

pub const fn saturating_sub(self, size: usize) -> Address

Perform a saturating subtract on the Address

pub unsafe fn load<T: Copy>(self) -> T

loads a value of type T from the address

Safety

This could throw a segment fault if the address is invalid

pub unsafe fn store<T>(self, value: T)

stores a value of type T to the address

Safety

This could throw a segment fault if the address is invalid

pub unsafe fn atomic_load<T: Atomic>(self, order: Ordering) -> T::Type

atomic operation: load

Safety

This could throw a segment fault if the address is invalid

pub unsafe fn atomic_store<T: Atomic>(self, val: T::Type, order: Ordering)

atomic operation: store

Safety

This could throw a segment fault if the address is invalid

pub unsafe fn compare_exchange<T: Atomic>( self, old: T::Type, new: T::Type, success: Ordering, failure: Ordering ) -> Result<T::Type, T::Type>

atomic operation: compare and exchange usize

Safety

This could throw a segment fault if the address is invalid

pub fn is_zero(self) -> bool

is this address zero?

pub const fn align_up(self, align: ByteSize) -> Address

aligns up the address to the given alignment

pub const fn align_down(self, align: ByteSize) -> Address

aligns down the address to the given alignment

pub const fn is_aligned_to(self, align: usize) -> bool

is this address aligned to the given alignment

pub fn to_ptr<T>(self) -> *const T

converts the Address to a pointer

pub fn to_mut_ptr<T>(self) -> *mut T

converts the Address to a mutable pointer

pub unsafe fn as_ref<'a, T>(self) -> &'a T

converts the Address to a Rust reference

Safety

The caller must guarantee the address actually points to a Rust object.

pub unsafe fn as_mut_ref<'a, T>(self) -> &'a mut T

converts the Address to a mutable Rust reference

Safety

The caller must guarantee the address actually points to a Rust object.

pub const fn as_usize(self) -> usize

converts the Address to a pointer-sized integer

pub fn chunk_index(self) -> usize

returns the chunk index for this address

pub fn is_mapped(self) -> bool

return true if the referenced memory is mapped

pub fn range_intersection( r1: &Range<Address>, r2: &Range<Address> ) -> Range<Address>

Returns the intersection of the two address ranges. The returned range could be empty if there is no intersection between the ranges.

Trait Implementations

impl Add<isize> for Address

Address + ByteOffset (positive or negative)

type Output = Address

The resulting type after applying the + operator.

fn add(self, offset: ByteOffset) -> Address

Performs the + operation.

impl Add<usize> for Address

Address + ByteSize (positive)

type Output = Address

The resulting type after applying the + operator.

fn add(self, offset: ByteSize) -> Address

Performs the + operation.

impl AddAssign<isize> for Address

Address += ByteOffset (positive or negative)

fn add_assign(&mut self, offset: ByteOffset)

Performs the += operation.

impl AddAssign<usize> for Address

Address += ByteSize (positive)

fn add_assign(&mut self, offset: ByteSize)

Performs the += operation.

impl BitAnd<u8> for Address

type Output = u8

The resulting type after applying the & operator.

fn bitand(self, other: u8) -> u8

Performs the & operation.

impl BitAnd<usize> for Address

Address & mask

type Output = usize

The resulting type after applying the & operator.

fn bitand(self, other: usize) -> usize

Performs the & operation.

impl BitOr<u8> for Address

type Output = usize

The resulting type after applying the | operator.

fn bitor(self, other: u8) -> usize

Performs the | operation.

impl BitOr<usize> for Address

Address | mask

type Output = usize

The resulting type after applying the | operator.

fn bitor(self, other: usize) -> usize

Performs the | operation.

impl Clone for Address

fn clone(&self) -> Address

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Address

allows Debug format the Address (as upper-case hex value with 0x prefix)

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

Formats the value using the given formatter.

impl Display for Address

allows Display format the Address (as upper-case hex value with 0x prefix)

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

Formats the value using the given formatter.

impl Edge for Address

For backword compatibility, we let Address implement Edge so that existing bindings that use Address to represent an edge can continue to work.

However, we should use SimpleEdge directly instead of using Address. The purpose of the Address type is to represent an address in memory. It is not directly related to fields that hold references to other objects. Calling load() and store() on an Address does not indicate how many bytes to load or store, or how to interpret those bytes. On the other hand, SimpleEdge is all about how to access a field that holds a reference represented simply as an ObjectReference. The intention and the semantics are clearer with SimpleEdge.

fn load(&self) -> Option<ObjectReference>

Load object reference from the slot.

fn store(&self, object: ObjectReference)

Store the object reference object into the slot.

fn prefetch_load(&self)

Prefetch the edge so that a subsequent load will be faster.

fn prefetch_store(&self)

Prefetch the edge so that a subsequent store will be faster.

impl FromStr for Address

type Err = ParseIntError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Address

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 LowerHex for Address

allows print Address as lower-case hex value

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

Formats the value using the given formatter.

impl Ord for Address

fn cmp(&self, other: &Address) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Address

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Address

fn partial_cmp(&self, other: &Address) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Shl<usize> for Address

Address << shift (get an index)

type Output = usize

The resulting type after applying the << operator.

fn shl(self, shift: usize) -> usize

Performs the << operation.

impl Shr<usize> for Address

Address >> shift (get an index)

type Output = usize

The resulting type after applying the >> operator.

fn shr(self, shift: usize) -> usize

Performs the >> operation.

impl Sub<usize> for Address

Address - ByteSize (positive)

type Output = Address

The resulting type after applying the - operator.

fn sub(self, offset: ByteSize) -> Address

Performs the - operation.

impl Sub for Address

Address - Address (the first address must be higher)

type Output = usize

The resulting type after applying the - operator.

fn sub(self, other: Address) -> ByteSize

Performs the - operation.

impl SubAssign<usize> for Address

Address -= ByteSize (positive)

fn sub_assign(&mut self, offset: ByteSize)

Performs the -= operation.

impl UpperHex for Address

allows print Address as upper-case hex value

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

Formats the value using the given formatter.

impl Copy for Address

impl Eq for Address

impl NoUninit for Address

impl StructuralPartialEq for Address