Struct 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 post 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 Debug for TenuredHeap

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

Formats the value using the given formatter.

impl PartialEq for TenuredHeap

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for TenuredHeap

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: 8 bytes