Struct script::dom::bindings::import::module::jsapi::TenuredHeap

#[repr(C)]
pub struct TenuredHeap {
    pub bits: usize,
}

The TenuredHeap class is similar to the Heap class above in that it encapsulates the GC concerns of an on-heap reference to a JS object. However, it has two important differences:

1. Pointers which are statically known to only reference “tenured” objects can avoid the extra overhead of SpiderMonkey’s write barriers.

2. Objects in the “tenured” heap have stronger alignment restrictions than those in the “nursery”, so it is possible to store flags in the lower bits of pointers known to be tenured. TenuredHeap wraps a normal tagged pointer with a nice API for accessing the flag bits and adds various assertions to ensure that it is not mis-used.

GC things are said to be “tenured” when they are located in the long-lived heap: e.g. they have gained tenure as an object by surviving past at least one GC. For performance, SpiderMonkey allocates some things which are known to normally be long lived directly into the tenured generation; for example, global objects. Additionally, SpiderMonkey does not visit individual objects when deleting non-tenured objects, so object with finalizers are also always tenured; for instance, this includes most DOM objects.

The considerations to keep in mind when using a TenuredHeap vs a normal Heap are:

• It is invalid for a TenuredHeap to refer to a non-tenured thing.
• It is however valid for a Heap to refer to a tenured thing.
• It is not possible to store flag bits in a Heap.

Fields

bits: usize

Trait Implementations

impl Clone for TenuredHeap

fn clone(&self) -> TenuredHeap

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TenuredHeap

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

Formats the value using the given formatter.

impl PartialEq for TenuredHeap

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

impl StructuralPartialEq for TenuredHeap