Struct mmtk::policy::marksweepspace::native_ms::block::Block

#[repr(transparent)]
pub struct Block(NonZeroUsize);

A 64KB region for MiMalloc. This is also known as MiMalloc page. We try to avoid getting confused with the OS 4K page. So we call it block. This type always holds a non-zero address to refer to a block. The underlying NonZeroUsize type ensures the size of Option<Block> is the same as Block itself.

Tuple Fields

0: NonZeroUsize

Implementations

impl Block

pub const LOG_PAGES: usize = 4usize

Log pages in block

pub const METADATA_SPECS: [SideMetadataSpec; 7] = _

pub const MARK_TABLE: SideMetadataSpec = crate::util::metadata::side_metadata::spec_defs::MS_BLOCK_MARK

Block mark table (side)

pub const NEXT_BLOCK_TABLE: SideMetadataSpec = crate::util::metadata::side_metadata::spec_defs::MS_BLOCK_NEXT

pub const PREV_BLOCK_TABLE: SideMetadataSpec = crate::util::metadata::side_metadata::spec_defs::MS_BLOCK_PREV

pub const FREE_LIST_TABLE: SideMetadataSpec = crate::util::metadata::side_metadata::spec_defs::MS_FREE

pub const SIZE_TABLE: SideMetadataSpec = crate::util::metadata::side_metadata::spec_defs::MS_BLOCK_SIZE

pub const BLOCK_LIST_TABLE: SideMetadataSpec = crate::util::metadata::side_metadata::spec_defs::MS_BLOCK_LIST

pub const TLS_TABLE: SideMetadataSpec = crate::util::metadata::side_metadata::spec_defs::MS_BLOCK_TLS

pub fn load_free_list(&self) -> Address

pub fn store_free_list(&self, free_list: Address)

pub fn load_prev_block(&self) -> Option<Block>

pub fn load_next_block(&self) -> Option<Block>

pub fn store_next_block(&self, next: Block)

pub fn clear_next_block(&self)

pub fn store_prev_block(&self, prev: Block)

pub fn clear_prev_block(&self)

pub fn store_block_list(&self, block_list: &BlockList)

pub fn load_block_list(&self) -> *mut BlockList

pub fn load_block_cell_size(&self) -> usize

pub fn store_block_cell_size(&self, size: usize)

pub fn store_tls(&self, tls: VMThread)

pub fn load_tls(&self) -> VMThread

pub fn has_free_cells(&self) -> bool

pub fn get_state(&self) -> BlockState

Get block mark state.

pub fn set_state(&self, state: BlockState)

Set block mark state.

pub fn attempt_release<VM: VMBinding>(self, space: &MarkSweepSpace<VM>) -> bool

Release this block if it is unmarked. Return true if the block is released.

pub fn sweep<VM: VMBinding>(&self)

Sweep the block. This is done either lazily in the allocation phase, or eagerly at the end of a GC.

fn simple_sweep<VM: VMBinding>(&self)

This implementation uses object reference and cell address interchangably. This is not correct for most cases. However, in certain cases, such as OpenJDK, this is correct, and efficient. See the sweep method for the invariants that we need to use this method correctly.

fn naive_brute_force_sweep<VM: VMBinding>(&self)

This is a naive implementation that is inefficient but should be correct. In this implementation, we simply go through each possible object reference and see if it has the mark bit set. If we find mark bit, that means the cell is alive. If we didn’t find the mark bit in the entire cell, it means the cell is dead.

pub fn chunk(&self) -> Chunk

Get the chunk containing the block.

pub fn init(&self)

Initialize a clean block after acquired from page-resource.

pub fn deinit(&self)

Deinitalize a block before releasing.

Trait Implementations

impl BlockMayHaveObjects for Block

fn may_have_objects(&self) -> bool

Return true if the block may contain valid objects (objects with the VO bit set). Return false otherwise.

impl Clone for Block

fn clone(&self) -> Block

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Block

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

Formats the value using the given formatter.

impl PartialEq for Block

fn eq(&self, other: &Block) -> 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 Block

fn partial_cmp(&self, other: &Block) -> 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 Region for Block

const LOG_BYTES: usize = 16usize

log2 of the size in bytes for the region.

fn from_aligned_address(address: Address) -> Self

Create a region from an address that is aligned to the region boundary. The method should panic if the address is not properly aligned to the region. For performance, this method should always be inlined.

fn start(&self) -> Address

Return the start address of the region. For performance, this method should always be inlined.

const BYTES: usize = _

The size in bytes for the region.

fn from_unaligned_address(address: Address) -> Self

Create a region from an arbitrary address.

fn align(address: Address) -> Address

Align the address to the region.

fn is_aligned(address: Address) -> bool

Check if an address is aligned to the region.

fn end(&self) -> Address

Return the end address of the region. Note that the end address is not in the region.

fn next(&self) -> Self

Return the next region after this one.

fn next_nth(&self, n: usize) -> Self

Return the next nth region after this one.

fn containing(object: ObjectReference) -> Self

Return the region that contains the object.

fn includes_address(&self, addr: Address) -> bool

Check if the given address is in the region.

impl Copy for Block

impl StructuralPartialEq for Block