Include persistent term storage in node/dist refc check

4 files changed, 191 insertions, 1 deletions

diff --git a/erts/emulator/beam/beam_bif_load.c b/erts/emulator/beam/beam_bif_load.c
index bb1b2e5b27..4c8ee5178a 100644
--- a/erts/emulator/beam/beam_bif_load.c
+++ b/erts/emulator/beam/beam_bif_load.c
@@ -1799,6 +1799,78 @@ erts_queue_release_literals(Process* c_p, ErtsLiteralArea* literals)
     }
 }
 
+struct debug_la_oh {
+    void (*func)(ErlOffHeap *, void *);
+    void *arg;
+};
+
+static void debug_later_cleanup_literal_area_off_heap(void *vfap,
+                                                      ErtsThrPrgrVal val,
+                                                      void *vlrlap)
+{
+    struct debug_la_oh *fap = vfap;
+    ErtsLaterReleasLiteralArea *lrlap = vlrlap;
+    ErtsLiteralArea *lap = lrlap->la;
+    if (!erts_debug_have_accessed_literal_area(lap)) {
+        ErlOffHeap oh;
+        ERTS_INIT_OFF_HEAP(&oh);
+        oh.first = lap->off_heap;
+        (*fap->func)(&oh, fap->arg);
+        erts_debug_save_accessed_literal_area(lap);
+    }
+}
+
+static void debug_later_complete_literal_area_switch_off_heap(void *vfap,
+                                                              ErtsThrPrgrVal val,
+                                                              void *vlap)
+{
+    struct debug_la_oh *fap = vfap;
+    ErtsLiteralArea *lap = vlap;
+    if (lap && !erts_debug_have_accessed_literal_area(lap)) {
+        ErlOffHeap oh;
+        ERTS_INIT_OFF_HEAP(&oh);
+        oh.first = lap->off_heap;
+        (*fap->func)(&oh, fap->arg);
+        erts_debug_save_accessed_literal_area(lap);
+    }
+}
+
+
+void
+erts_debug_foreach_release_literal_area_off_heap(void (*func)(ErlOffHeap *, void *), void *arg)
+{
+    ErtsLiteralArea *lap;
+    ErlOffHeap oh;
+    ErtsLiteralAreaRef *ref;
+    struct debug_la_oh fa;
+    erts_mtx_lock(&release_literal_areas.mtx);
+    for (ref = release_literal_areas.first; ref; ref = ref->next) {
+        lap = ref->literal_area;
+        if (!erts_debug_have_accessed_literal_area(lap)) {
+            ERTS_INIT_OFF_HEAP(&oh);
+            oh.first = lap->off_heap;
+            (*func)(&oh, arg);
+            erts_debug_save_accessed_literal_area(lap);
+        }
+    }
+    erts_mtx_unlock(&release_literal_areas.mtx);
+    lap = ERTS_COPY_LITERAL_AREA();
+    if (lap && !erts_debug_have_accessed_literal_area(lap)) {
+        ERTS_INIT_OFF_HEAP(&oh);
+        oh.first = lap->off_heap;
+        (*func)(&oh, arg);
+        erts_debug_save_accessed_literal_area(lap);
+    }
+    fa.func = func;
+    fa.arg = arg;
+    erts_debug_later_op_foreach(later_release_literal_area,
+                                debug_later_cleanup_literal_area_off_heap,
+                                (void *) &fa);
+    erts_debug_later_op_foreach(complete_literal_area_switch,
+                                debug_later_complete_literal_area_switch_off_heap,
+                                (void *) &fa);
+}
+
 /*
  * Move code from current to old and null all export entries for the module
  */
diff --git a/erts/emulator/beam/erl_bif_persistent.c b/erts/emulator/beam/erl_bif_persistent.c
index 5a78a043ce..87f93fec9b 100644
--- a/erts/emulator/beam/erl_bif_persistent.c
+++ b/erts/emulator/beam/erl_bif_persistent.c
@@ -998,3 +998,102 @@ next_to_delete(void)
     erts_mtx_unlock(&delete_queue_mtx);
     return table;
 }
+
+/*
+ * test/debug functionality follow...
+ */
+
+static Uint accessed_literal_areas_size;
+static Uint accessed_no_literal_areas;
+static ErtsLiteralArea **accessed_literal_areas;
+
+int
+erts_debug_have_accessed_literal_area(ErtsLiteralArea *lap)
+{
+    Uint i;
+    for (i = 0; i < accessed_no_literal_areas; i++) {
+        if (accessed_literal_areas[i] == lap)
+            return !0;
+    }
+    return 0;
+}
+
+void
+erts_debug_save_accessed_literal_area(ErtsLiteralArea *lap)
+{
+    if (accessed_no_literal_areas == accessed_literal_areas_size) {
+        accessed_literal_areas_size += 10;
+        accessed_literal_areas = erts_realloc(ERTS_ALC_T_TMP,
+                                              accessed_literal_areas,
+                                              (sizeof(ErtsLiteralArea *)
+                                               *accessed_literal_areas_size));
+    }
+    accessed_literal_areas[accessed_no_literal_areas++] = lap;
+}
+
+static void debug_foreach_off_heap(HashTable *tbl, void (*func)(ErlOffHeap *, void *), void *arg)
+{
+    int i;
+    
+    for (i = 0; i < tbl->allocated; i++) {
+        Eterm term = tbl->term[i];
+        if (is_tuple_arity(term, 2)) {
+            ErtsLiteralArea *lap = term_to_area(term);
+            ErlOffHeap oh;
+            if (!erts_debug_have_accessed_literal_area(lap)) {
+                ERTS_INIT_OFF_HEAP(&oh);
+                oh.first = lap->off_heap;
+                (*func)(&oh, arg);
+                erts_debug_save_accessed_literal_area(lap);
+            }
+        }
+    }
+}
+
+struct debug_la_oh {
+    void (*func)(ErlOffHeap *, void *);
+    void *arg;
+};
+
+static void debug_handle_table(void *vfap,
+                               ErtsThrPrgrVal val,
+                               void *vtbl)
+{
+    struct debug_la_oh *fap = vfap;
+    HashTable *tbl = vtbl;
+    debug_foreach_off_heap(tbl, fap->func, fap->arg);
+}
+
+void
+erts_debug_foreach_persistent_term_off_heap(void (*func)(ErlOffHeap *, void *), void *arg)
+{
+    HashTable *tbl;
+    struct debug_la_oh fa;
+    accessed_no_literal_areas = 0;
+    accessed_literal_areas_size = 10;
+    accessed_literal_areas = erts_alloc(ERTS_ALC_T_TMP,
+                                        (sizeof(ErtsLiteralArea *)
+                                         * accessed_literal_areas_size));
+    
+    tbl = (HashTable *) erts_atomic_read_nob(&the_hash_table);
+    debug_foreach_off_heap(tbl, func, arg);
+    erts_mtx_lock(&delete_queue_mtx);
+    for (tbl = delete_queue_head; tbl; tbl = tbl->delete_next)
+        debug_foreach_off_heap(tbl, func, arg);
+    erts_mtx_unlock(&delete_queue_mtx);
+    fa.func = func;
+    fa.arg = arg;
+    erts_debug_later_op_foreach(table_updater,
+                                debug_handle_table,
+                                (void *) &fa);
+    erts_debug_later_op_foreach(table_deleter,
+                                debug_handle_table,
+                                (void *) &fa);
+    erts_debug_foreach_release_literal_area_off_heap(func, arg);
+    
+    erts_free(ERTS_ALC_T_TMP, accessed_literal_areas);
+    accessed_no_literal_areas = 0;
+    accessed_literal_areas_size = 0;
+    accessed_literal_areas = NULL;
+}
+
diff --git a/erts/emulator/beam/erl_node_tables.c b/erts/emulator/beam/erl_node_tables.c
index 907bacef6d..ef344d8ac3 100644
--- a/erts/emulator/beam/erl_node_tables.c
+++ b/erts/emulator/beam/erl_node_tables.c
@@ -1178,6 +1178,7 @@ static Eterm AM_timer;
 static Eterm AM_delayed_delete_timer;
 static Eterm AM_thread_progress_delete_timer;
 static Eterm AM_signal;
+static Eterm AM_persistent_term;
 
 static void setup_reference_table(void);
 static Eterm reference_table_term(Uint **hpp, ErlOffHeap *ohp, Uint *szp);
@@ -1272,6 +1273,7 @@ erts_get_node_and_dist_references(struct process *proc)
 	INIT_AM(delayed_delete_timer);
         INIT_AM(thread_progress_delete_timer);
 	INIT_AM(signal);
+	INIT_AM(persistent_term);
 	references_atoms_need_init = 0;
     }
 
@@ -1813,6 +1815,14 @@ insert_sig_link(ErtsLink *lnk, void *arg)
 }
 
 static void
+insert_persistent_term(ErlOffHeap *ohp, void *arg)
+{
+    Eterm heap[3];
+    insert_offheap(ohp, SYSTEM_REF,
+                   TUPLE2(&heap[0], AM_system, AM_persistent_term));
+}
+
+static void
 setup_reference_table(void)
 {
     ErlHeapFragment *hfp;
@@ -2008,6 +2018,10 @@ setup_reference_table(void)
     /* Insert all bif timers */
     erts_debug_bif_timer_foreach(insert_bif_timer, NULL);
 
+    /* Insert persistent term storage */
+    erts_debug_foreach_persistent_term_off_heap(insert_persistent_term,
+                                                NULL);
+
     /* Insert node table (references to dist) */
     hash_foreach(&erts_node_table, insert_erl_node, NULL);
 }
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index f564472081..ac0dcef517 100644
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -902,7 +902,8 @@ Eterm erl_is_function(Process* p, Eterm arg1, Eterm arg2);
 /* beam_bif_load.c */
 Eterm erts_check_process_code(Process *c_p, Eterm module, int *redsp, int fcalls);
 Eterm erts_proc_copy_literal_area(Process *c_p, int *redsp, int fcalls, int gc_allowed);
-
+void erts_debug_foreach_release_literal_area_off_heap(void (*func)(ErlOffHeap *, void *),
+                                                      void *arg);
 typedef struct ErtsLiteralArea_ {
     struct erl_off_heap_header *off_heap;
     Eterm *end;
@@ -1251,6 +1252,10 @@ Uint erts_persistent_term_count(void);
 void erts_init_persistent_dumping(void);
 extern ErtsLiteralArea** erts_persistent_areas;
 extern Uint erts_num_persistent_areas;
+void erts_debug_foreach_persistent_term_off_heap(void (*func)(ErlOffHeap *, void *),
+                                                 void *arg);
+int erts_debug_have_accessed_literal_area(ErtsLiteralArea *lap);
+void erts_debug_save_accessed_literal_area(ErtsLiteralArea *lap);
 
 /* external.c */
 void erts_init_external(void);