feat: Deduplicate tagged blobs

rts/motoko-rts/src/gc/incremental/roots/enhanced.rs

@@ -29,6 +29,16 @@ pub unsafe fn visit_roots<C, V: Fn(&mut C, *mut Value)>(
             visit_field(context, location);
         }
     }
+    #[cfg(feature = "ic")]
+    {
+        // Always visit the dedup table as well.
+        // Otherwise the dedup table will be garbage collected.
+        use crate::persistence::get_dedup_table_ptr;
+        let dedup_table = get_dedup_table_ptr();
+        if dedup_table.is_non_null_ptr() {
+            visit_field(context, dedup_table);
+        }
+    }
 }
 
 #[cfg(feature = "ic")]
@@ -67,6 +77,7 @@ pub unsafe fn initialize_static_variables<M: crate::memory::Memory>(mem: &mut M,
     for index in 0..amount {
         array.initialize(index, NULL_POINTER, mem);
     }
+
     let location = addr_of_mut!(STATIC_VARIABLES) as *mut Value;
     write_with_barrier(mem, location, variables);
 }

rts/motoko-rts/src/memory.rs

@@ -113,3 +113,26 @@ pub unsafe fn weak_ref_is_live<M: Memory>(_mem: &mut M, weak_ref: Value) -> bool
     let weak_ref_obj = weak_ref.get_ptr() as *mut WeakRef;
     return (*weak_ref_obj).is_live();
 }
+
+/// Get the dedup table.
+#[enhanced_orthogonal_persistence]
+#[ic_mem_fn]
+#[cfg(feature = "ic")]
+pub unsafe fn get_dedup_table<M: Memory>(_mem: &mut M) -> Value {
+    use crate::persistence::get_dedup_table_ptr;
+    *get_dedup_table_ptr()
+}
+
+/// Set the dedup table.
+#[enhanced_orthogonal_persistence]
+#[ic_mem_fn]
+#[cfg(feature = "ic")]
+pub unsafe fn set_dedup_table<M: Memory>(mem: &mut M, dedup_table: Value) {
+    use crate::persistence::set_dedup_table_ptr;
+    if !dedup_table.is_array() {
+        crate::rts_trap_with(
+            "set_dedup_table: Invalid dedup table pointer. This is a bug, report to the Motoko team.",
+        );
+    }
+    set_dedup_table_ptr(mem, dedup_table);
+}

rts/motoko-rts/src/persistence.rs

@@ -57,6 +57,12 @@ struct PersistentMetadata {
     /// A Value representing a pointer to a MarkStack object
     /// used to collect weak references during the GC marking phase.
     weak_ref_registry: Value,
+    /// Dedup metadata object. The dedup metadata object is an implementation of a hash table
+    /// which works like an array of a fixed size, and for collisions we have a linked list.
+    /// The implementation is done in the Motoko prelude file internals.mo, so it is entirely user-space.
+    /// We keep a pointer to this here so that we can keep if alive across upgrades.
+    /// To keep the dedup table live, we need to add it to roots as well.
+    dedup_table: Value,
 }
 
 /// Location of the persistent metadata. Prereserved and fixed forever.
@@ -105,6 +111,8 @@ impl PersistentMetadata {
         (*self).upgrade_instructions = 0;
         // Initialize the weak reference registry as the null pointer.
         (*self).weak_ref_registry = NULL_POINTER;
+        // Initialize the dedup table as the null pointer.
+        (*self).dedup_table = NULL_POINTER;
     }
 }
 
@@ -122,6 +130,12 @@ pub unsafe fn initialize_memory<M: Memory>() {
             // support. We need to initialize the weak reference registry to NULL_POINTER.
             (*metadata).weak_ref_registry = NULL_POINTER;
         }
+        // Explicit migration from a version of the RTS without dedup table support.
+        if (*metadata).dedup_table.get_raw() == 0 {
+            // This is the first upgrade from a version of the RTS without dedup table support.
+            // We need to initialize the dedup table to NULL_POINTER.
+            (*metadata).dedup_table = NULL_POINTER;
+        }
     } else {
         metadata.initialize::<M>();
     }
@@ -335,3 +349,16 @@ unsafe fn is_weak_ref_registry_null() -> bool {
     // thus marking of previous weak ref object is not needed.
     (*metadata).weak_ref_registry == NULL_POINTER
 }
+
+/// Accessor method for the dedup table.
+pub(crate) unsafe fn get_dedup_table_ptr() -> &'static mut Value {
+    let metadata = PersistentMetadata::get();
+    &mut (*metadata).dedup_table
+}
+
+/// Setter method for the dedup table.
+pub(crate) unsafe fn set_dedup_table_ptr<M: Memory>(mem: &mut M, dedup_table: Value) {
+    let metadata = PersistentMetadata::get();
+    // Use barrier in case the dedup table is set during a GC phase.
+    write_with_barrier(mem, &mut (*metadata).dedup_table, dedup_table);
+}