Only update reference if the object is actually moved?

[qinsoon]

In the line in ProcessEdgesWork,

mmtk-core/src/scheduler/gc_work.rs

Lines 449 to 452 in 0babba2

	let new_object = self.trace_object(object);
	if Self::OVERWRITE_REFERENCE {
	unsafe { slot.store(new_object) };
	}

we check a constant OVERWRITE_REFERENCE and write back the reference returned by trace_object(). OVERWRITE_REFERENCE
is defined per ProcessEdgesWork, which is currently per plan. In a copying plan, OVERWRITE_REFERENCE is true, and we always update references.

However, this means there are a few cases where we update references but we do not have to:

• an object is in a non-copying space: e.g. objects in immortal or large object space in a copying plan
• an object is in a copying space but in a particular trace, the policy is not moving objects: e.g. objects in an immix space in a non-defrag GC (non-moving), or objects in the mature immix space in generational immix for a non-defrag GC (nursery is still copying, but objects in mature space is non-moving for that GC).

We may want to check if this introduces any measurable overhead.

There could be different solutions if this brings any overhead:

• Per policy per trace work packet. So OVERWRITE_REFERENCE is defined per policy per trace.
• Check if new_object is the same as object before write. (conditional vs memory write).

[qinsoon]

Alternative solutions:

• Let policy's trace_object() returns whether they copied object or not (e.g. returns Option<ObjectReference>).
• Pass the slot address to policy's trace_object(). If the policy copies objects, they are responsible to update the slot.

[wks]

One way to "let policy's trace_object() returns whether they copied object or not" is mentioned here: #559

Example:

pub struct TraceObjectResult {
    pub is_newly_marked: bool,  // true if the object is newly marked
    pub forwarded: Option<ObjectReference>,  // If an object is forwarded, return Some(newobj), otherwise None.
}

#[inline]
fn process_edge(&mut self, slot: Address) {
    let object = unsafe { slot.load::<ObjectReference>() };
    let TraceObjectResult(newly_marked, forwarded) = self.trace_object(object);
    if newly_marked {
        self.process_node(forwarded.unwrap_or(object));  // enqueue IFF newly marked
    }
    if let Some(new_object) = forwarded {
        unsafe { slot.store(new_object) };  // store IFF forwarded.
    }
}

But it is probably easier to try Option<ObjectReference> alone first to see if there is any impact on performance.

[wks]

As discussed in another issue, the impact is negligible if we return Option<ObjectReference> and update references exactly when the object is actually moved.

#559 (comment)