From b937b42d2f98c4e0024418dbbd55ff545bcf65d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <psyeugenic@gmail.com>
Date: Sat, 10 Apr 2010 17:27:24 +0200
Subject: Call time breakpoint tracing framework

Initial commit with a new breakpoint instruction and PSD areas
for temporary time storage during tracing.
---
 erts/emulator/beam/beam_bp.c | 94 +++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 93 insertions(+), 1 deletion(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 6278ff6bad..a78645a9c7 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -191,7 +191,12 @@ erts_set_count_break(Eterm mfa[3], int specified, enum erts_break_op count_op) {
 		     (BeamInstr) BeamOp(op_i_count_breakpoint), count_op, NIL);
 }
 
-
+int
+erts_set_time_break(Eterm mfa[3], int specified, enum erts_break_op count_op) {
+    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    return set_break(mfa, specified, NULL,
+		     (BeamInstr) BeamOp(op_i_time_breakpoint), count_op, NIL);
+}
 
 int
 erts_clear_trace_break(Eterm mfa[3], int specified) {
@@ -236,6 +241,13 @@ erts_clear_count_break(Eterm mfa[3], int specified) {
 		       (BeamInstr) BeamOp(op_i_count_breakpoint));
 }
 
+int
+erts_clear_time_break(Eterm mfa[3], int specified) {
+    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    return clear_break(mfa, specified,
+		       (BeamInstr) BeamOp(op_i_time_breakpoint));
+}
+
 int
 erts_clear_break(Eterm mfa[3], int specified) {
     ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
@@ -408,6 +420,31 @@ erts_is_count_break(BeamInstr *pc, Sint *count_ret) {
     return 0;
 }
 
+int
+erts_is_time_break(Uint *pc, Sint *count, Uint *s_time, Uint *us_time) {
+    BpDataTime *bdt =
+	(BpDataTime *) is_break(pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
+    Uint i;
+
+    if (bdt) {
+	if (count && s_time && us_time) {
+	    *count   = 0;
+	    *s_time  = 0;
+	    *us_time = 0;
+	    ErtsSmpBPLock(bdt);
+	    for (i = 0; i < bdt->n; i++) {
+		*count   += bdt->items[i].count;
+		*s_time  += bdt->items[i].s_time;
+		*us_time += bdt->items[i].us_time;
+	    }
+	    ErtsSmpBPUnlock(bdt);
+	}
+	return !0;
+    }
+    return 0;
+}
+
+
 BeamInstr *
 erts_find_local_func(Eterm mfa[3]) {
     Module *modp;
@@ -432,6 +469,22 @@ erts_find_local_func(Eterm mfa[3]) {
     return NULL;
 }
 
+void erts_do_time_break(Process *p, BpDataTime *bdt) {
+     Uint ms,s,u;
+     ErtsSchedulerData *esdp;
+     int ix = 0;
+
+     esdp = erts_get_scheduler_data();
+     ix   = esdp->no - 1;
+
+     get_sys_now(&ms,&s,&u);
+     //ErtsSmpBPLock(bdt);
+     //
+     bdt->items[ix].count++;
+     bdt->items[ix].s_time = 1;
+     bdt->items[ix].us_time = 1;
+     //ErtsSmpBPUnlock(bdt);
+}
 
 
 /* *************************************************************************
@@ -519,6 +572,7 @@ static int set_function_break(Module *modp, BeamInstr *pc,
     if ( (bd = is_break(pc, break_op))) {
 	if (break_op == (BeamInstr) BeamOp(op_i_trace_breakpoint)
 	    || break_op == (BeamInstr) BeamOp(op_i_mtrace_breakpoint)) {
+
 	    BpDataTrace *bdt = (BpDataTrace *) bd;
 	    Binary *old_match_spec;
 	    
@@ -545,6 +599,18 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 		    bdc->count = 0; /* Reset call counter */
 		}
 		ErtsSmpBPUnlock(bdc);
+	    } else if (break_op == (Uint) BeamOp(op_i_count_breakpoint)) {
+		BpDataTime *bdt = (BpDataTime *) bd;
+		Uint i = 0;
+
+		ErtsSmpBPLock(bdt);
+		for (i = 0; i < bdt->n; i++) {
+		    bdt->items[i].count   = 0;
+		    bdt->items[i].s_time  = 0;
+		    bdt->items[i].us_time = 0;
+		}
+		ErtsSmpBPUnlock(bdt);
+
 	    } else {
 		ASSERT (! count_op);
 	    }
@@ -564,6 +630,12 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 		return 1;
 	    }
 	    size = sizeof(BpDataCount);
+	} else if (break_op == (BeamInstr) BeamOp(op_i_time_breakpoint))  {
+	    if (count_op == erts_break_reset || count_op == erts_break_stop) {
+		/* Do not insert a new breakpoint */
+		return 1;
+	    }
+	    size = sizeof(BpDataTime);
 	} else {
 	    ASSERT(! count_op);
 	    ASSERT(break_op == (BeamInstr) BeamOp(op_i_debug_breakpoint));
@@ -576,6 +648,7 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	ASSERT(*pc != (BeamInstr) BeamOp(op_i_mtrace_breakpoint));
 	ASSERT(*pc != (BeamInstr) BeamOp(op_i_debug_breakpoint));
 	ASSERT(*pc != (BeamInstr) BeamOp(op_i_count_breakpoint));
+	ASSERT(*pc != (BeamInstr) BeamOp(op_i_time_breakpoint));
 	/* First breakpoint; create singleton ring */
 	bd = Alloc(size);
 	BpInit(bd, *pc);
@@ -585,6 +658,7 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	ASSERT(*pc == (BeamInstr) BeamOp(op_i_trace_breakpoint) ||
 	       *pc == (BeamInstr) BeamOp(op_i_mtrace_breakpoint) ||
 	       *pc == (BeamInstr) BeamOp(op_i_debug_breakpoint) ||
+	       *pc == (BeamInstr) BeamOp(op_i_time_breakpoint) ||
 	       *pc == (BeamInstr) BeamOp(op_i_count_breakpoint));
 	if (*pc == (BeamInstr) BeamOp(op_i_debug_breakpoint)) {
 	    /* Debug bp must be last, so if it is also first; 
@@ -617,6 +691,18 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	MatchSetRef(match_spec);
 	bdt->match_spec = match_spec;
 	bdt->tracer_pid = tracer_pid;
+    } else if (break_op == (BeamInstr) BeamOp(op_i_time_breakpoint)) {
+	BpDataTime *bdt = (BpDataTime *) bd;
+	Uint i = 0;
+
+	bdt->n     = erts_no_schedulers;
+	bdt->items = Alloc(sizeof(bp_data_time_item_t)*(bdt->n));
+
+	for (i = 0; i < bdt->n; i++) {
+	    bdt->items[i].count   = 0;
+	    bdt->items[i].s_time  = 0;
+	    bdt->items[i].us_time = 0;
+	}
     } else if (break_op == (BeamInstr) BeamOp(op_i_count_breakpoint)) {
 	BpDataCount *bdc = (BpDataCount *) bd;
 
@@ -739,6 +825,12 @@ static int clear_function_break(Module *m, BeamInstr *pc, BeamInstr break_op) {
 
 	    MatchSetUnref(bdt->match_spec);
 	}
+	if (op == (BeamInstr) BeamOp(op_i_time_breakpoint)) {
+	    BpDataTime *bdt = (BpDataTrace *) bd;
+
+	    Free(bdt->items);
+	    bdt->n = 0;
+	}
 	Free(bd);
 	ASSERT(((BeamInstr) code_base[MI_NUM_BREAKPOINTS]) > 0);
 	--(*(BeamInstr*)&code_base[MI_NUM_BREAKPOINTS]);
-- 
cgit v1.2.3


From 78d5145d68783dca4aa43bfd38fb9afecc59c416 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <psyeugenic@gmail.com>
Date: Wed, 21 Apr 2010 15:29:31 +0200
Subject: Add processes hashes for call time breakpoints

Call time breakpoint tracing traces per call trace per process.
- Add hashes to support the extra dimension.
- Teach trace_info/2 to handle the extra information dimension.
---
 erts/emulator/beam/beam_bp.c | 289 +++++++++++++++++++++++++++++++++++++------
 1 file changed, 249 insertions(+), 40 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index a78645a9c7..f264ebfa3f 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -30,6 +30,7 @@
 #include "error.h"
 #include "erl_binary.h"
 #include "beam_bp.h"
+#include "erl_term.h"
 
 /* *************************************************************************
 ** Macros
@@ -127,6 +128,23 @@ static int clear_function_break(Module *modp, BeamInstr *pc,
 
 static BpData *is_break(BeamInstr *pc, BeamInstr break_op);
 
+/* bp_hash */
+#define BP_TIME_ADD(pi0, pi1)             \
+    do {                                  \
+	Uint r; \
+	(pi0)->count   += (pi1)->count;   \
+	(pi0)->s_time  += (pi1)->s_time;  \
+	(pi0)->us_time += (pi1)->us_time; \
+	r = (pi0)->us_time / 1000000;     \
+	(pi0)->s_time  += r;              \
+	(pi0)->us_time  = (pi0)->us_time % 1000000; \
+    } while(0)
+
+static void bp_hash_init(bp_time_hash_t *hash, Uint n);
+static void bp_hash_rehash(bp_time_hash_t *hash, Uint n);
+static ERTS_INLINE bp_data_time_item_t * bp_hash_get(bp_time_hash_t *hash, bp_data_time_item_t *sitem);
+static ERTS_INLINE bp_data_time_item_t * bp_hash_put(bp_time_hash_t *hash, bp_data_time_item_t *sitem);
+static void bp_hash_delete(bp_time_hash_t *hash);
 
 
 /* *************************************************************************
@@ -420,27 +438,58 @@ erts_is_count_break(BeamInstr *pc, Sint *count_ret) {
     return 0;
 }
 
-int
-erts_is_time_break(Uint *pc, Sint *count, Uint *s_time, Uint *us_time) {
-    BpDataTime *bdt =
-	(BpDataTime *) is_break(pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
-    Uint i;
+int erts_is_time_break(Process *p, BeamInstr *pc, Eterm *retval) {
+    BpDataTime *bdt = (BpDataTime *) is_break(pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
+    Uint i, ix;
+    bp_time_hash_t hash;
+    Uint size;
+    Eterm *hp, t;
+    bp_data_time_item_t *item = NULL;
 
     if (bdt) {
-	if (count && s_time && us_time) {
-	    *count   = 0;
-	    *s_time  = 0;
-	    *us_time = 0;
-	    ErtsSmpBPLock(bdt);
+	if (retval) {
+	    /* collect all hashes to one hash */
+	    bp_hash_init(&hash, 64);
+	    /* foreach threadspecific hash */
 	    for (i = 0; i < bdt->n; i++) {
-		*count   += bdt->items[i].count;
-		*s_time  += bdt->items[i].s_time;
-		*us_time += bdt->items[i].us_time;
+		bp_data_time_item_t *sitem;
+
+	        /* foreach hash bucket not NIL*/
+		for(ix = 0; ix < bdt->hash[i].n; ix++) {
+		    item = &(bdt->hash[i].item[ix]);
+		    if (item->pid != NIL) {
+			sitem = bp_hash_get(&hash, item);
+			if (sitem) {
+			    BP_TIME_ADD(sitem, item);
+			} else {
+			    bp_hash_put(&hash, item);
+			}
+		    }
+		}
 	    }
-	    ErtsSmpBPUnlock(bdt);
+
+	    *retval = NIL;
+	    if (hash.used > 0) {
+		size = (5 + 2)*hash.used;
+		hp   = HAlloc(p, size);
+
+		for(ix = 0; ix < hash.n; ix++) {
+		    item = &(hash.item[ix]);
+		    if (item->pid != NIL) {
+			t = TUPLE4(hp, item->pid,
+				make_small(item->count),
+				make_small(item->s_time),
+				make_small(item->us_time));
+			hp += 5;
+			*retval = CONS(hp, t, *retval); hp += 2;
+		    }
+		}
+	    }
+	    bp_hash_delete(&hash);
 	}
 	return !0;
     }
+
     return 0;
 }
 
@@ -469,21 +518,182 @@ erts_find_local_func(Eterm mfa[3]) {
     return NULL;
 }
 
+/* bp_hash */
+
+static void bp_hash_init(bp_time_hash_t *hash, Uint n) {
+    Uint size = sizeof(bp_data_time_item_t)*n;
+    Uint i;
+
+    hash->n    = n;
+    hash->used = 0;
+
+
+    hash->item = (bp_data_time_item_t *)Alloc(size);
+    sys_memzero(hash->item, size);
+
+    for(i = 0; i < n; ++i) {
+	hash->item[i].pid = NIL;
+    }
+}
+
+static void bp_hash_rehash(bp_time_hash_t *hash, Uint n) {
+    bp_data_time_item_t *item = NULL;
+    Uint size = sizeof(bp_data_time_item_t)*n;
+    Uint ix;
+    Uint hval;
+
+    item = (bp_data_time_item_t *)Alloc(size);
+    sys_memzero(item, size);
+
+    for( ix = 0; ix < n; ++ix) {
+	item[ix].pid = NIL;
+    }
+
+    for( ix = 0; ix < hash->n; ix++) {
+	if (hash->item[ix].pid != NIL) {
+
+	    hval = ((hash->item[ix].pid) >> 4) % n; /* new n */
+
+	    while (item[hval].pid != NIL) {
+		hval = (hval + 1) % n;
+	    }
+	    item[hval].pid     = hash->item[ix].pid;
+	    item[hval].count   = hash->item[ix].count;
+	    item[hval].s_time  = hash->item[ix].s_time;
+	    item[hval].us_time = hash->item[ix].us_time;
+	}
+    }
+
+    Free(hash->item);
+    hash->n = n;
+    hash->item = item;
+}
+static ERTS_INLINE bp_data_time_item_t * bp_hash_get(bp_time_hash_t *hash, bp_data_time_item_t *sitem) {
+    Eterm pid = sitem->pid;
+    Uint hval = (pid >> 4) % hash->n;
+    bp_data_time_item_t *item = NULL;
+
+    item = hash->item;
+
+    while (item[hval].pid != pid) {
+	if (item[hval].pid == NIL) return NULL;
+	hval = (hval + 1) % hash->n;
+    }
+
+    return &(item[hval]);
+}
+
+static ERTS_INLINE bp_data_time_item_t * bp_hash_put(bp_time_hash_t *hash, bp_data_time_item_t* sitem) {
+    Uint hval = (sitem->pid >> 4) % hash->n;
+    float r = 0.0;
+    bp_data_time_item_t *item;
+
+    /* make sure that the hash is not saturated */
+    /* if saturated, rehash it */
+
+    r = hash->used / (float) hash->n;
+
+    if (r > 0.7f) {
+	bp_hash_rehash(hash, hash->n * 2);
+    }
+
+    /* find free slot */
+    item = hash->item;
+
+    while (item[hval].pid != NIL) {
+	hval = (hval + 1) % hash->n;
+    }
+    item = &(hash->item[hval]);
+
+    item->pid     = sitem->pid;
+    item->s_time  = sitem->s_time;
+    item->us_time = sitem->us_time;
+    item->count   = sitem->count;
+    hash->used++;
+
+    return item;
+}
+
+static void bp_hash_delete(bp_time_hash_t *hash) {
+    hash->n = 0;
+    hash->used = 0;
+    Free(hash->item);
+    hash->item = NULL;
+}
+
+static void bp_time_diff(bp_data_time_item_t *item, /* out */
+	process_breakpoint_time_t *pbt,             /* in  */
+	Uint ms, Uint s, Uint us) {
+    int dms,ds,dus;
+
+    dms = ms - pbt->ms;
+    ds  = s  - pbt->s;
+    dus = us - pbt->us;
+
+    if (dms > 0) {
+	item->s_time  = (ds + dms * 1000000);
+    } else {
+	item->s_time  = ds;
+    }
+    if ( dus < 0 ) {
+	item->us_time = (dus + 1000000);
+	item->s_time -= 1;
+    } else {
+	item->us_time = dus;
+    }
+}
+
 void erts_do_time_break(Process *p, BpDataTime *bdt) {
-     Uint ms,s,u;
-     ErtsSchedulerData *esdp;
-     int ix = 0;
+    Uint ms,s,us;
+    process_breakpoint_time_t *pbt = NULL;
+    int ix = 0;
 
-     esdp = erts_get_scheduler_data();
-     ix   = esdp->no - 1;
+    /* get previous timestamp and breakpoint
+     * from the process' psd  */
+    pbt = ERTS_PROC_GET_CALL_TIME(p);
+    get_sys_now(&ms,&s,&us);
 
-     get_sys_now(&ms,&s,&u);
-     //ErtsSmpBPLock(bdt);
-     //
-     bdt->items[ix].count++;
-     bdt->items[ix].s_time = 1;
-     bdt->items[ix].us_time = 1;
-     //ErtsSmpBPUnlock(bdt);
+    if (pbt) {
+	bp_data_time_item_t sitem, *item;
+	bp_time_hash_t *h;
+
+#ifdef ERTS_SMP
+	ix  = p->scheduler_data->no - 1;
+#else
+	ix  = 0;
+#endif
+	bp_time_diff(&sitem, pbt, ms, s, us);
+	sitem.pid   = p->id;
+	sitem.count = 1;
+
+	h = &(pbt->bdt->hash[ix]);
+
+	item = bp_hash_get(h, &sitem);
+	if (!item) {
+	    bp_hash_put(h, &sitem);
+	} else {
+	    BP_TIME_ADD(item, &sitem);
+	}
+
+	pbt->bdt = bdt;
+	pbt->ms  = ms;
+	pbt->s   = s;
+	pbt->us  = us;
+
+    } else {
+	pbt = Alloc(sizeof(process_breakpoint_time_t));
+
+	pbt->bdt = bdt;
+	pbt->ms  = ms;
+	pbt->s   = s;
+	pbt->us  = us;
+
+	(void *) ERTS_PROC_SET_CALL_TIME(p, ERTS_PROC_LOCK_MAIN, pbt);
+    }
+
+    /* timestamp start of this call
+     * save ms, s, us, and bdt to the process.
+     */
 }
 
 
@@ -603,13 +813,12 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 		BpDataTime *bdt = (BpDataTime *) bd;
 		Uint i = 0;
 
-		ErtsSmpBPLock(bdt);
+		/*XXX: must block system */
+
 		for (i = 0; i < bdt->n; i++) {
-		    bdt->items[i].count   = 0;
-		    bdt->items[i].s_time  = 0;
-		    bdt->items[i].us_time = 0;
+		    bp_hash_delete(&(bdt->hash[i]));
+		    bp_hash_init(&(bdt->hash[i]), 32);
 		}
-		ErtsSmpBPUnlock(bdt);
 
 	    } else {
 		ASSERT (! count_op);
@@ -695,13 +904,11 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	BpDataTime *bdt = (BpDataTime *) bd;
 	Uint i = 0;
 
-	bdt->n     = erts_no_schedulers;
-	bdt->items = Alloc(sizeof(bp_data_time_item_t)*(bdt->n));
+	bdt->n    = erts_no_schedulers;
+	bdt->hash = Alloc(sizeof(bp_time_hash_t)*(bdt->n));
 
 	for (i = 0; i < bdt->n; i++) {
-	    bdt->items[i].count   = 0;
-	    bdt->items[i].s_time  = 0;
-	    bdt->items[i].us_time = 0;
+	    bp_hash_init(&(bdt->hash[i]), 32);
 	}
     } else if (break_op == (BeamInstr) BeamOp(op_i_count_breakpoint)) {
 	BpDataCount *bdc = (BpDataCount *) bd;
@@ -822,13 +1029,15 @@ static int clear_function_break(Module *m, BeamInstr *pc, BeamInstr break_op) {
 	    op == (BeamInstr) BeamOp(op_i_mtrace_breakpoint)) {
 	    
 	    BpDataTrace *bdt = (BpDataTrace *) bd;
-
 	    MatchSetUnref(bdt->match_spec);
 	}
 	if (op == (BeamInstr) BeamOp(op_i_time_breakpoint)) {
-	    BpDataTime *bdt = (BpDataTrace *) bd;
-
-	    Free(bdt->items);
+	    BpDataTime *bdt = (BpDataTime *) bd;
+	    Uint i = 0;
+	    for( i = 0; i < bdt->n; ++i) {
+		bp_hash_delete(&(bdt->hash[i]));
+	    }
+	    Free(bdt->hash);
 	    bdt->n = 0;
 	}
 	Free(bd);
-- 
cgit v1.2.3


From 35fc33a60608c160f20387840fa6317b09d05d7b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <psyeugenic@gmail.com>
Date: Wed, 21 Apr 2010 16:09:14 +0200
Subject: Fix set_function_break to use correct breakpoint

op_i_time_breakpoint is now used
---
 erts/emulator/beam/beam_bp.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index f264ebfa3f..7c85885fa2 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -129,14 +129,14 @@ static int clear_function_break(Module *modp, BeamInstr *pc,
 static BpData *is_break(BeamInstr *pc, BeamInstr break_op);
 
 /* bp_hash */
-#define BP_TIME_ADD(pi0, pi1)             \
-    do {                                  \
-	Uint r; \
-	(pi0)->count   += (pi1)->count;   \
-	(pi0)->s_time  += (pi1)->s_time;  \
-	(pi0)->us_time += (pi1)->us_time; \
-	r = (pi0)->us_time / 1000000;     \
-	(pi0)->s_time  += r;              \
+#define BP_TIME_ADD(pi0, pi1)                       \
+    do {                                            \
+	Uint r;                                     \
+	(pi0)->count   += (pi1)->count;             \
+	(pi0)->s_time  += (pi1)->s_time;            \
+	(pi0)->us_time += (pi1)->us_time;           \
+	r = (pi0)->us_time / 1000000;               \
+	(pi0)->s_time  += r;                        \
 	(pi0)->us_time  = (pi0)->us_time % 1000000; \
     } while(0)
 
@@ -809,7 +809,7 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 		    bdc->count = 0; /* Reset call counter */
 		}
 		ErtsSmpBPUnlock(bdc);
-	    } else if (break_op == (Uint) BeamOp(op_i_count_breakpoint)) {
+	    } else if (break_op == (Uint) BeamOp(op_i_time_breakpoint)) {
 		BpDataTime *bdt = (BpDataTime *) bd;
 		Uint i = 0;
 
-- 
cgit v1.2.3


From 891682094bf1db038cdf9addffe0b107f40ab6ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <psyeugenic@gmail.com>
Date: Thu, 29 Apr 2010 14:52:18 +0200
Subject: Add return_time trace and PSD deletions

---
 erts/emulator/beam/beam_bp.c | 287 ++++++++++++++++++++++++++++++++++++-------
 1 file changed, 240 insertions(+), 47 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 7c85885fa2..48e7b6675a 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -630,70 +630,233 @@ static void bp_time_diff(bp_data_time_item_t *item, /* out */
     ds  = s  - pbt->s;
     dus = us - pbt->us;
 
-    if (dms > 0) {
-	item->s_time  = (ds + dms * 1000000);
-    } else {
-	item->s_time  = ds;
+    /* get_sys_now may return zero difftime,
+     * this is ok.
+     */
+
+    ASSERT(dms >= 0 || ds >= 0 || dus >= 0);
+
+    if (dus < 0) {
+	dus += 1000000;
+	ds  -= 1;
     }
-    if ( dus < 0 ) {
-	item->us_time = (dus + 1000000);
-	item->s_time -= 1;
-    } else {
-	item->us_time = dus;
+    if (ds < 0) {
+	ds += 1000000;
     }
+
+    item->s_time  = ds;
+    item->us_time = dus;
 }
 
-void erts_do_time_break(Process *p, BpDataTime *bdt) {
+void erts_schedule_time_break(Process *p, Uint schedule) {
+    Uint ms, s, us;
+    process_breakpoint_time_t *pbt = NULL;
+    Uint ix = 0;
+    bp_data_time_item_t sitem, *item = NULL;
+    bp_time_hash_t *h = NULL;
+
+    ASSERT(p);
+
+    pbt = ERTS_PROC_GET_CALL_TIME(p);
+
+    ASSERT( (p->status == P_RUNNING) ||
+	    (p->status == P_WAITING) ||
+	    (p->status == P_RUNABLE));
+
+    if (pbt) {
+	get_sys_now(&ms,&s,&us);
+
+	switch(schedule) {
+	case ERTS_BP_CALL_TIME_SCHEDULE_EXITING :
+	case ERTS_BP_CALL_TIME_SCHEDULE_OUT :
+	    /* When a process is scheduled _out_,
+	     * timestamp it and add its delta to
+	     * the previous breakpoint.
+	     */
+
+#ifdef ERTS_SMP
+	    ix = p->scheduler_data->no - 1;
+#else
+	    ix = 0;
+#endif
+	    bp_time_diff(&sitem, pbt, ms, s, us);
+	    sitem.pid   = p->id;
+	    sitem.count = 1;
+	    /*count is set to 0 if out and 1 if exiting */
+
+	    h = &(pbt->bdt->hash[ix]);
+
+	    ASSERT(h->item);
+
+	    item = bp_hash_get(h, &sitem);
+	    if (!item) {
+		item = bp_hash_put(h, &sitem);
+	    } else {
+		BP_TIME_ADD(item, &sitem);
+	    }
+	    break;
+	case ERTS_BP_CALL_TIME_SCHEDULE_IN :
+	    /* When a process is scheduled _in_,
+	     * timestamp it and remove the previous
+	     * timestamp in the psd.
+	     */
+	    sitem.pid     = p->id;
+	    sitem.count   = -1;
+	    sitem.us_time = 0;
+	    sitem.s_time  = 0;
+
+	    h = &(pbt->bdt->hash[ix]);
+
+	    ASSERT(h->item);
+
+	    item = bp_hash_get(h, &sitem);
+	    if (!item) {
+		item = bp_hash_put(h, &sitem);
+	    } else {
+		BP_TIME_ADD(item, &sitem);
+	    }
+	    pbt->ms = ms;
+	    pbt->s  = s;
+	    pbt->us = us;
+	    break;
+	default :
+	    ASSERT(0);
+		/* will never happen */
+	    break;
+	}
+#ifdef DEBUG
+    } else {
+	/* if pbt is null, then the process has just been spawned
+	 * and status should be runnable.
+	 */
+	ASSERT( (p->status == P_RUNABLE) ||
+		(p->status == P_WAITING));
+#endif
+    } /* pbt */
+}
+
+/* call_time breakpoint
+ * Accumulated times are added to the previous bp,
+ * not the current one. The current one is saved
+ * for future reference.
+ * The previous breakpoint is stored in the process it self, the psd.
+ * We do not need to store in a stack frame.
+ * There is no need for locking, each thread has its own
+ * area in each bp to save data.
+ * Since we need to diffrentiate between processes for each bp,
+ * every bp has a hash (per thread) to process-bp statistics.
+ * - egil
+ */
+
+void erts_do_time_break(Process *p, BpDataTime *bdt, Uint type) {
     Uint ms,s,us;
     process_breakpoint_time_t *pbt = NULL;
     int ix = 0;
+    bp_data_time_item_t sitem, *item = NULL;
+    bp_time_hash_t *h = NULL;
+
+    ASSERT(p);
+    ASSERT(bdt);
+    ASSERT(p->status == P_RUNNING);
 
     /* get previous timestamp and breakpoint
-     * from the process' psd  */
+     * from the process psd  */
+
     pbt = ERTS_PROC_GET_CALL_TIME(p);
     get_sys_now(&ms,&s,&us);
 
-    if (pbt) {
-	bp_data_time_item_t sitem, *item;
-	bp_time_hash_t *h;
+    switch(type) {
+	case ERTS_BP_CALL_TIME_CALL:
+	    /* get pbt
+	     * timestamp = t0
+	     * set ts0 to pbt
+	     * add call count here?
+	     */
+	    if (!pbt) {
+		pbt = Alloc(sizeof(process_breakpoint_time_t));
+		(void *) ERTS_PROC_SET_CALL_TIME(p, ERTS_PROC_LOCK_MAIN, pbt);
+	    }
+
+	    pbt->bdt = bdt; /* needed for schedule? */
+
+	    pbt->ms  = ms;
+	    pbt->s   = s;
+	    pbt->us  = us;
+
+
+	    break;
+	case ERTS_BP_CALL_TIME_TAIL_CALL:
+
+	    ASSERT(pbt);
 
 #ifdef ERTS_SMP
-	ix  = p->scheduler_data->no - 1;
+		ix = p->scheduler_data->no - 1;
 #else
-	ix  = 0;
+		ix = 0;
 #endif
-	bp_time_diff(&sitem, pbt, ms, s, us);
-	sitem.pid   = p->id;
-	sitem.count = 1;
+		bp_time_diff(&sitem, pbt, ms, s, us);
+		sitem.pid   = p->id;
+		sitem.count = 1;
 
-	h = &(pbt->bdt->hash[ix]);
+		h = &(bdt->hash[ix]);
 
-	item = bp_hash_get(h, &sitem);
-	if (!item) {
-	    bp_hash_put(h, &sitem);
-	} else {
-	    BP_TIME_ADD(item, &sitem);
-	}
+		ASSERT(h->item);
 
-	pbt->bdt = bdt;
-	pbt->ms  = ms;
-	pbt->s   = s;
-	pbt->us  = us;
+		item = bp_hash_get(h, &sitem);
+		if (!item) {
+		    item = bp_hash_put(h, &sitem);
+		} else {
+		    BP_TIME_ADD(item, &sitem);
+		}
 
-    } else {
-	pbt = Alloc(sizeof(process_breakpoint_time_t));
 
-	pbt->bdt = bdt;
-	pbt->ms  = ms;
-	pbt->s   = s;
-	pbt->us  = us;
+	    pbt->bdt = bdt; /* needed for schedule? */
 
-	(void *) ERTS_PROC_SET_CALL_TIME(p, ERTS_PROC_LOCK_MAIN, pbt);
-    }
+	    pbt->ms  = ms;
+	    pbt->s   = s;
+	    pbt->us  = us;
+	    break;
 
-    /* timestamp start of this call
-     * save ms, s, us, and bdt to the process.
-     */
+
+	case ERTS_BP_CALL_TIME_RETURN:
+	    /* get pbt
+	     * timestamp = t1
+	     * get ts0 from pbt
+	     * get item from bdt->hash[bp_hash(p->id)]
+	     * ack diff (t1, t0) to item
+	     */
+
+	    if(pbt) {
+		/* might have been removed due to
+		 * trace_pattern(false)
+		 */
+#ifdef ERTS_SMP
+		ix = p->scheduler_data->no - 1;
+#else
+		ix = 0;
+#endif
+		bp_time_diff(&sitem, pbt, ms, s, us);
+		sitem.pid   = p->id;
+		sitem.count = 1;
+
+		h = &(bdt->hash[ix]);
+
+		ASSERT(h->item);
+
+		item = bp_hash_get(h, &sitem);
+		if (!item) {
+		    item = bp_hash_put(h, &sitem);
+		} else {
+		    BP_TIME_ADD(item, &sitem);
+		}
+
+		pbt->bdt = NULL;
+		pbt->ms  = ms;
+		pbt->s   = s;
+		pbt->us  = us;
+	    }
+	    break;
+    }
 }
 
 
@@ -814,10 +977,14 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 		Uint i = 0;
 
 		/*XXX: must block system */
-
-		for (i = 0; i < bdt->n; i++) {
-		    bp_hash_delete(&(bdt->hash[i]));
-		    bp_hash_init(&(bdt->hash[i]), 32);
+		if (count_op == erts_break_stop) {
+		    bdt->pause = 1;
+		} else {
+		    bdt->pause = 0;
+		    for (i = 0; i < bdt->n; i++) {
+			bp_hash_delete(&(bdt->hash[i]));
+			bp_hash_init(&(bdt->hash[i]), 32);
+		    }
 		}
 
 	    } else {
@@ -904,8 +1071,9 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	BpDataTime *bdt = (BpDataTime *) bd;
 	Uint i = 0;
 
-	bdt->n    = erts_no_schedulers;
-	bdt->hash = Alloc(sizeof(bp_time_hash_t)*(bdt->n));
+	bdt->pause = 0;
+	bdt->n     = erts_no_schedulers;
+	bdt->hash  = Alloc(sizeof(bp_time_hash_t)*(bdt->n));
 
 	for (i = 0; i < bdt->n; i++) {
 	    bp_hash_init(&(bdt->hash[i]), 32);
@@ -1034,10 +1202,35 @@ static int clear_function_break(Module *m, BeamInstr *pc, BeamInstr break_op) {
 	if (op == (BeamInstr) BeamOp(op_i_time_breakpoint)) {
 	    BpDataTime *bdt = (BpDataTime *) bd;
 	    Uint i = 0;
+	    Uint j = 0;
+	    Process *h_p = NULL;
+	    bp_data_time_item_t *item = NULL;
+	    process_breakpoint_time_t *pbt = NULL;
+
+	    /* remove all psd associated with the hash
+	     * and then delete the hash.
+	     * ... sigh ...
+	     */
+
 	    for( i = 0; i < bdt->n; ++i) {
+		if (bdt->hash[i].used) {
+		    for (j = 0; j < bdt->hash[i].n; ++j) {
+			item = &(bdt->hash[i].item[j]);
+			if (item->pid != NIL) {
+			    h_p = process_tab[internal_pid_index(item->pid)];
+			    if (h_p) {
+				pbt = ERTS_PROC_SET_CALL_TIME(h_p, ERTS_PROC_LOCK_MAIN, NULL);
+				if (pbt) {
+				    Free(pbt);
+				}
+			    }
+			}
+		    }
+		}
 		bp_hash_delete(&(bdt->hash[i]));
 	    }
 	    Free(bdt->hash);
+	    bdt->hash = NULL;
 	    bdt->n = 0;
 	}
 	Free(bd);
-- 
cgit v1.2.3


From 5bd5aa849475b505a5b0798295511a6a0b4885a4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <psyeugenic@gmail.com>
Date: Fri, 30 Apr 2010 15:03:56 +0200
Subject: Teach call_time trace to use intruction pointers

call_time trace will use instruction pointers instead of
breakpoint data pointers. More costly lookup but the bdt
structure might be deallocated, we do not want that.

Remove unnecessary pattern lock.
---
 erts/emulator/beam/beam_bp.c | 190 +++++++++++++++++++++++--------------------
 1 file changed, 104 insertions(+), 86 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 48e7b6675a..3e776fa951 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -549,6 +549,8 @@ static void bp_hash_rehash(bp_time_hash_t *hash, Uint n) {
 	item[ix].pid = NIL;
     }
 
+    /* rehash, old hash -> new hash */
+
     for( ix = 0; ix < hash->n; ix++) {
 	if (hash->item[ix].pid != NIL) {
 
@@ -654,45 +656,51 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
     Uint ix = 0;
     bp_data_time_item_t sitem, *item = NULL;
     bp_time_hash_t *h = NULL;
+    BpDataTime *pbdt = NULL;
 
     ASSERT(p);
 
     pbt = ERTS_PROC_GET_CALL_TIME(p);
 
+#ifdef ERTS_SMP
+    ix = p->scheduler_data->no - 1;
+#else
+    ix = 0;
+#endif
+/*
     ASSERT( (p->status == P_RUNNING) ||
 	    (p->status == P_WAITING) ||
 	    (p->status == P_RUNABLE));
-
+*/
     if (pbt) {
 	get_sys_now(&ms,&s,&us);
 
 	switch(schedule) {
 	case ERTS_BP_CALL_TIME_SCHEDULE_EXITING :
+	    break;
 	case ERTS_BP_CALL_TIME_SCHEDULE_OUT :
 	    /* When a process is scheduled _out_,
 	     * timestamp it and add its delta to
 	     * the previous breakpoint.
 	     */
 
-#ifdef ERTS_SMP
-	    ix = p->scheduler_data->no - 1;
-#else
-	    ix = 0;
-#endif
-	    bp_time_diff(&sitem, pbt, ms, s, us);
-	    sitem.pid   = p->id;
-	    sitem.count = 1;
-	    /*count is set to 0 if out and 1 if exiting */
+	    pbdt = (BpDataTime *) is_break(pbt->pc, (Uint) BeamOp(op_i_time_breakpoint));
+	    if (pbdt) {
+		bp_time_diff(&sitem, pbt, ms, s, us);
+		sitem.pid   = p->id;
+		sitem.count = 0;
 
-	    h = &(pbt->bdt->hash[ix]);
+		h = &(pbdt->hash[ix]);
 
-	    ASSERT(h->item);
+		ASSERT(h);
+		ASSERT(h->item);
 
-	    item = bp_hash_get(h, &sitem);
-	    if (!item) {
-		item = bp_hash_put(h, &sitem);
-	    } else {
-		BP_TIME_ADD(item, &sitem);
+		item = bp_hash_get(h, &sitem);
+		if (!item) {
+		    item = bp_hash_put(h, &sitem);
+		} else {
+		    BP_TIME_ADD(item, &sitem);
+		}
 	    }
 	    break;
 	case ERTS_BP_CALL_TIME_SCHEDULE_IN :
@@ -700,21 +708,6 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
 	     * timestamp it and remove the previous
 	     * timestamp in the psd.
 	     */
-	    sitem.pid     = p->id;
-	    sitem.count   = -1;
-	    sitem.us_time = 0;
-	    sitem.s_time  = 0;
-
-	    h = &(pbt->bdt->hash[ix]);
-
-	    ASSERT(h->item);
-
-	    item = bp_hash_get(h, &sitem);
-	    if (!item) {
-		item = bp_hash_put(h, &sitem);
-	    } else {
-		BP_TIME_ADD(item, &sitem);
-	    }
 	    pbt->ms = ms;
 	    pbt->s  = s;
 	    pbt->us = us;
@@ -748,15 +741,15 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
  * - egil
  */
 
-void erts_do_time_break(Process *p, BpDataTime *bdt, Uint type) {
+void erts_trace_time_break(Process *p, BeamInstr *pc, BpDataTime *bdt, Uint type) {
     Uint ms,s,us;
     process_breakpoint_time_t *pbt = NULL;
     int ix = 0;
     bp_data_time_item_t sitem, *item = NULL;
     bp_time_hash_t *h = NULL;
+    BpDataTime *pbdt = NULL;
 
     ASSERT(p);
-    ASSERT(bdt);
     ASSERT(p->status == P_RUNNING);
 
     /* get previous timestamp and breakpoint
@@ -765,61 +758,81 @@ void erts_do_time_break(Process *p, BpDataTime *bdt, Uint type) {
     pbt = ERTS_PROC_GET_CALL_TIME(p);
     get_sys_now(&ms,&s,&us);
 
+#ifdef ERTS_SMP
+    ix = p->scheduler_data->no - 1;
+#else
+    ix = 0;
+#endif
+
     switch(type) {
-	case ERTS_BP_CALL_TIME_CALL:
 	    /* get pbt
 	     * timestamp = t0
+	     * lookup bdt from code
 	     * set ts0 to pbt
 	     * add call count here?
 	     */
-	    if (!pbt) {
-		pbt = Alloc(sizeof(process_breakpoint_time_t));
-		(void *) ERTS_PROC_SET_CALL_TIME(p, ERTS_PROC_LOCK_MAIN, pbt);
-	    }
-
-	    pbt->bdt = bdt; /* needed for schedule? */
-
-	    pbt->ms  = ms;
-	    pbt->s   = s;
-	    pbt->us  = us;
-
-
-	    break;
+	case ERTS_BP_CALL_TIME_CALL:
 	case ERTS_BP_CALL_TIME_TAIL_CALL:
 
-	    ASSERT(pbt);
-
-#ifdef ERTS_SMP
-		ix = p->scheduler_data->no - 1;
-#else
-		ix = 0;
-#endif
+	    if (pbt) {
+		ASSERT(pbt->pc);
+		/* add time to previous code */
 		bp_time_diff(&sitem, pbt, ms, s, us);
 		sitem.pid   = p->id;
-		sitem.count = 1;
+		sitem.count = 0;
 
-		h = &(bdt->hash[ix]);
+		/* previous breakpoint */
+		pbdt = (BpDataTime *) is_break(pbt->pc, (Uint) BeamOp(op_i_time_breakpoint));
 
-		ASSERT(h->item);
+		/* if null then the breakpoint was removed */
+		if (pbdt) {
+		    h = &(pbdt->hash[ix]);
 
-		item = bp_hash_get(h, &sitem);
-		if (!item) {
-		    item = bp_hash_put(h, &sitem);
-		} else {
-		    BP_TIME_ADD(item, &sitem);
+		    ASSERT(h);
+		    ASSERT(h->item);
+
+		    item = bp_hash_get(h, &sitem);
+		    if (!item) {
+			item = bp_hash_put(h, &sitem);
+		    } else {
+			BP_TIME_ADD(item, &sitem);
+		    }
 		}
 
+	    } else {
+		/* first call of process to instrumented function */
+		pbt = Alloc(sizeof(process_breakpoint_time_t));
+		(void *) ERTS_PROC_SET_CALL_TIME(p, ERTS_PROC_LOCK_MAIN, pbt);
+	    }
+	    /* add count to this code */
+	    sitem.pid     = p->id;
+	    sitem.count   = 1;
+	    sitem.s_time  = 0;
+	    sitem.us_time = 0;
 
-	    pbt->bdt = bdt; /* needed for schedule? */
+	    /* this breakpoint */
+	    ASSERT(bdt);
+	    h = &(bdt->hash[ix]);
 
-	    pbt->ms  = ms;
-	    pbt->s   = s;
-	    pbt->us  = us;
-	    break;
+	    ASSERT(h);
+	    ASSERT(h->item);
 
+	    item = bp_hash_get(h, &sitem);
+	    if (!item) {
+		item = bp_hash_put(h, &sitem);
+	    } else {
+		BP_TIME_ADD(item, &sitem);
+	    }
+
+	    pbt->pc = pc;
+	    pbt->ms = ms;
+	    pbt->s  = s;
+	    pbt->us = us;
+	    break;
 
 	case ERTS_BP_CALL_TIME_RETURN:
 	    /* get pbt
+	     * lookup bdt from code
 	     * timestamp = t1
 	     * get ts0 from pbt
 	     * get item from bdt->hash[bp_hash(p->id)]
@@ -830,30 +843,34 @@ void erts_do_time_break(Process *p, BpDataTime *bdt, Uint type) {
 		/* might have been removed due to
 		 * trace_pattern(false)
 		 */
-#ifdef ERTS_SMP
-		ix = p->scheduler_data->no - 1;
-#else
-		ix = 0;
-#endif
+		ASSERT(pbt->pc);
+
 		bp_time_diff(&sitem, pbt, ms, s, us);
 		sitem.pid   = p->id;
-		sitem.count = 1;
+		sitem.count = 0;
 
-		h = &(bdt->hash[ix]);
+		/* previous breakpoint */
+		pbdt = (BpDataTime *) is_break(pbt->pc, (Uint) BeamOp(op_i_time_breakpoint));
 
-		ASSERT(h->item);
+		if (pbdt) {
 
-		item = bp_hash_get(h, &sitem);
-		if (!item) {
-		    item = bp_hash_put(h, &sitem);
-		} else {
-		    BP_TIME_ADD(item, &sitem);
+		    h = &(pbdt->hash[ix]);
+
+		    ASSERT(h);
+		    ASSERT(h->item);
+
+		    item = bp_hash_get(h, &sitem);
+		    if (!item) {
+			item = bp_hash_put(h, &sitem);
+		    } else {
+			BP_TIME_ADD(item, &sitem);
+		    }
 		}
 
-		pbt->bdt = NULL;
-		pbt->ms  = ms;
-		pbt->s   = s;
-		pbt->us  = us;
+		pbt->pc = pc;
+		pbt->ms = ms;
+		pbt->s  = s;
+		pbt->us = us;
 	    }
 	    break;
     }
@@ -976,7 +993,8 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 		BpDataTime *bdt = (BpDataTime *) bd;
 		Uint i = 0;
 
-		/*XXX: must block system */
+		ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+
 		if (count_op == erts_break_stop) {
 		    bdt->pause = 1;
 		} else {
-- 
cgit v1.2.3


From 9a5848fc667acb2aedeb39af94d16a9b346aa47e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <psyeugenic@gmail.com>
Date: Thu, 6 May 2010 18:51:34 +0200
Subject: Add search keys in breakpoints and a searchfunction

---
 erts/emulator/beam/beam_bp.c | 29 ++++++++++++++++++++++++++---
 1 file changed, 26 insertions(+), 3 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 3e776fa951..7b46f073c6 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -127,6 +127,7 @@ static int clear_function_break(Module *modp, BeamInstr *pc,
 				BeamInstr break_op);
 
 static BpData *is_break(BeamInstr *pc, BeamInstr break_op);
+static BpData *get_break(BeamInstr *pc, BeamInstr break_op);
 
 /* bp_hash */
 #define BP_TIME_ADD(pi0, pi1)                       \
@@ -684,7 +685,7 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
 	     * the previous breakpoint.
 	     */
 
-	    pbdt = (BpDataTime *) is_break(pbt->pc, (Uint) BeamOp(op_i_time_breakpoint));
+	    pbdt = (BpDataTime *) get_break(pbt->pc, (Uint) BeamOp(op_i_time_breakpoint));
 	    if (pbdt) {
 		bp_time_diff(&sitem, pbt, ms, s, us);
 		sitem.pid   = p->id;
@@ -782,7 +783,7 @@ void erts_trace_time_break(Process *p, BeamInstr *pc, BpDataTime *bdt, Uint type
 		sitem.count = 0;
 
 		/* previous breakpoint */
-		pbdt = (BpDataTime *) is_break(pbt->pc, (Uint) BeamOp(op_i_time_breakpoint));
+		pbdt = (BpDataTime *) get_break(pbt->pc, (Uint) BeamOp(op_i_time_breakpoint));
 
 		/* if null then the breakpoint was removed */
 		if (pbdt) {
@@ -850,7 +851,7 @@ void erts_trace_time_break(Process *p, BeamInstr *pc, BpDataTime *bdt, Uint type
 		sitem.count = 0;
 
 		/* previous breakpoint */
-		pbdt = (BpDataTime *) is_break(pbt->pc, (Uint) BeamOp(op_i_time_breakpoint));
+		pbdt = (BpDataTime *) get_break(pbt->pc, (Uint) BeamOp(op_i_time_breakpoint));
 
 		if (pbdt) {
 
@@ -1076,6 +1077,7 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	    *r = bd;
 	}
     }
+    bd->this_instr = break_op;
     /* Init the bp type specific data */
     if (break_op == (BeamInstr) BeamOp(op_i_trace_breakpoint) ||
 	break_op == (BeamInstr) BeamOp(op_i_mtrace_breakpoint)) {
@@ -1296,3 +1298,24 @@ static BpData *is_break(BeamInstr *pc, BeamInstr break_op) {
     }
     return NULL;
 }
+static BpData *get_break(BeamInstr *pc, BeamInstr break_op) {
+    ASSERT(pc[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
+    if (! erts_is_native_break(pc)) {
+	BpData *bd = (BpData *) pc[-4];
+
+	if (! bd){
+	    return NULL;
+	}
+
+	bd = bd->next;
+	while (bd != (BpData *) pc[-4]) {
+	    ASSERT(bd);
+	    if (bd->this_instr == break_op) {
+		ASSERT(bd);
+		return bd;
+	    }
+	    bd = bd->next;
+	}
+    }
+    return NULL;
+}
-- 
cgit v1.2.3


From ff9531eb5e6aaa5a4802db0db5e0e850f4233702 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <psyeugenic@gmail.com>
Date: Thu, 6 May 2010 20:18:21 +0200
Subject: Add a scheduler array for BpData at BeamInstr[-4]

To solve the issue of multiple schedulers constantly updating the
head pointer to the bp data wheel, each scheduler now has its own
entrypoint to the wheel. This head pointer can be updated without
a locking being taken. Previously there were no lock ...
---
 erts/emulator/beam/beam_bp.c | 150 +++++++++++++++++++++++++++----------------
 1 file changed, 95 insertions(+), 55 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 7b46f073c6..79d150c9e2 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -101,6 +101,9 @@ do {                               \
     (b)->prev = (a);               \
 } while (0)
 
+
+
+
 /* *************************************************************************
 ** Local prototypes
 */
@@ -127,7 +130,7 @@ static int clear_function_break(Module *modp, BeamInstr *pc,
 				BeamInstr break_op);
 
 static BpData *is_break(BeamInstr *pc, BeamInstr break_op);
-static BpData *get_break(BeamInstr *pc, BeamInstr break_op);
+static BpData *get_break(Process *p, BeamInstr *pc, BeamInstr break_op);
 
 /* bp_hash */
 #define BP_TIME_ADD(pi0, pi1)                       \
@@ -296,9 +299,12 @@ BeamInstr
 erts_trace_break(Process *p, BeamInstr *pc, Eterm *args,
 		 Uint32 *ret_flags, Eterm *tracer_pid) {
     Eterm tpid1, tpid2;
-    BpDataTrace *bdt = (BpDataTrace *) pc[-4];
+    BpData **bds = (BpData **) (pc)[-4];
+    BpDataTrace *bdt = NULL;
 
+    ASSERT(bds);
     ASSERT(pc[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
+    bdt = (BpDataTrace *) bds[bp_sched2ix_proc(p)];
     ASSERT(bdt);
     bdt = (BpDataTrace *) bdt->next;
     ASSERT(bdt);
@@ -317,7 +323,7 @@ erts_trace_break(Process *p, BeamInstr *pc, Eterm *args,
 	bdt->tracer_pid = tpid2;
 	ErtsSmpBPUnlock(bdt);
     }
-    pc[-4] = (BeamInstr) bdt;
+    bds[bp_sched2ix_proc(p)] = (BpData *) bdt;
     return bdt->orig_instr;
 }
 
@@ -329,12 +335,15 @@ erts_trace_break(Process *p, BeamInstr *pc, Eterm *args,
 Uint32
 erts_bif_mtrace(Process *p, BeamInstr *pc, Eterm *args, int local,
 		Eterm *tracer_pid) {
-    BpDataTrace *bdt = (BpDataTrace *) pc[-4];
+    BpData **bds = (BpData **) (pc)[-4];
+    BpDataTrace *bdt = NULL;
+
 
     ASSERT(tracer_pid);
-    if (bdt) {
+    if (bds) {
 	Eterm tpid1, tpid2;
 	Uint32 flags;
+	bdt = (BpDataTrace *)bds[bp_sched2ix_proc(p)];
 
 	ErtsSmpBPLock(bdt);
 	tpid1 = tpid2 = bdt->tracer_pid;
@@ -520,7 +529,15 @@ erts_find_local_func(Eterm mfa[3]) {
 }
 
 /* bp_hash */
-
+ERTS_INLINE Uint bp_sched2ix() {
+#ifdef ERTS_SMP
+    ErtsSchedulerData *esdp;
+    esdp = erts_get_scheduler_data();
+    return esdp->no - 1;
+#else
+    return 0;
+#endif
+}
 static void bp_hash_init(bp_time_hash_t *hash, Uint n) {
     Uint size = sizeof(bp_data_time_item_t)*n;
     Uint i;
@@ -528,7 +545,6 @@ static void bp_hash_init(bp_time_hash_t *hash, Uint n) {
     hash->n    = n;
     hash->used = 0;
 
-
     hash->item = (bp_data_time_item_t *)Alloc(size);
     sys_memzero(hash->item, size);
 
@@ -654,7 +670,6 @@ static void bp_time_diff(bp_data_time_item_t *item, /* out */
 void erts_schedule_time_break(Process *p, Uint schedule) {
     Uint ms, s, us;
     process_breakpoint_time_t *pbt = NULL;
-    Uint ix = 0;
     bp_data_time_item_t sitem, *item = NULL;
     bp_time_hash_t *h = NULL;
     BpDataTime *pbdt = NULL;
@@ -663,18 +678,7 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
 
     pbt = ERTS_PROC_GET_CALL_TIME(p);
 
-#ifdef ERTS_SMP
-    ix = p->scheduler_data->no - 1;
-#else
-    ix = 0;
-#endif
-/*
-    ASSERT( (p->status == P_RUNNING) ||
-	    (p->status == P_WAITING) ||
-	    (p->status == P_RUNABLE));
-*/
     if (pbt) {
-	get_sys_now(&ms,&s,&us);
 
 	switch(schedule) {
 	case ERTS_BP_CALL_TIME_SCHEDULE_EXITING :
@@ -685,13 +689,14 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
 	     * the previous breakpoint.
 	     */
 
-	    pbdt = (BpDataTime *) get_break(pbt->pc, (Uint) BeamOp(op_i_time_breakpoint));
+	    pbdt = (BpDataTime *) get_break(p, pbt->pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
 	    if (pbdt) {
+		get_sys_now(&ms,&s,&us);
 		bp_time_diff(&sitem, pbt, ms, s, us);
 		sitem.pid   = p->id;
 		sitem.count = 0;
 
-		h = &(pbdt->hash[ix]);
+		h = &(pbdt->hash[bp_sched2ix_proc(p)]);
 
 		ASSERT(h);
 		ASSERT(h->item);
@@ -709,6 +714,7 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
 	     * timestamp it and remove the previous
 	     * timestamp in the psd.
 	     */
+	    get_sys_now(&ms,&s,&us);
 	    pbt->ms = ms;
 	    pbt->s  = s;
 	    pbt->us = us;
@@ -718,14 +724,6 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
 		/* will never happen */
 	    break;
 	}
-#ifdef DEBUG
-    } else {
-	/* if pbt is null, then the process has just been spawned
-	 * and status should be runnable.
-	 */
-	ASSERT( (p->status == P_RUNABLE) ||
-		(p->status == P_WAITING));
-#endif
     } /* pbt */
 }
 
@@ -745,7 +743,6 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
 void erts_trace_time_break(Process *p, BeamInstr *pc, BpDataTime *bdt, Uint type) {
     Uint ms,s,us;
     process_breakpoint_time_t *pbt = NULL;
-    int ix = 0;
     bp_data_time_item_t sitem, *item = NULL;
     bp_time_hash_t *h = NULL;
     BpDataTime *pbdt = NULL;
@@ -759,12 +756,6 @@ void erts_trace_time_break(Process *p, BeamInstr *pc, BpDataTime *bdt, Uint type
     pbt = ERTS_PROC_GET_CALL_TIME(p);
     get_sys_now(&ms,&s,&us);
 
-#ifdef ERTS_SMP
-    ix = p->scheduler_data->no - 1;
-#else
-    ix = 0;
-#endif
-
     switch(type) {
 	    /* get pbt
 	     * timestamp = t0
@@ -783,11 +774,11 @@ void erts_trace_time_break(Process *p, BeamInstr *pc, BpDataTime *bdt, Uint type
 		sitem.count = 0;
 
 		/* previous breakpoint */
-		pbdt = (BpDataTime *) get_break(pbt->pc, (Uint) BeamOp(op_i_time_breakpoint));
+		pbdt = (BpDataTime *) get_break(p, pbt->pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
 
 		/* if null then the breakpoint was removed */
 		if (pbdt) {
-		    h = &(pbdt->hash[ix]);
+		    h = &(pbdt->hash[bp_sched2ix_proc(p)]);
 
 		    ASSERT(h);
 		    ASSERT(h->item);
@@ -813,7 +804,7 @@ void erts_trace_time_break(Process *p, BeamInstr *pc, BpDataTime *bdt, Uint type
 
 	    /* this breakpoint */
 	    ASSERT(bdt);
-	    h = &(bdt->hash[ix]);
+	    h = &(bdt->hash[bp_sched2ix_proc(p)]);
 
 	    ASSERT(h);
 	    ASSERT(h->item);
@@ -851,11 +842,11 @@ void erts_trace_time_break(Process *p, BeamInstr *pc, BpDataTime *bdt, Uint type
 		sitem.count = 0;
 
 		/* previous breakpoint */
-		pbdt = (BpDataTime *) get_break(pbt->pc, (Uint) BeamOp(op_i_time_breakpoint));
+		pbdt = (BpDataTime *) get_break(p, pbt->pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
 
+		/* beware, the trace_pattern might have been removed */
 		if (pbdt) {
-
-		    h = &(pbdt->hash[ix]);
+		    h = &(pbdt->hash[bp_sched2ix_proc(p)]);
 
 		    ASSERT(h);
 		    ASSERT(h->item);
@@ -874,6 +865,10 @@ void erts_trace_time_break(Process *p, BeamInstr *pc, BpDataTime *bdt, Uint type
 		pbt->us = us;
 	    }
 	    break;
+	default :
+	    ASSERT(0);
+		/* will never happen */
+	    break;
     }
 }
 
@@ -946,8 +941,9 @@ static int set_module_break(Module *modp, Eterm mfa[3], int specified,
 static int set_function_break(Module *modp, BeamInstr *pc,
 			      Binary *match_spec, BeamInstr break_op,
 			      enum erts_break_op count_op, Eterm tracer_pid) {
-    BpData *bd, **r;
+    BpData *bd, **r, ***rs;
     size_t size;
+    Uint ix = 0;
     BeamInstr **code_base = (BeamInstr **)modp->code;
     
     ASSERT(code_base);
@@ -1037,7 +1033,15 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	    size = sizeof(BpDataDebug);
 	}
     }
-    r = (BpData **) (pc-4);
+    rs = (BpData ***) (pc-4);
+    if (! *rs) {
+	size_t ssize = sizeof(BeamInstr) * erts_no_schedulers;
+	*rs = (BpData **) Alloc(ssize);
+	sys_memzero(*rs, ssize);
+    }
+
+    r = &((*rs)[0]);
+
     if (! *r) {
 	ASSERT(*pc != (BeamInstr) BeamOp(op_i_trace_breakpoint));
 	ASSERT(*pc != (BeamInstr) BeamOp(op_i_mtrace_breakpoint));
@@ -1058,12 +1062,12 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	if (*pc == (BeamInstr) BeamOp(op_i_debug_breakpoint)) {
 	    /* Debug bp must be last, so if it is also first; 
 	     * it must be singleton. */
-	    ASSERT(BpSingleton(*r)); 
+	    ASSERT(BpSingleton(*r));
 	    /* Insert new bp first in the ring, i.e second to last. */
 	    bd = Alloc(size);
 	    BpInitAndSpliceNext(bd, *pc, *r);
 	    *pc = break_op;
-	} else if ((*r)->prev->orig_instr 
+	} else if ((*r)->prev->orig_instr
 		   == (BeamInstr) BeamOp(op_i_debug_breakpoint)) {
 	    /* Debug bp last in the ring; insert new second to last. */
 	    bd = Alloc(size);
@@ -1077,6 +1081,10 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	    *r = bd;
 	}
     }
+    for (ix = 1; ix < erts_no_schedulers; ++ix) {
+	(*rs)[ix] = (*rs)[0];
+    }
+
     bd->this_instr = break_op;
     /* Init the bp type specific data */
     if (break_op == (BeamInstr) BeamOp(op_i_trace_breakpoint) ||
@@ -1161,6 +1169,7 @@ static int clear_module_break(Module *m, Eterm mfa[3], int specified,
 
 static int clear_function_break(Module *m, BeamInstr *pc, BeamInstr break_op) {
     BpData *bd;
+    Uint ix = 0;
     BeamInstr **code_base = (BeamInstr **)m->code;
     
     ASSERT(code_base);
@@ -1178,8 +1187,17 @@ static int clear_function_break(Module *m, BeamInstr *pc, BeamInstr break_op) {
 	 * but break_op may be 0 which matches any type. 
 	 */
 	BeamInstr op;
-	BpData **r = (BpData **) (pc-4);
+	BpData ***rs = (BpData ***) (pc - 4);
+	BpData   **r = NULL;
+
+#ifdef DEBUG
+	for (ix = 1; ix < erts_no_schedulers; ++ix) {
+	    ASSERT((*rs)[ix] == (*rs)[0]);
+	}
+#endif
 	
+	r = &((*rs)[0]);
+
 	ASSERT(*r);
 	/* Find opcode for this breakpoint */
 	if (break_op) {
@@ -1195,8 +1213,9 @@ static int clear_function_break(Module *m, BeamInstr *pc, BeamInstr break_op) {
 	if (BpSingleton(bd)) {
 	    ASSERT(*r == bd);
 	    /* Only one breakpoint to remove */
-	    *r  = NULL;
 	    *pc = bd->orig_instr;
+	    Free(*rs);
+	    *rs = NULL;
 	} else {
 	    BpData *bd_prev = bd->prev;
 	    
@@ -1256,7 +1275,12 @@ static int clear_function_break(Module *m, BeamInstr *pc, BeamInstr break_op) {
 	Free(bd);
 	ASSERT(((BeamInstr) code_base[MI_NUM_BREAKPOINTS]) > 0);
 	--(*(BeamInstr*)&code_base[MI_NUM_BREAKPOINTS]);
-    }
+	if (*rs) {
+	    for (ix = 1; ix < erts_no_schedulers; ++ix) {
+		(*rs)[ix] = (*rs)[0];
+	    }
+	}
+    } /* while bd != NULL */
     return 1;
 }
 
@@ -1272,7 +1296,16 @@ static int clear_function_break(Module *m, BeamInstr *pc, BeamInstr break_op) {
 static BpData *is_break(BeamInstr *pc, BeamInstr break_op) {
     ASSERT(pc[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
     if (! erts_is_native_break(pc)) {
-	BpData *bd = (BpData *) pc[-4];
+	BpData **rs = (BpData **) pc[-4];
+	BpData  *bd = NULL, *ebd = NULL;
+
+	if (! rs) {
+	    return NULL;
+	}
+
+	bd = ebd = rs[bp_sched2ix()];
+
+	ASSERT(bd);
 	
 	if (break_op == 0) {
 	    return bd;
@@ -1285,7 +1318,7 @@ static BpData *is_break(BeamInstr *pc, BeamInstr break_op) {
 	    return NULL;
 	}
 	bd = bd->next;
-	while (bd != (BpData *) pc[-4]) {
+	while (bd != ebd) {
 	    ASSERT(bd);
 	    if (bd->orig_instr == break_op) {
 		bd = bd->next;
@@ -1298,17 +1331,24 @@ static BpData *is_break(BeamInstr *pc, BeamInstr break_op) {
     }
     return NULL;
 }
-static BpData *get_break(BeamInstr *pc, BeamInstr break_op) {
+static BpData *get_break(Process *p, BeamInstr *pc, BeamInstr break_op) {
     ASSERT(pc[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
     if (! erts_is_native_break(pc)) {
-	BpData *bd = (BpData *) pc[-4];
+	BpData **rs = (BpData **) pc[-4];
+	BpData  *bd = NULL, *ebd = NULL;
 
-	if (! bd){
+	if (! rs) {
 	    return NULL;
 	}
 
+	bd = ebd = rs[bp_sched2ix_proc(p)];
+	ASSERT(bd);
+	if (bd->this_instr == break_op) {
+	    return bd;
+	}
+
 	bd = bd->next;
-	while (bd != (BpData *) pc[-4]) {
+	while (bd != ebd) {
 	    ASSERT(bd);
 	    if (bd->this_instr == break_op) {
 		ASSERT(bd);
-- 
cgit v1.2.3


From 96a6c45d081e41dbe2d44a8d07d78b46d0e9f587 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <psyeugenic@gmail.com>
Date: Tue, 11 May 2010 20:14:09 +0200
Subject: Teach call count tracing to use atomics

Call count previously used a global lock for accessing and writing
its counter in the breakpoint. This is now changed to atomics instead.

The change will let call count tracing and cprof to scale better
when increasing the number of schedulers.
---
 erts/emulator/beam/beam_bp.c | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 79d150c9e2..424e3324f9 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -439,9 +439,7 @@ erts_is_count_break(BeamInstr *pc, Sint *count_ret) {
     
     if (bdc) {
 	if (count_ret) {
-	    ErtsSmpBPLock(bdc);
-	    *count_ret = bdc->count;
-	    ErtsSmpBPUnlock(bdc);
+	    *count_ret = (Sint) erts_smp_atomic_read(&bdc->acount);
 	}
 	return !0;
     }
@@ -976,16 +974,23 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	    ASSERT(is_nil(tracer_pid));
 	    if (break_op == (BeamInstr) BeamOp(op_i_count_breakpoint)) {
 		BpDataCount *bdc = (BpDataCount *) bd;
+		long count = 0;
+		long res   = 0;
 		
-		ErtsSmpBPLock(bdc);
 		if (count_op == erts_break_stop) {
-		    if (bdc->count >= 0) {
-			bdc->count = -bdc->count-1; /* Stop call counter */
+		    count = erts_smp_atomic_read(&bdc->acount);
+		    if (count >= 0) {
+			while(1) {
+			    res = erts_smp_atomic_cmpxchg(&bdc->acount, -count - 1, count);
+			    if ((res == count) || count < 0) break;
+			    count = res;
+			}
 		    }
 		} else {
-		    bdc->count = 0; /* Reset call counter */
+		    /* Reset call counter */
+		    erts_smp_atomic_set(&bdc->acount, 0);
 		}
-		ErtsSmpBPUnlock(bdc);
+
 	    } else if (break_op == (Uint) BeamOp(op_i_time_breakpoint)) {
 		BpDataTime *bdt = (BpDataTime *) bd;
 		Uint i = 0;
@@ -1015,8 +1020,7 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	ASSERT(! match_spec);
 	ASSERT(is_nil(tracer_pid));
 	if (break_op == (BeamInstr) BeamOp(op_i_count_breakpoint)) {
-	    if (count_op == erts_break_reset
-		|| count_op == erts_break_stop) {
+	    if (count_op == erts_break_reset || count_op == erts_break_stop) {
 		/* Do not insert a new breakpoint */
 		return 1;
 	    }
@@ -1108,8 +1112,7 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	}
     } else if (break_op == (BeamInstr) BeamOp(op_i_count_breakpoint)) {
 	BpDataCount *bdc = (BpDataCount *) bd;
-
-	bdc->count = 0;
+	erts_smp_atomic_init(&bdc->acount, 0);
     }
     ++(*(BeamInstr*)&code_base[MI_NUM_BREAKPOINTS]);
     return 1;
-- 
cgit v1.2.3


From b2369c68b33344eb44544c0892cffb8acc658ffa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <psyeugenic@gmail.com>
Date: Tue, 25 May 2010 14:17:07 +0200
Subject: Teach call time trace patterns to include bifs

---
 erts/emulator/beam/beam_bp.c | 209 +++++++++++++++++++++----------------------
 1 file changed, 101 insertions(+), 108 deletions(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 424e3324f9..9004c74f51 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -102,6 +102,8 @@ do {                               \
 } while (0)
 
 
+#define BREAK_IS_BIF (1)
+#define BREAK_IS_ERL (0)
 
 
 /* *************************************************************************
@@ -118,7 +120,7 @@ static int set_break(Eterm mfa[3], int specified,
 static int set_module_break(Module *modp, Eterm mfa[3], int specified,
 			    Binary *match_spec, BeamInstr break_op,
 			    enum erts_break_op count_op, Eterm tracer_pid);
-static int set_function_break(Module *modp, BeamInstr *pc,
+static int set_function_break(Module *modp, BeamInstr *pc, int bif,
 			      Binary *match_spec, BeamInstr break_op,
 			      enum erts_break_op count_op, Eterm tracer_pid); 
 
@@ -126,7 +128,7 @@ static int clear_break(Eterm mfa[3], int specified,
 		       BeamInstr break_op);
 static int clear_module_break(Module *modp, Eterm mfa[3], int specified, 
 			      BeamInstr break_op);
-static int clear_function_break(Module *modp, BeamInstr *pc,
+static int clear_function_break(Module *modp, BeamInstr *pc, int bif,
 				BeamInstr break_op);
 
 static BpData *is_break(BeamInstr *pc, BeamInstr break_op);
@@ -178,25 +180,20 @@ erts_set_mtrace_break(Eterm mfa[3], int specified, Binary *match_spec,
 		     (BeamInstr) BeamOp(op_i_mtrace_breakpoint), 0, tracer_pid);
 }
 
+/* set breakpoint data for on exported bif entry */
+
 void
 erts_set_mtrace_bif(BeamInstr *pc, Binary *match_spec, Eterm tracer_pid) {
-    BpDataTrace *bdt;
     ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    set_function_break(NULL, pc, BREAK_IS_BIF, match_spec, (BeamInstr) BeamOp(op_i_mtrace_breakpoint), 0, tracer_pid);
+}
 
-    bdt = (BpDataTrace *) pc[-4];
-    if (bdt) {
-	MatchSetUnref(bdt->match_spec);
-	MatchSetRef(match_spec);
-	bdt->match_spec = match_spec;
-	bdt->tracer_pid = tracer_pid;
-    } else {
-	bdt = Alloc(sizeof(BpDataTrace));
-	BpInit((BpData *) bdt, 0);
-	MatchSetRef(match_spec);
-	bdt->match_spec = match_spec;
-	bdt->tracer_pid = tracer_pid;
-	pc[-4] = (BeamInstr) bdt;
-    }
+void erts_set_time_trace_bif(BeamInstr *pc, enum erts_break_op count_op) {
+    set_function_break(NULL, pc, BREAK_IS_BIF, NULL, (BeamInstr) BeamOp(op_i_time_breakpoint), count_op, NIL);
+}
+
+void erts_clear_time_trace_bif(BeamInstr *pc) {
+    clear_function_break(NULL, pc, BREAK_IS_BIF, (BeamInstr) BeamOp(op_i_time_breakpoint));
 }
 
 int 
@@ -236,17 +233,7 @@ erts_clear_mtrace_break(Eterm mfa[3], int specified) {
 
 void
 erts_clear_mtrace_bif(BeamInstr *pc) {
-    BpDataTrace *bdt;
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
-    
-    bdt = (BpDataTrace *) pc[-4];
-    if (bdt) {
-	if (bdt->match_spec) {
-	    MatchSetUnref(bdt->match_spec);
-	}
-	Free(bdt);
-    }
-    pc[-4] = (BeamInstr) NULL;
+    clear_function_break(NULL, pc, BREAK_IS_BIF, (BeamInstr) BeamOp(op_i_mtrace_breakpoint));
 }
 
 int
@@ -287,7 +274,7 @@ int
 erts_clear_function_break(Module *modp, BeamInstr *pc) {
     ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
     ASSERT(modp);
-    return clear_function_break(modp, pc, 0);
+    return clear_function_break(modp, pc, BREAK_IS_ERL, 0);
 }
 
 
@@ -403,24 +390,6 @@ erts_is_mtrace_break(BeamInstr *pc, Binary **match_spec_ret, Eterm *tracer_pid_r
     return 0;
 }
 
-int
-erts_is_mtrace_bif(BeamInstr *pc, Binary **match_spec_ret, Eterm *tracer_pid_ret) {
-    BpDataTrace *bdt = (BpDataTrace *) pc[-4];
-    
-    if (bdt) {
-	if (match_spec_ret) {
-	    *match_spec_ret = bdt->match_spec;
-	}
-	if (tracer_pid_ret) {
-	    ErtsSmpBPLock(bdt);
-	    *tracer_pid_ret = bdt->tracer_pid;
-	    ErtsSmpBPUnlock(bdt);
-	}
-	return !0;
-    }
-    return 0;
-}
-
 int
 erts_is_native_break(BeamInstr *pc) {
 #ifdef HIPE
@@ -447,12 +416,12 @@ erts_is_count_break(BeamInstr *pc, Sint *count_ret) {
 }
 
 int erts_is_time_break(Process *p, BeamInstr *pc, Eterm *retval) {
-    BpDataTime *bdt = (BpDataTime *) is_break(pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
     Uint i, ix;
     bp_time_hash_t hash;
     Uint size;
     Eterm *hp, t;
     bp_data_time_item_t *item = NULL;
+    BpDataTime *bdt = (BpDataTime *) is_break(pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
 
     if (bdt) {
 	if (retval) {
@@ -475,8 +444,8 @@ int erts_is_time_break(Process *p, BeamInstr *pc, Eterm *retval) {
 		    }
 		}
 	    }
+	    /* *retval should be NIL or term from previous bif in export entry */
 
-	    *retval = NIL;
 	    if (hash.used > 0) {
 		size = (5 + 2)*hash.used;
 		hp   = HAlloc(p, size);
@@ -926,27 +895,35 @@ static int set_module_break(Module *modp, Eterm mfa[3], int specified,
 	ASSERT(code_ptr[0] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
 	if ((specified < 2 || mfa[1] == ((Eterm) code_ptr[3])) &&
 	    (specified < 3 || ((int) mfa[2]) == ((int) code_ptr[4]))) {
-	    BeamInstr   *pc = code_ptr+5;
+	    BeamInstr *pc = code_ptr+5;
 	    
 	    num_processed +=
-		set_function_break(modp, pc, match_spec, 
+		set_function_break(modp, pc, BREAK_IS_ERL, match_spec,
 				   break_op, count_op, tracer_pid);
 	}
     }
     return num_processed;
 }
 
-static int set_function_break(Module *modp, BeamInstr *pc,
+static int set_function_break(Module *modp, BeamInstr *pc, int bif,
 			      Binary *match_spec, BeamInstr break_op,
 			      enum erts_break_op count_op, Eterm tracer_pid) {
+
+    BeamInstr **code_base = NULL;
     BpData *bd, **r, ***rs;
     size_t size;
     Uint ix = 0;
-    BeamInstr **code_base = (BeamInstr **)modp->code;
     
-    ASSERT(code_base);
-    ASSERT(code_base <= (BeamInstr **)pc);
-    ASSERT((BeamInstr **)pc < code_base + (modp->code_length/sizeof(BeamInstr *)));
+    if (bif == BREAK_IS_ERL) {
+	code_base = (BeamInstr **)modp->code;
+	ASSERT(code_base);
+	ASSERT(code_base <= (BeamInstr **)pc);
+	ASSERT((BeamInstr **)pc < code_base + (modp->code_length/sizeof(BeamInstr *)));
+    } else {
+	ASSERT(*pc == (BeamInstr) em_apply_bif);
+	ASSERT(modp == NULL);
+    }
+
     /*
      * Currently no trace support for native code.
      */
@@ -970,13 +947,14 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	    ErtsSmpBPUnlock(bdt);
 	    MatchSetUnref(old_match_spec);
 	} else {
+	    BpDataCount *bdc = (BpDataCount *) bd;
+	    long count = 0;
+	    long res   = 0;
+
 	    ASSERT(! match_spec);
 	    ASSERT(is_nil(tracer_pid));
-	    if (break_op == (BeamInstr) BeamOp(op_i_count_breakpoint)) {
-		BpDataCount *bdc = (BpDataCount *) bd;
-		long count = 0;
-		long res   = 0;
 		
+	    if (break_op == (BeamInstr) BeamOp(op_i_count_breakpoint)) {
 		if (count_op == erts_break_stop) {
 		    count = erts_smp_atomic_read(&bdc->acount);
 		    if (count >= 0) {
@@ -991,7 +969,7 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 		    erts_smp_atomic_set(&bdc->acount, 0);
 		}
 
-	    } else if (break_op == (Uint) BeamOp(op_i_time_breakpoint)) {
+	    } else if (break_op == (BeamInstr) BeamOp(op_i_time_breakpoint)) {
 		BpDataTime *bdt = (BpDataTime *) bd;
 		Uint i = 0;
 
@@ -1055,8 +1033,10 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	/* First breakpoint; create singleton ring */
 	bd = Alloc(size);
 	BpInit(bd, *pc);
-	*pc = break_op;
 	*r = bd;
+	if (bif == BREAK_IS_ERL) {
+	    *pc = break_op;
+	}
     } else {
 	ASSERT(*pc == (BeamInstr) BeamOp(op_i_trace_breakpoint) ||
 	       *pc == (BeamInstr) BeamOp(op_i_mtrace_breakpoint) ||
@@ -1070,7 +1050,9 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	    /* Insert new bp first in the ring, i.e second to last. */
 	    bd = Alloc(size);
 	    BpInitAndSpliceNext(bd, *pc, *r);
-	    *pc = break_op;
+	    if (bif == BREAK_IS_ERL) {
+		*pc = break_op;
+	    }
 	} else if ((*r)->prev->orig_instr
 		   == (BeamInstr) BeamOp(op_i_debug_breakpoint)) {
 	    /* Debug bp last in the ring; insert new second to last. */
@@ -1114,7 +1096,10 @@ static int set_function_break(Module *modp, BeamInstr *pc,
 	BpDataCount *bdc = (BpDataCount *) bd;
 	erts_smp_atomic_init(&bdc->acount, 0);
     }
-    ++(*(BeamInstr*)&code_base[MI_NUM_BREAKPOINTS]);
+
+    if (bif == BREAK_IS_ERL) {
+	++(*(BeamInstr*)&code_base[MI_NUM_BREAKPOINTS]);
+    }
     return 1;
 }
 
@@ -1164,26 +1149,34 @@ static int clear_module_break(Module *m, Eterm mfa[3], int specified,
 	    BeamInstr *pc = code_ptr + 5;
 	    
 	    num_processed += 
-		clear_function_break(m, pc, break_op);
+		clear_function_break(m, pc, BREAK_IS_ERL, break_op);
 	}
     }
     return num_processed;
 }
 
-static int clear_function_break(Module *m, BeamInstr *pc, BeamInstr break_op) {
+static int clear_function_break(Module *m, BeamInstr *pc, int bif, BeamInstr break_op) {
     BpData *bd;
     Uint ix = 0;
-    BeamInstr **code_base = (BeamInstr **)m->code;
-    
-    ASSERT(code_base);
-    ASSERT(code_base <= (BeamInstr **)pc);
-    ASSERT((BeamInstr **)pc < code_base + (m->code_length/sizeof(BeamInstr *)));
+    BeamInstr **code_base = NULL;
+
+    if (bif == BREAK_IS_ERL) {
+	code_base = (BeamInstr **)m->code;
+	ASSERT(code_base);
+	ASSERT(code_base <= (BeamInstr **)pc);
+	ASSERT((BeamInstr **)pc < code_base + (m->code_length/sizeof(BeamInstr *)));
+    } else {
+	ASSERT(*pc == (BeamInstr) em_apply_bif);
+	ASSERT(m == NULL);
+    }
+
     /*
      * Currently no trace support for native code.
      */
     if (erts_is_native_break(pc)) {
 	return 0;
     }
+
     while ( (bd = is_break(pc, break_op))) {
 	/* Remove all breakpoints of this type.
 	 * There should be only one of each type, 
@@ -1216,7 +1209,9 @@ static int clear_function_break(Module *m, BeamInstr *pc, BeamInstr break_op) {
 	if (BpSingleton(bd)) {
 	    ASSERT(*r == bd);
 	    /* Only one breakpoint to remove */
-	    *pc = bd->orig_instr;
+	    if (bif == BREAK_IS_ERL) {
+		*pc = bd->orig_instr;
+	    }
 	    Free(*rs);
 	    *rs = NULL;
 	} else {
@@ -1230,7 +1225,9 @@ static int clear_function_break(Module *m, BeamInstr *pc, BeamInstr break_op) {
 		bd_prev->orig_instr = bd->orig_instr;
 	    } else if (bd_prev == *r) {
 		/* We removed the first breakpoint in the ring */
-		*pc = bd->orig_instr;
+		if (bif == BREAK_IS_ERL) {
+		    *pc = bd->orig_instr;
+		}
 	    } else {
 		bd_prev->orig_instr = bd->orig_instr;
 	    }
@@ -1276,8 +1273,10 @@ static int clear_function_break(Module *m, BeamInstr *pc, BeamInstr break_op) {
 	    bdt->n = 0;
 	}
 	Free(bd);
-	ASSERT(((BeamInstr) code_base[MI_NUM_BREAKPOINTS]) > 0);
-	--(*(BeamInstr*)&code_base[MI_NUM_BREAKPOINTS]);
+	if (bif == BREAK_IS_ERL) {
+	    ASSERT(((BeamInstr) code_base[MI_NUM_BREAKPOINTS]) > 0);
+	    --(*(BeamInstr*)&code_base[MI_NUM_BREAKPOINTS]);
+	}
 	if (*rs) {
 	    for (ix = 1; ix < erts_no_schedulers; ++ix) {
 		(*rs)[ix] = (*rs)[0];
@@ -1296,7 +1295,12 @@ static int clear_function_break(Module *m, BeamInstr *pc, BeamInstr break_op) {
 ** returned. The program counter must point to the first executable
 ** (breakpoint) instruction of the function.
 */
-static BpData *is_break(BeamInstr *pc, BeamInstr break_op) {
+
+BpData *erts_get_time_break(Process *p, BeamInstr *pc) {
+    return get_break(p, pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
+}
+
+static BpData *get_break(Process *p, BeamInstr *pc, BeamInstr break_op) {
     ASSERT(pc[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
     if (! erts_is_native_break(pc)) {
 	BpData **rs = (BpData **) pc[-4];
@@ -1306,59 +1310,48 @@ static BpData *is_break(BeamInstr *pc, BeamInstr break_op) {
 	    return NULL;
 	}
 
-	bd = ebd = rs[bp_sched2ix()];
-
+	bd = ebd = rs[bp_sched2ix_proc(p)];
 	ASSERT(bd);
-	
-	if (break_op == 0) {
+	if (bd->this_instr == break_op) {
 	    return bd;
 	}
-	if (*pc == break_op) {
-	    ASSERT(bd);
-	    return bd->next;
-	}
-	if (! bd){
-	    return NULL;
-	}
+
 	bd = bd->next;
 	while (bd != ebd) {
 	    ASSERT(bd);
-	    if (bd->orig_instr == break_op) {
-		bd = bd->next;
+	    if (bd->this_instr == break_op) {
 		ASSERT(bd);
 		return bd;
-	    } else {
-		bd = bd->next;
 	    }
+	    bd = bd->next;
 	}
     }
     return NULL;
 }
-static BpData *get_break(Process *p, BeamInstr *pc, BeamInstr break_op) {
+
+static BpData *is_break(BeamInstr *pc, BeamInstr break_op) {
+    BpData **rs = (BpData **) pc[-4];
+    BpData  *bd = NULL, *ebd = NULL;
     ASSERT(pc[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
-    if (! erts_is_native_break(pc)) {
-	BpData **rs = (BpData **) pc[-4];
-	BpData  *bd = NULL, *ebd = NULL;
 
-	if (! rs) {
-	    return NULL;
-	}
+    if (! rs) {
+	return NULL;
+    }
 
-	bd = ebd = rs[bp_sched2ix_proc(p)];
+    bd = ebd = rs[bp_sched2ix()];
+    ASSERT(bd);
+    if ( (break_op == 0) || (bd->this_instr == break_op)) {
+	return bd;
+    }
+
+    bd = bd->next;
+    while (bd != ebd) {
 	ASSERT(bd);
 	if (bd->this_instr == break_op) {
+	    ASSERT(bd);
 	    return bd;
 	}
-
 	bd = bd->next;
-	while (bd != ebd) {
-	    ASSERT(bd);
-	    if (bd->this_instr == break_op) {
-		ASSERT(bd);
-		return bd;
-	    }
-	    bd = bd->next;
-	}
     }
     return NULL;
 }
-- 
cgit v1.2.3


From 1e1482a82280ffd16ca160845f8d7fd3d52a0aba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <psyeugenic@gmail.com>
Date: Fri, 28 May 2010 20:43:56 +0200
Subject: Fix assertion in trace_pattern for bifs

---
 erts/emulator/beam/beam_bp.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 9004c74f51..5ccac9b593 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -1042,7 +1042,8 @@ static int set_function_break(Module *modp, BeamInstr *pc, int bif,
 	       *pc == (BeamInstr) BeamOp(op_i_mtrace_breakpoint) ||
 	       *pc == (BeamInstr) BeamOp(op_i_debug_breakpoint) ||
 	       *pc == (BeamInstr) BeamOp(op_i_time_breakpoint) ||
-	       *pc == (BeamInstr) BeamOp(op_i_count_breakpoint));
+	       *pc == (BeamInstr) BeamOp(op_i_count_breakpoint) ||
+	       *pc == (BeamInstr) em_apply_bif);
 	if (*pc == (BeamInstr) BeamOp(op_i_debug_breakpoint)) {
 	    /* Debug bp must be last, so if it is also first; 
 	     * it must be singleton. */
-- 
cgit v1.2.3


From 9a4c67fa6c6093b11e387247e1ca756edefbdbfe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <psyeugenic@gmail.com>
Date: Mon, 31 May 2010 20:03:56 +0200
Subject: Fix bp_hash_put to do hash value after rehash

If a rehash was done the old hash value was used. This was incorrect.
---
 erts/emulator/beam/beam_bp.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'erts/emulator/beam/beam_bp.c')

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 5ccac9b593..682f31b83f 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -570,7 +570,7 @@ static ERTS_INLINE bp_data_time_item_t * bp_hash_get(bp_time_hash_t *hash, bp_da
 }
 
 static ERTS_INLINE bp_data_time_item_t * bp_hash_put(bp_time_hash_t *hash, bp_data_time_item_t* sitem) {
-    Uint hval = (sitem->pid >> 4) % hash->n;
+    Uint hval;
     float r = 0.0;
     bp_data_time_item_t *item;
 
@@ -582,6 +582,8 @@ static ERTS_INLINE bp_data_time_item_t * bp_hash_put(bp_time_hash_t *hash, bp_da
     if (r > 0.7f) {
 	bp_hash_rehash(hash, hash->n * 2);
     }
+    /* Do hval after rehash */
+    hval = (sitem->pid >> 4) % hash->n;
 
     /* find free slot */
     item = hash->item;
-- 
cgit v1.2.3