Consolidate rename src,dst -> staging,active

Author: sverker

erts/emulator/beam/beam_bp.c

@@ -1574,39 +1574,39 @@ static void collect_timem_info(BpTimemTrace* bdt,
 void erts_timem_info_consolidate()
 {
     FinishTimemInfo *fin = &finish_timem_info;
-    GenericBpData *src_bp = &fin->g->data[erts_staging_bp_ix()];
-    GenericBpData *dst_bp = &fin->g->data[erts_active_bp_ix()];
+    GenericBpData *staging = &fin->g->data[erts_staging_bp_ix()];
+    GenericBpData *active = &fin->g->data[erts_active_bp_ix()];
     const Uint32 dirty_thr_ix = (Uint32) erts_no_schedulers;
 
     ERTS_LC_ASSERT(erts_has_code_mod_permission());
-    ASSERT(src_bp->flags == dst_bp->flags);
-    ASSERT(src_bp->flags & (ERTS_BPF_TIME_TRACE_ACTIVE | ERTS_BPF_MEM_TRACE_ACTIVE));
+    ASSERT(staging->flags == active->flags);
+    ASSERT(staging->flags & (ERTS_BPF_TIME_TRACE_ACTIVE | ERTS_BPF_MEM_TRACE_ACTIVE));
 
     /*
-     * We use the *active* hash for dirty schedulers to receive the
+     * We use the active hash for dirty schedulers to receive the
      * accumulations that happenend during the trace_info call. It's safe as
-     * it's lock protected. Another solution would be to have a dedicated
-     * consolidation hash to avoid the locking here.
+     * it's lock protected. Another solution could be to have a dedicated
+     * consolidation hash index to avoid the locking here.
     */
     erts_mtx_lock(&erts_dirty_bp_ix_mtx);
 
     if (fin->break_flags & ERTS_BPF_TIME_TRACE_ACTIVE) {
-        ASSERT(src_bp->flags & ERTS_BPF_TIME_TRACE_ACTIVE);
-        collect_timem_info(src_bp->time,
-                            &(dst_bp->time->threads[dirty_thr_ix]));
+        ASSERT(staging->flags & ERTS_BPF_TIME_TRACE_ACTIVE);
+        collect_timem_info(staging->time,
+                           &(active->time->threads[dirty_thr_ix]));
 
-        bp_calltrace_unref(src_bp->time);
-        src_bp->time = dst_bp->time;
-        erts_refc_inc(&src_bp->time->refc, 2);
+        bp_calltrace_unref(staging->time);
+        staging->time = active->time;
+        erts_refc_inc(&staging->time->refc, 2);
     }
     if (fin->break_flags & ERTS_BPF_MEM_TRACE_ACTIVE) {
-        ASSERT(src_bp->flags & ERTS_BPF_MEM_TRACE_ACTIVE);
-        collect_timem_info(src_bp->memory,
-                            &(dst_bp->memory->threads[dirty_thr_ix]));
+        ASSERT(staging->flags & ERTS_BPF_MEM_TRACE_ACTIVE);
+        collect_timem_info(staging->memory,
+                           &(active->memory->threads[dirty_thr_ix]));
 
-        bp_calltrace_unref(src_bp->memory);
-        src_bp->memory = dst_bp->memory;
-        erts_refc_inc(&src_bp->memory->refc, 2);
+        bp_calltrace_unref(staging->memory);
+        staging->memory = active->memory;
+        erts_refc_inc(&staging->memory->refc, 2);
     }
     erts_mtx_unlock(&erts_dirty_bp_ix_mtx);
 }