feat: Deduplicate tagged blobs (#5512)

This PR adds (tagged) blob deduplication support. The main issue it
solves is that all external calls to a motoko canister go through candid
deserialization and blobs passed as arguments end up as fresh blobs on
the motoko heap. Calling multiple times with the same blob as argument
creates multiple copies of the same blob.

To achieve deduplication, this PR does the following:
* in `internals.mo`, it creates a fixed-size hash-table which solves
collisions via chaining.
* sets up a thin RTS interface to set/get the hash-table allocated in
`internals.mo` to be tracked by the RTS layer such that the table is not
garbage collected and it survives upgrades.
* to achieve deduplication, the hash table stores weak references
pointing to the actual objects; once objects are garbage collected, the
weak references will point to null.
* a thin client interface (in `prim.mo`) to walk the hash table and
check which deduplicated blobs are alive/dead and prune the dead ones if
neeed.

Author: alexandru-uta

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);
+}