Struct PlanConstraints

pub struct PlanConstraints {
    pub collects_garbage: bool,
    pub moves_objects: bool,
    pub max_non_los_default_alloc_bytes: usize,
    pub max_non_los_copy_bytes: usize,
    pub needs_log_bit: bool,
    pub may_trace_duplicate_edges: bool,
    pub barrier: BarrierSelector,
    pub needs_linear_scan: bool,
    pub needs_concurrent_workers: bool,
    pub needs_forward_after_liveness: bool,
    pub needs_prepare_mutator: bool,
    pub generational: bool,
}

This struct defines plan-specific constraints. Most of the constraints are constants. Each plan should declare a constant of this struct, and use the constant wherever possible. However, for plan-neutral implementations, these constraints are not constant.

Fields

collects_garbage: bool

Does the plan collect garbage? Obviously most plans do, but NoGC does not collect.

moves_objects: bool

True if the plan moves objects.

max_non_los_default_alloc_bytes: usize

Size (in bytes) beyond which new regular objects must be allocated to the LOS. This usually depends on the restriction of the default allocator, e.g. block size for Immix, nursery size, max possible cell for freelist, etc.

max_non_los_copy_bytes: usize

Size (in bytes) beyond which copied objects must be copied to the LOS. This depends on the copy allocator.

needs_log_bit: bool

Does this plan use the log bit? See vm::ObjectModel::GLOBAL_LOG_BIT_SPEC.

may_trace_duplicate_edges: bool

Some plans may allow benign race for testing mark bit, and this will lead to trace the same edge multiple times. If a plan allows tracing duplicated edges, we will not run duplicate edge check in extreme_assertions.

Note: Both crate::vm::Scanning::scan_object (which enqueues slots) and crate::vm::Scanning::scan_object_and_trace_edges (which traces the targets directly) are affected by such benign races. But our current duplicate edge check in extreme_assertions only identifies duplicated slots.

barrier: BarrierSelector

The barrier this plan uses. A binding may check this and know what kind of write barrier is in use if they would like to implement the barrier fast path in the binding side.

needs_linear_scan: bool

True if this plan requires linear scanning. This is unused and may be incorrect.

needs_concurrent_workers: bool

True if this plan requires concurrent worker threads. This is unused and may be incorrect.

needs_forward_after_liveness: bool

Some policies do object forwarding after the first liveness transitive closure, such as mark compact. For plans that use those policies, they should set this as true.

needs_prepare_mutator: bool

Some (in fact, most) plans do nothing when preparing mutators before tracing (i.e. in MutatorConfig::prepare_func). Those plans can set this to false so that the PrepareMutator work packets will not be created at all.

generational: bool

Is this plan generational?

Implementations

impl PlanConstraints

pub const fn default() -> Self

A const function to create the default plan constraints.