Merge branch 'rickard/port-optimizations/OTP-10336' into rickard/r16/port-optimizations/OTP-10336

* rickard/port-optimizations/OTP-10336:
  Change annotate level for emacs-22 in cerl
  Update etp-commands
  Add documentation on communication in Erlang
  Add support for busy port message queue
  Add driver callback epilogue
  Implement true asynchronous signaling between processes and ports
  Add erl_drv_[send|output]_term
  Move busy port flag
  Use rwlock for driver list
  Optimize management of port tasks
  Improve configuration of process and port tables
  Remove R9 compatibility features
  Use ptab functionality also for ports
  Prepare for use of ptab functionality also for ports
  Atomic port state
  Generalize process table implementation
  Implement functionality for delaying thread progress from unmanaged threads

Conflicts:
	erts/doc/src/erl_driver.xml
	erts/doc/src/erlang.xml
	erts/emulator/beam/beam_bif_load.c
	erts/emulator/beam/beam_bp.c
	erts/emulator/beam/beam_emu.c
	erts/emulator/beam/bif.c
	erts/emulator/beam/copy.c
	erts/emulator/beam/erl_alloc.c
	erts/emulator/beam/erl_alloc.types
	erts/emulator/beam/erl_bif_info.c
	erts/emulator/beam/erl_bif_port.c
	erts/emulator/beam/erl_bif_trace.c
	erts/emulator/beam/erl_init.c
	erts/emulator/beam/erl_message.c
	erts/emulator/beam/erl_port_task.c
	erts/emulator/beam/erl_process.c
	erts/emulator/beam/erl_process.h
	erts/emulator/beam/erl_process_lock.c
	erts/emulator/beam/erl_trace.c
	erts/emulator/beam/export.h
	erts/emulator/beam/global.h
	erts/emulator/beam/io.c
	erts/emulator/sys/unix/sys.c
	erts/emulator/sys/vxworks/sys.c
	erts/emulator/test/port_SUITE.erl
	erts/etc/unix/cerl.src
	erts/preloaded/ebin/erlang.beam
	erts/preloaded/ebin/prim_inet.beam
	erts/preloaded/src/prim_inet.erl
	lib/hipe/cerl/erl_bif_types.erl
	lib/kernel/doc/src/inet.xml
	lib/kernel/src/inet.erl

1 files changed, 192 insertions, 184 deletions

diff --git a/erts/emulator/beam/erl_trace.c b/erts/emulator/beam/erl_trace.c
index d04a91f18c..41f33efa79 100644
--- a/erts/emulator/beam/erl_trace.c
+++ b/erts/emulator/beam/erl_trace.c
@@ -156,8 +156,8 @@ do { (RES) = (TPID); } while(0)
 #define ERTS_TRACER_REF_TYPE Process *
 #define ERTS_GET_TRACER_REF(RES, TPID, TRACEE_FLGS) \
 do { \
-    (RES) = erts_proc_lookup((TPID));					\
-    if (!(RES) || !((RES)->trace_flags & F_TRACER)) {			\
+    (RES) = erts_proc_lookup((TPID)); \
+    if (!(RES) || !(ERTS_TRACE_FLAGS((RES)) & F_TRACER)) { \
 	(TPID) = NIL; \
 	(TRACEE_FLGS) &= ~TRACEE_FLAGS; \
 	return; \
@@ -409,7 +409,7 @@ WRITE_SYS_MSG_TO_PORT(Eterm unused_to,
     }
 
 #ifndef ERTS_SMP
-    if (!INVALID_TRACER_PORT(trace_port, trace_port->id))
+    if (!INVALID_TRACER_PORT(trace_port, trace_port->common.id))
 #endif
 	erts_raw_port_command(trace_port, buffer, ptr-buffer);
 
@@ -441,7 +441,7 @@ do_send_schedfix_to_port(Port *trace_port, Eterm pid, Eterm timestamp) {
     message = TUPLE5(hp, am_trace_ts, pid, am_out, mfarity, timestamp);
     /* Note, hp is deliberately NOT incremented since it will be reused */
 
-    do_send_to_port(trace_port->id,
+    do_send_to_port(trace_port->common.id,
 		    trace_port,
 		    pid,
 		    SYS_MSG_TYPE_UNDEFINED,
@@ -451,7 +451,7 @@ do_send_schedfix_to_port(Port *trace_port, Eterm pid, Eterm timestamp) {
     hp += 5;
     hp = patch_ts(message, hp);
 
-    do_send_to_port(trace_port->id,
+    do_send_to_port(trace_port->common.id,
 		    trace_port,
 		    pid,
 		    SYS_MSG_TYPE_UNDEFINED,
@@ -508,7 +508,7 @@ send_to_port(Process *c_p, Eterm message,
 #endif
 	do_send_to_port(*tracer_pid,
 			trace_port,
-			c_p ? c_p->id : NIL,
+			c_p ? c_p->common.id : NIL,
 			SYS_MSG_TYPE_TRACE,
 			message);
 #ifndef ERTS_SMP
@@ -543,7 +543,7 @@ send_to_port(Process *c_p, Eterm message,
     trace_port->control_flags &= ~PORT_CONTROL_FLAG_HEAVY;
     do_send_to_port(*tracer_pid,
 		    trace_port,
-		    c_p ? c_p->id : NIL,
+		    c_p ? c_p->common.id : NIL,
 		    SYS_MSG_TYPE_TRACE,
 		    message);
 
@@ -557,7 +557,7 @@ send_to_port(Process *c_p, Eterm message,
 	 * just after writning the real trace message, and now gets scheduled
 	 * in again.
 	 */
-	do_send_schedfix_to_port(trace_port, c_p->id, ts);
+	do_send_schedfix_to_port(trace_port, c_p->common.id, ts);
     }
 
     erts_port_release(trace_port);
@@ -599,15 +599,14 @@ profile_send(Eterm from, Eterm message) {
 	if (profiler_port) {
 	    do_send_to_port(profiler,
 			    profiler_port,
-			    NIL, /* or current process->id */
+			    NIL, /* or current process->common.id */
 			    SYS_MSG_TYPE_SYSPROF,
 			    message);
 	    erts_port_release(profiler_port);
 	}
     	
     } else {
-	ASSERT(is_internal_pid(profiler)
-                && internal_pid_index(profiler) < erts_max_processes);
+	ASSERT(is_internal_pid(profiler));
         
 	profile_p = erts_proc_lookup(profiler);
 
@@ -673,7 +672,7 @@ seq_trace_send_to_port(Process *c_p,
 #endif
 	do_send_to_port(seq_tracer,
 			trace_port,
-			c_p ? c_p->id : NIL,
+			c_p ? c_p->common.id : NIL,
 			SYS_MSG_TYPE_SEQTRACE,
 			message);
 
@@ -704,7 +703,7 @@ seq_trace_send_to_port(Process *c_p,
     trace_port->control_flags &= ~PORT_CONTROL_FLAG_HEAVY;
     do_send_to_port(seq_tracer,
 		    trace_port,
-		    c_p ? c_p->id : NIL,
+		    c_p ? c_p->common.id : NIL,
 		    SYS_MSG_TYPE_SEQTRACE,
 		    message);
 
@@ -718,7 +717,7 @@ seq_trace_send_to_port(Process *c_p,
 	 * just after writing the real trace message, and now gets scheduled
 	 * in again.
 	 */
-	do_send_schedfix_to_port(trace_port, c_p->id, ts);
+	do_send_schedfix_to_port(trace_port, c_p->common.id, ts);
     }
 
     erts_port_release(trace_port);
@@ -729,7 +728,9 @@ seq_trace_send_to_port(Process *c_p,
 }
 
 #define TS_HEAP_WORDS 5
-#define TS_SIZE(p) (((p)->trace_flags & F_TIMESTAMP) ? TS_HEAP_WORDS : 0)
+#define TS_SIZE(p) ((ERTS_TRACE_FLAGS((p)) & F_TIMESTAMP) \
+		    ? TS_HEAP_WORDS \
+		    : 0)
 
 /*
  * Patch a timestamp into a tuple.  The tuple must be the last thing
@@ -764,17 +765,17 @@ send_to_tracer(Process *tracee,
 
     erts_smp_mtx_lock(&smq_mtx);
 
-    if (tracee->trace_flags & F_TIMESTAMP)
+    if (ERTS_TRACE_FLAGS(tracee) & F_TIMESTAMP)
 	*hpp = patch_ts(msg, *hpp);
 
-    if (is_internal_pid(tracee->tracer_proc))
-	ERTS_ENQ_TRACE_MSG(tracee->id, tracer_ref, msg, bp);
+    if (is_internal_pid(ERTS_TRACER_PROC(tracee)))
+	ERTS_ENQ_TRACE_MSG(tracee->common.id, tracer_ref, msg, bp);
     else {
-	ASSERT(is_internal_port(tracee->tracer_proc));
+	ASSERT(is_internal_port(ERTS_TRACER_PROC(tracee)));
 	send_to_port(no_fake_sched ? NULL : tracee,
 		     msg,
-		     &tracee->tracer_proc,
-		     &tracee->trace_flags);
+		     &ERTS_TRACER_PROC(tracee),
+		     &ERTS_TRACE_FLAGS(tracee));
     }
 
     erts_smp_mtx_unlock(&smq_mtx);
@@ -792,7 +793,7 @@ trace_sched_aux(Process *p, Eterm what, int never_fake_sched)
     ERTS_TRACER_REF_TYPE tracer_ref = ERTS_NULL_TRACER_REF;
     int sched_no, curr_func, to_port, no_fake_sched;
 
-    if (is_nil(p->tracer_proc))
+    if (is_nil(ERTS_TRACER_PROC(p)))
 	return;
 
     no_fake_sched = never_fake_sched;
@@ -812,13 +813,14 @@ trace_sched_aux(Process *p, Eterm what, int never_fake_sched)
     }
 
     sched_no = IS_TRACED_FL(p, F_TRACE_SCHED_NO);
-    to_port = is_internal_port(p->tracer_proc);
+    to_port = is_internal_port(ERTS_TRACER_PROC(p));
 
     if (!to_port) {
-	ASSERT(is_internal_pid(p->tracer_proc)
-	       && internal_pid_index(p->tracer_proc) < erts_max_processes);
+	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
 
-	ERTS_GET_TRACER_REF(tracer_ref, p->tracer_proc, p->trace_flags);
+	ERTS_GET_TRACER_REF(tracer_ref,
+			    ERTS_TRACER_PROC(p),
+			    ERTS_TRACE_FLAGS(p));
     }
 
     if (ERTS_PROC_IS_EXITING(p))
@@ -851,7 +853,7 @@ trace_sched_aux(Process *p, Eterm what, int never_fake_sched)
     }
 
     if (!sched_no) {
-	mess = TUPLE4(hp, am_trace, p->id, what, tmp);
+	mess = TUPLE4(hp, am_trace, p->common.id, what, tmp);
 	hp += 5;
     }
     else {
@@ -860,7 +862,7 @@ trace_sched_aux(Process *p, Eterm what, int never_fake_sched)
 #else
 	Eterm sched_id = make_small(1);
 #endif
-	mess = TUPLE5(hp, am_trace, p->id, what, sched_id, tmp);
+	mess = TUPLE5(hp, am_trace, p->common.id, what, sched_id, tmp);
 	hp += 6;
     }
 
@@ -912,19 +914,19 @@ trace_send(Process *p, Eterm to, Eterm msg)
 	operation = am_atom_put(s, sys_strlen(s));
     }
 
-    if (is_internal_port(p->tracer_proc)) {
+    if (is_internal_port(ERTS_TRACER_PROC(p))) {
 #define LOCAL_HEAP_SIZE (11)
 	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
 	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 
 	hp = local_heap;
-	mess = TUPLE5(hp, am_trace, p->id, operation, msg, to);
+	mess = TUPLE5(hp, am_trace, p->common.id, operation, msg, to);
 	hp += 6;
 	erts_smp_mtx_lock(&smq_mtx);
-	if (p->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(p) & F_TIMESTAMP) {
 	    hp = patch_ts(mess, hp);
 	}
-	send_to_port(p, mess, &p->tracer_proc, &p->trace_flags);
+	send_to_port(p, mess, &ERTS_TRACER_PROC(p), &ERTS_TRACE_FLAGS(p));
 	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 #undef LOCAL_HEAP_SIZE
 	erts_smp_mtx_unlock(&smq_mtx);
@@ -934,10 +936,11 @@ trace_send(Process *p, Eterm to, Eterm msg)
 	ErlOffHeap *off_heap;
 	ERTS_TRACER_REF_TYPE tracer_ref;
 
-	ASSERT(is_internal_pid(p->tracer_proc)
-	       && internal_pid_index(p->tracer_proc) < erts_max_processes);
+	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
 
-	ERTS_GET_TRACER_REF(tracer_ref, p->tracer_proc, p->trace_flags);
+	ERTS_GET_TRACER_REF(tracer_ref,
+			    ERTS_TRACER_PROC(p),
+			    ERTS_TRACE_FLAGS(p));
 
 	sz_msg = size_object(msg);
 	sz_to  = size_object(to);
@@ -953,16 +956,16 @@ trace_send(Process *p, Eterm to, Eterm msg)
 			  sz_msg,
 			  &hp,
 			  off_heap);
-	mess = TUPLE5(hp, am_trace, p->id/* Local pid */, operation, msg, to);
+	mess = TUPLE5(hp, am_trace, p->common.id, operation, msg, to);
 	hp += 6;
 
 	erts_smp_mtx_lock(&smq_mtx);
 
-	if (p->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(p) & F_TIMESTAMP) {
 	    patch_ts(mess, hp);
 	}
 
-	ERTS_ENQ_TRACE_MSG(p->id, tracer_ref, mess, bp);
+	ERTS_ENQ_TRACE_MSG(p->common.id, tracer_ref, mess, bp);
 	erts_smp_mtx_unlock(&smq_mtx);
     }
 }
@@ -977,19 +980,19 @@ trace_receive(Process *rp, Eterm msg)
     size_t sz_msg;
     Eterm* hp;
 
-    if (is_internal_port(rp->tracer_proc)) {
+    if (is_internal_port(ERTS_TRACER_PROC(rp))) {
 #define LOCAL_HEAP_SIZE (10)
 	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
 	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 
 	hp = local_heap;
-	mess = TUPLE4(hp, am_trace, rp->id, am_receive, msg);
+	mess = TUPLE4(hp, am_trace, rp->common.id, am_receive, msg);
 	hp += 5;
 	erts_smp_mtx_lock(&smq_mtx);
-	if (rp->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(rp) & F_TIMESTAMP) {
 	    hp = patch_ts(mess, hp);
 	}
-	send_to_port(rp, mess, &rp->tracer_proc, &rp->trace_flags);
+	send_to_port(rp, mess, &ERTS_TRACER_PROC(rp), &ERTS_TRACE_FLAGS(rp));
 	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 #undef LOCAL_HEAP_SIZE
 	erts_smp_mtx_unlock(&smq_mtx);
@@ -999,10 +1002,11 @@ trace_receive(Process *rp, Eterm msg)
 	ErlOffHeap *off_heap;
 	ERTS_TRACER_REF_TYPE tracer_ref;
 
-	ASSERT(is_internal_pid(rp->tracer_proc)
-	       && internal_pid_index(rp->tracer_proc) < erts_max_processes);
+	ASSERT(is_internal_pid(ERTS_TRACER_PROC(rp)));
 
-	ERTS_GET_TRACER_REF(tracer_ref, rp->tracer_proc, rp->trace_flags);
+	ERTS_GET_TRACER_REF(tracer_ref,
+			    ERTS_TRACER_PROC(rp),
+			    ERTS_TRACE_FLAGS(rp));
 
 	sz_msg = size_object(msg);
 
@@ -1011,16 +1015,16 @@ trace_receive(Process *rp, Eterm msg)
 	hp = ERTS_ALLOC_SYSMSG_HEAP(hsz, &bp, &off_heap, tracer_ref);
 
 	msg = copy_struct(msg, sz_msg, &hp, off_heap);
-	mess = TUPLE4(hp, am_trace, rp->id/* Local pid */, am_receive, msg);
+	mess = TUPLE4(hp, am_trace, rp->common.id, am_receive, msg);
 	hp += 5;
 
 	erts_smp_mtx_lock(&smq_mtx);
 
-	if (rp->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(rp) & F_TIMESTAMP) {
 	    patch_ts(mess, hp);
 	}
 
-	ERTS_ENQ_TRACE_MSG(rp->id, tracer_ref, mess, bp);
+	ERTS_ENQ_TRACE_MSG(rp->common.id, tracer_ref, mess, bp);
 	erts_smp_mtx_unlock(&smq_mtx);
     }
 }
@@ -1030,14 +1034,14 @@ seq_trace_update_send(Process *p)
 {
     Eterm seq_tracer = erts_get_system_seq_tracer();
     ASSERT((is_tuple(SEQ_TRACE_TOKEN(p)) || is_nil(SEQ_TRACE_TOKEN(p))));
-    if ( (p->id == seq_tracer) || (SEQ_TRACE_TOKEN(p) == NIL)
+    if ( (p->common.id == seq_tracer) || (SEQ_TRACE_TOKEN(p) == NIL)
 #ifdef USE_VM_PROBES
 	 || (SEQ_TRACE_TOKEN(p) == am_have_dt_utag)
 #endif
 	 ) {
 	return 0;
     }
-    SEQ_TRACE_TOKEN_SENDER(p) = p->id; /* Internal pid */
+    SEQ_TRACE_TOKEN_SENDER(p) = p->common.id;
     SEQ_TRACE_TOKEN_SERIAL(p) = 
 	make_small(++(p -> seq_trace_clock));
     SEQ_TRACE_TOKEN_LASTCNT(p) = 
@@ -1074,7 +1078,7 @@ seq_trace_output_generic(Eterm token, Eterm msg, Uint type,
 
     ASSERT(is_tuple(token) || is_nil(token));
     if (SEQ_TRACE_T_SENDER(token) == seq_tracer || token == NIL ||
-	(process && process->trace_flags & F_SENSITIVE)) {
+	(process && ERTS_TRACE_FLAGS(process) & F_SENSITIVE)) {
 	return;
     }
 
@@ -1138,8 +1142,7 @@ seq_trace_output_generic(Eterm token, Eterm msg, Uint type,
 	Uint sz_label, sz_lastcnt_serial, sz_msg, sz_ts, sz_sender,
 	    sz_exitfrom, sz_receiver;
 
-	ASSERT(is_internal_pid(seq_tracer)
-	       && internal_pid_index(seq_tracer) < erts_max_processes);
+	ASSERT(is_internal_pid(seq_tracer));
 
 #ifndef ERTS_SMP
 
@@ -1253,17 +1256,17 @@ erts_trace_return_to(Process *p, BeamInstr *pc)
 	hp += 4;
     }
 	
-    mess = TUPLE4(hp, am_trace, p->id, am_return_to, mfa);
+    mess = TUPLE4(hp, am_trace, p->common.id, am_return_to, mfa);
     hp += 5;
 
     erts_smp_mtx_lock(&smq_mtx);
 
-    if (p->trace_flags & F_TIMESTAMP) {
+    if (ERTS_TRACE_FLAGS(p) & F_TIMESTAMP) {
 	hp = patch_ts(mess, hp);
     }
 
-    if (is_internal_port(p->tracer_proc)) {
-	send_to_port(p, mess, &p->tracer_proc, &p->trace_flags);
+    if (is_internal_port(ERTS_TRACER_PROC(p))) {
+	send_to_port(p, mess, &ERTS_TRACER_PROC(p), &ERTS_TRACE_FLAGS(p));
     } else {
 	ErlHeapFragment *bp;
 	ErlOffHeap *off_heap;
@@ -1273,10 +1276,11 @@ erts_trace_return_to(Process *p, BeamInstr *pc)
 	/*
 	 * Find the tracer.
 	 */
-	ASSERT(is_internal_pid(p->tracer_proc)
-	       && internal_pid_index(p->tracer_proc) < erts_max_processes);
+	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
 
-	ERTS_GET_TRACER_REF(tracer_ref, p->tracer_proc, p->trace_flags);
+	ERTS_GET_TRACER_REF(tracer_ref,
+			    ERTS_TRACER_PROC(p),
+			    ERTS_TRACE_FLAGS(p));
 
 	size = size_object(mess);
 
@@ -1286,7 +1290,7 @@ erts_trace_return_to(Process *p, BeamInstr *pc)
 	 * Copy the trace message into the buffer and enqueue it.
 	 */
 	mess = copy_struct(mess, size, &hp, off_heap);
-	ERTS_ENQ_TRACE_MSG(p->id, tracer_ref, mess, bp);
+	ERTS_ENQ_TRACE_MSG(p->common.id, tracer_ref, mess, bp);
     }
     UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 #undef LOCAL_HEAP_SIZE
@@ -1315,25 +1319,25 @@ erts_trace_return(Process* p, BeamInstr* fi, Eterm retval, Eterm *tracer_pid)
 	/* Breakpoint trace enabled without specifying tracer =>
 	 *   use process tracer and flags
 	 */
-	tracer_pid = &p->tracer_proc;
+	tracer_pid = &ERTS_TRACER_PROC(p);
     }
     if (is_nil(*tracer_pid)) {
 	/* Trace disabled */
 	return;
     }
     ASSERT(is_internal_pid(*tracer_pid) || is_internal_port(*tracer_pid));
-    if (*tracer_pid == p->id) {
+    if (*tracer_pid == p->common.id) {
 	/* Do not generate trace messages to oneself */
 	return;
     }
-    if (tracer_pid == &p->tracer_proc) {
+    if (tracer_pid == &ERTS_TRACER_PROC(p)) {
 	/* Tracer specified in process structure =>
 	 *   non-breakpoint trace =>
 	 *     use process flags
 	 */
-	tracee_flags = &p->trace_flags;
+	tracee_flags = &ERTS_TRACE_FLAGS(p);
 #ifdef ERTS_SMP
-	tracee = p->id;
+	tracee = p->common.id;
 #endif
     } else {
 	/* Tracer not specified in process structure =>
@@ -1362,7 +1366,7 @@ erts_trace_return(Process* p, BeamInstr* fi, Eterm retval, Eterm *tracer_pid)
 	hp = local_heap;
 	mfa = TUPLE3(hp, mod, name, make_small(arity));
 	hp += 4;
-	mess = TUPLE5(hp, am_trace, p->id, am_return_from, mfa, retval);
+	mess = TUPLE5(hp, am_trace, p->common.id, am_return_from, mfa, retval);
 	hp += 6;
 	erts_smp_mtx_lock(&smq_mtx);
 	if (*tracee_flags & F_TIMESTAMP) {
@@ -1382,8 +1386,7 @@ erts_trace_return(Process* p, BeamInstr* fi, Eterm retval, Eterm *tracer_pid)
 	Eterm* limit;
 #endif
 
-	ASSERT(is_internal_pid(*tracer_pid)
-	       && internal_pid_index(*tracer_pid) < erts_max_processes);
+	ASSERT(is_internal_pid(*tracer_pid));
 
 	ERTS_GET_TRACER_REF(tracer_ref, *tracer_pid, *tracee_flags);
 	
@@ -1405,7 +1408,7 @@ erts_trace_return(Process* p, BeamInstr* fi, Eterm retval, Eterm *tracer_pid)
 	mfa = TUPLE3(hp, mod, name, make_small(arity));
 	hp += 4;
 	retval = copy_struct(retval, retval_size, &hp, off_heap);
-	mess = TUPLE5(hp, am_trace, p->id/* Local pid */, am_return_from, mfa, retval);
+	mess = TUPLE5(hp, am_trace, p->common.id, am_return_from, mfa, retval);
 	hp += 6;
 
 	erts_smp_mtx_lock(&smq_mtx);
@@ -1446,25 +1449,25 @@ erts_trace_exception(Process* p, BeamInstr mfa[3], Eterm class, Eterm value,
 	/* Breakpoint trace enabled without specifying tracer =>
 	 *   use process tracer and flags
 	 */
-	tracer_pid = &p->tracer_proc;
+	tracer_pid = &ERTS_TRACER_PROC(p);
     }
     if (is_nil(*tracer_pid)) {
 	/* Trace disabled */
 	return;
     }
     ASSERT(is_internal_pid(*tracer_pid) || is_internal_port(*tracer_pid));
-    if (*tracer_pid == p->id) {
+    if (*tracer_pid == p->common.id) {
 	/* Do not generate trace messages to oneself */
 	return;
     }
-    if (tracer_pid == &p->tracer_proc) {
+    if (tracer_pid == &ERTS_TRACER_PROC(p)) {
 	/* Tracer specified in process structure =>
 	 *   non-breakpoint trace =>
 	 *     use process flags
 	 */
-	tracee_flags = &p->trace_flags;
+	tracee_flags = &ERTS_TRACE_FLAGS(p);
 #ifdef ERTS_SMP
-	tracee = p->id;
+	tracee = p->common.id;
 #endif
 	if (! (*tracee_flags & F_TRACE_CALLS)) {
 	    return;
@@ -1492,7 +1495,7 @@ erts_trace_exception(Process* p, BeamInstr mfa[3], Eterm class, Eterm value,
 	hp += 4;
 	cv = TUPLE2(hp, class, value);
 	hp += 3;
-	mess = TUPLE5(hp, am_trace, p->id, am_exception_from, mfa_tuple, cv);
+	mess = TUPLE5(hp, am_trace, p->common.id, am_exception_from, mfa_tuple, cv);
 	hp += 6;
 	ASSERT((hp - local_heap) <= LOCAL_HEAP_SIZE);
 	erts_smp_mtx_lock(&smq_mtx);
@@ -1514,8 +1517,7 @@ erts_trace_exception(Process* p, BeamInstr mfa[3], Eterm class, Eterm value,
 	Eterm* limit;
 #endif
 
-	ASSERT(is_internal_pid(*tracer_pid)
-	       && internal_pid_index(*tracer_pid) < erts_max_processes);
+	ASSERT(is_internal_pid(*tracer_pid));
 
 	ERTS_GET_TRACER_REF(tracer_ref, *tracer_pid, *tracee_flags);
 	
@@ -1539,7 +1541,7 @@ erts_trace_exception(Process* p, BeamInstr mfa[3], Eterm class, Eterm value,
 	value = copy_struct(value, value_size, &hp, off_heap);
 	cv = TUPLE2(hp, class, value);
 	hp += 3;
-	mess = TUPLE5(hp, am_trace, p->id/* Local pid */, 
+	mess = TUPLE5(hp, am_trace, p->common.id, 
 		      am_exception_from, mfa_tuple, cv);
 	hp += 6;
 
@@ -1593,25 +1595,25 @@ erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
 	/* Breakpoint trace enabled without specifying tracer =>
 	 *   use process tracer and flags
 	 */
-	tracer_pid = &p->tracer_proc;
+	tracer_pid = &ERTS_TRACER_PROC(p);
     } 
     if (is_nil(*tracer_pid)) {
 	/* Trace disabled */
 	return 0;
     }
     ASSERT(is_internal_pid(*tracer_pid) || is_internal_port(*tracer_pid));
-    if (*tracer_pid == p->id) {
+    if (*tracer_pid == p->common.id) {
 	/* Do not generate trace messages to oneself */
 	return 0;
     }
-    if (tracer_pid == &p->tracer_proc) {
+    if (tracer_pid == &ERTS_TRACER_PROC(p)) {
 	/* Tracer specified in process structure =>
 	 *   non-breakpoint trace =>
 	 *     use process flags
 	 */
-	tracee_flags = &p->trace_flags;
+	tracee_flags = &ERTS_TRACE_FLAGS(p);
 #ifdef ERTS_SMP
-	tracee = p->id;
+	tracee = p->common.id;
 #endif
     } else {
 	/* Tracer not specified in process structure =>
@@ -1619,7 +1621,7 @@ erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
 	 *     meta trace =>
 	 *       use fixed flag set instead of process flags
 	 */	    
-	if (p->trace_flags & F_SENSITIVE) {
+	if (ERTS_TRACE_FLAGS(p) & F_SENSITIVE) {
 	    /* No trace messages for sensitive processes. */
 	    return 0;
 	}
@@ -1677,7 +1679,7 @@ erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
 
 	if (!erts_is_valid_tracer_port(*tracer_pid)) {
 #ifdef ERTS_SMP
-	    ASSERT(is_nil(tracee) || tracer_pid == &p->tracer_proc);
+	    ASSERT(is_nil(tracee) || tracer_pid == &ERTS_TRACER_PROC(p));
 	    if (is_not_nil(tracee))
 		erts_smp_proc_lock(p, ERTS_PROC_LOCKS_ALL_MINOR);
 #endif
@@ -1779,7 +1781,7 @@ erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
 	 * Build the trace tuple and send it to the port.
 	 */
 	
-	mess = TUPLE4(hp, am_trace, p->id, am_call, mfa_tuple);
+	mess = TUPLE4(hp, am_trace, p->common.id, am_call, mfa_tuple);
 	hp += 5;
 	if (pam_result != am_true) {
 	    hp[-5] = make_arityval(5);
@@ -1814,21 +1816,21 @@ erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
 	Eterm* limit;
 #endif
 
-	ASSERT(is_internal_pid(*tracer_pid)
-	       && internal_pid_index(*tracer_pid) < erts_max_processes);
+	ASSERT(is_internal_pid(*tracer_pid));
 	
 	tracer = erts_pid2proc(p, ERTS_PROC_LOCK_MAIN,
 			       *tracer_pid, ERTS_PROC_LOCK_STATUS);
 	if (!tracer)
 	    invalid_tracer = 1;
 	else {
-	    invalid_tracer = (tracer->trace_flags & F_TRACER) == 0;
+	    invalid_tracer = !(ERTS_TRACE_FLAGS(tracer) & F_TRACER);
 	    erts_smp_proc_unlock(tracer, ERTS_PROC_LOCK_STATUS);
 	}
 
 	if (invalid_tracer) {
 #ifdef ERTS_SMP
-	    ASSERT(is_nil(tracee) || tracer_pid == &p->tracer_proc);
+	    ASSERT(is_nil(tracee)
+		   || tracer_pid == &ERTS_TRACER_PROC(p));
 	    if (is_not_nil(tracee))
 		erts_smp_proc_lock(p, ERTS_PROC_LOCKS_ALL_MINOR);
 #endif
@@ -1952,7 +1954,7 @@ erts_call_trace(Process* p, BeamInstr mfa[3], Binary *match_spec,
 	 * Build the trace tuple and enqueue it.
 	 */
 	
-	mess = TUPLE4(hp, am_trace, p->id/* Local pid */, am_call, mfa_tuple);
+	mess = TUPLE4(hp, am_trace, p->common.id, am_call, mfa_tuple);
 	hp += 5;
 	if (pam_result != am_true) {
 	    hp[-5] = make_arityval(5);
@@ -1990,17 +1992,17 @@ trace_proc(Process *c_p, Process *t_p, Eterm what, Eterm data)
 
     ERTS_SMP_LC_ASSERT((erts_proc_lc_my_proc_locks(t_p) != 0)
 		       || erts_thr_progress_is_blocking());
-    if (is_internal_port(t_p->tracer_proc)) {
+    if (is_internal_port(ERTS_TRACER_PROC(t_p))) {
 #define LOCAL_HEAP_SIZE (5+5)
 	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
 	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 
 
 	hp = local_heap;
-	mess = TUPLE4(hp, am_trace, t_p->id, what, data);
+	mess = TUPLE4(hp, am_trace, t_p->common.id, what, data);
 	hp += 5;
 	erts_smp_mtx_lock(&smq_mtx);
-	if (t_p->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(t_p) & F_TIMESTAMP) {
 	    hp = patch_ts(mess, hp);
 	}
 	send_to_port(
@@ -2011,7 +2013,9 @@ trace_proc(Process *c_p, Process *t_p, Eterm what, Eterm data)
 	    /* Fake schedule out and in are never sent when smp enabled */
 	    c_p,
 #endif
-	    mess, &t_p->tracer_proc, &t_p->trace_flags);
+	    mess,
+	    &ERTS_TRACER_PROC(t_p),
+	    &ERTS_TRACE_FLAGS(t_p));
 	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 #undef LOCAL_HEAP_SIZE
 	erts_smp_mtx_unlock(&smq_mtx);
@@ -2022,10 +2026,11 @@ trace_proc(Process *c_p, Process *t_p, Eterm what, Eterm data)
 	ERTS_TRACER_REF_TYPE tracer_ref;
 	size_t sz_data;
 
-	ASSERT(is_internal_pid(t_p->tracer_proc)
-	       && internal_pid_index(t_p->tracer_proc) < erts_max_processes);
+	ASSERT(is_internal_pid(ERTS_TRACER_PROC(t_p)));
 
-	ERTS_GET_TRACER_REF(tracer_ref, t_p->tracer_proc, t_p->trace_flags);
+	ERTS_GET_TRACER_REF(tracer_ref,
+			    ERTS_TRACER_PROC(t_p),
+			    ERTS_TRACE_FLAGS(t_p));
 
 	sz_data = size_object(data);
 
@@ -2034,16 +2039,16 @@ trace_proc(Process *c_p, Process *t_p, Eterm what, Eterm data)
 	hp = ERTS_ALLOC_SYSMSG_HEAP(need, &bp, &off_heap, tracer_ref);
 
 	tmp = copy_struct(data, sz_data, &hp, off_heap);
-	mess = TUPLE4(hp, am_trace, t_p->id/* Local pid */, what, tmp);
+	mess = TUPLE4(hp, am_trace, t_p->common.id, what, tmp);
 	hp += 5;
 
 	erts_smp_mtx_lock(&smq_mtx);
 
-	if (t_p->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(t_p) & F_TIMESTAMP) {
 	    hp = patch_ts(mess, hp);
 	}
 
-	ERTS_ENQ_TRACE_MSG(t_p->id, tracer_ref, mess, bp);
+	ERTS_ENQ_TRACE_MSG(t_p->common.id, tracer_ref, mess, bp);
 	erts_smp_mtx_unlock(&smq_mtx);
     }
 }
@@ -2064,7 +2069,7 @@ trace_proc_spawn(Process *p, Eterm pid,
     Eterm mess;
     Eterm* hp;
 
-    if (is_internal_port(p->tracer_proc)) {
+    if (is_internal_port(ERTS_TRACER_PROC(p))) {
 #define LOCAL_HEAP_SIZE (4+6+5)
 	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
 	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
@@ -2072,13 +2077,13 @@ trace_proc_spawn(Process *p, Eterm pid,
 	hp = local_heap;
 	mfa = TUPLE3(hp, mod, func, args);
 	hp += 4;
-	mess = TUPLE5(hp, am_trace, p->id, am_spawn, pid, mfa);
+	mess = TUPLE5(hp, am_trace, p->common.id, am_spawn, pid, mfa);
 	hp += 6;
 	erts_smp_mtx_lock(&smq_mtx);
-	if (p->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(p) & F_TIMESTAMP) {
 	    hp = patch_ts(mess, hp);
 	}
-	send_to_port(p, mess, &p->tracer_proc, &p->trace_flags);
+	send_to_port(p, mess, &ERTS_TRACER_PROC(p), &ERTS_TRACE_FLAGS(p));
 	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 #undef LOCAL_HEAP_SIZE
 	erts_smp_mtx_unlock(&smq_mtx);
@@ -2090,10 +2095,11 @@ trace_proc_spawn(Process *p, Eterm pid,
 	size_t sz_args, sz_pid;
 	Uint need;
 
-	ASSERT(is_internal_pid(p->tracer_proc)
-	       && internal_pid_index(p->tracer_proc) < erts_max_processes);
+	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
 
-	ERTS_GET_TRACER_REF(tracer_ref, p->tracer_proc, p->trace_flags);
+	ERTS_GET_TRACER_REF(tracer_ref,
+			    ERTS_TRACER_PROC(p),
+			    ERTS_TRACE_FLAGS(p));
 
 	sz_args = size_object(args);
 	sz_pid = size_object(pid);
@@ -2105,16 +2111,16 @@ trace_proc_spawn(Process *p, Eterm pid,
 	mfa = TUPLE3(hp, mod, func, tmp);
 	hp += 4;
 	tmp = copy_struct(pid, sz_pid, &hp, off_heap);
-	mess = TUPLE5(hp, am_trace, p->id, am_spawn, tmp, mfa);
+	mess = TUPLE5(hp, am_trace, p->common.id, am_spawn, tmp, mfa);
 	hp += 6;
 
 	erts_smp_mtx_lock(&smq_mtx);
 
-	if (p->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(p) & F_TIMESTAMP) {
 	    hp = patch_ts(mess, hp);
 	}
 
-	ERTS_ENQ_TRACE_MSG(p->id, tracer_ref, mess, bp);
+	ERTS_ENQ_TRACE_MSG(p->common.id, tracer_ref, mess, bp);
 	erts_smp_mtx_unlock(&smq_mtx);
     }
 }
@@ -2204,7 +2210,7 @@ trace_gc(Process *p, Eterm what)
 
     UseTmpHeap(LOCAL_HEAP_SIZE,p);
 
-    if (is_internal_port(p->tracer_proc)) {
+    if (is_internal_port(ERTS_TRACER_PROC(p))) {
 	hp = local_heap;
 #ifdef DEBUG
 	size = 0;
@@ -2216,10 +2222,11 @@ trace_gc(Process *p, Eterm what)
 	size += 5/*4-tuple*/ + TS_SIZE(p);
 #endif
     } else {
-	ASSERT(is_internal_pid(p->tracer_proc)
-	       && internal_pid_index(p->tracer_proc) < erts_max_processes);
+	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
 
-	ERTS_GET_TRACER_REF(tracer_ref, p->tracer_proc, p->trace_flags);
+	ERTS_GET_TRACER_REF(tracer_ref,
+			    ERTS_TRACER_PROC(p),
+			    ERTS_TRACE_FLAGS(p));
 
 	size = 0;
 	(void) erts_bld_atom_uint_2tup_list(NULL,
@@ -2243,19 +2250,19 @@ trace_gc(Process *p, Eterm what)
 				       tags,
 				       values);
 
-    msg = TUPLE4(hp, am_trace, p->id/* Local pid */, what, msg);
+    msg = TUPLE4(hp, am_trace, p->common.id, what, msg);
     hp += 5;
 
     erts_smp_mtx_lock(&smq_mtx);
 
-    if (p->trace_flags & F_TIMESTAMP) {
+    if (ERTS_TRACE_FLAGS(p) & F_TIMESTAMP) {
 	hp = patch_ts(msg, hp);
     }
     ASSERT(hp == limit);
-    if (is_internal_port(p->tracer_proc))
-	send_to_port(p, msg, &p->tracer_proc, &p->trace_flags);
+    if (is_internal_port(ERTS_TRACER_PROC(p)))
+	send_to_port(p, msg, &ERTS_TRACER_PROC(p), &ERTS_TRACE_FLAGS(p));
     else
-	ERTS_ENQ_TRACE_MSG(p->id, tracer_ref, msg, bp);
+	ERTS_ENQ_TRACE_MSG(p->common.id, tracer_ref, msg, bp);
     erts_smp_mtx_unlock(&smq_mtx);
     UnUseTmpHeap(LOCAL_HEAP_SIZE,p);
 #undef LOCAL_HEAP_SIZE
@@ -2295,8 +2302,7 @@ monitor_long_gc(Process *p, Uint time) {
 #endif
 	
 #ifndef ERTS_SMP
-    ASSERT(is_internal_pid(system_monitor)
-	   && internal_pid_index(system_monitor) < erts_max_processes);
+    ASSERT(is_internal_pid(system_monitor));
     monitor_p = erts_proc_lookup(system_monitor);
     if (!monitor_p || p == monitor_p)
 	return;
@@ -2321,7 +2327,7 @@ monitor_long_gc(Process *p, Uint time) {
 					sizeof(values)/sizeof(Uint),
 					tags,
 					values);
-    msg = TUPLE4(hp, am_monitor, p->id/* Local pid */, am_long_gc, list); 
+    msg = TUPLE4(hp, am_monitor, p->common.id, am_long_gc, list); 
 
 #ifdef DEBUG
     hp += 5 /* 4-tuple */;
@@ -2329,7 +2335,7 @@ monitor_long_gc(Process *p, Uint time) {
 #endif
 
 #ifdef ERTS_SMP
-    enqueue_sys_msg(SYS_MSG_TYPE_SYSMON, p->id, NIL, msg, bp);
+    enqueue_sys_msg(SYS_MSG_TYPE_SYSMON, p->common.id, NIL, msg, bp);
 #else
     erts_queue_message(monitor_p, NULL, bp, msg, NIL
 #ifdef USE_VM_PROBES
@@ -2370,8 +2376,7 @@ monitor_large_heap(Process *p) {
 
 
 #ifndef ERTS_SMP 
-    ASSERT(is_internal_pid(system_monitor)
-	   && internal_pid_index(system_monitor) < erts_max_processes);
+    ASSERT(is_internal_pid(system_monitor));
     monitor_p = erts_proc_lookup(system_monitor);
     if (monitor_p || p == monitor_p) {
 	return;
@@ -2397,7 +2402,7 @@ monitor_large_heap(Process *p) {
 					sizeof(values)/sizeof(Uint),
 					tags,
 					values);
-    msg = TUPLE4(hp, am_monitor, p->id/* Local pid */, am_large_heap, list); 
+    msg = TUPLE4(hp, am_monitor, p->common.id, am_large_heap, list); 
 
 #ifdef DEBUG
     hp += 5 /* 4-tuple */;
@@ -2405,7 +2410,7 @@ monitor_large_heap(Process *p) {
 #endif
 
 #ifdef ERTS_SMP
-    enqueue_sys_msg(SYS_MSG_TYPE_SYSMON, p->id, NIL, msg, bp);
+    enqueue_sys_msg(SYS_MSG_TYPE_SYSMON, p->common.id, NIL, msg, bp);
 #else
     erts_queue_message(monitor_p, NULL, bp, msg, NIL
 #ifdef USE_VM_PROBES
@@ -2425,8 +2430,7 @@ monitor_generic(Process *p, Eterm type, Eterm spec) {
     Eterm *hp, msg;
 
 #ifndef ERTS_SMP
-    ASSERT(is_internal_pid(system_monitor)
-	   && internal_pid_index(system_monitor) < erts_max_processes);
+    ASSERT(is_internal_pid(system_monitor));
     monitor_p = erts_proc_lookup(system_monitor);
     if (!monitor_p || p == monitor_p)
 	return;
@@ -2434,11 +2438,11 @@ monitor_generic(Process *p, Eterm type, Eterm spec) {
 
     hp = ERTS_ALLOC_SYSMSG_HEAP(5, &bp, &off_heap, monitor_p);
 
-    msg = TUPLE4(hp, am_monitor, p->id/* Local pid */, type, spec); 
+    msg = TUPLE4(hp, am_monitor, p->common.id, type, spec); 
     hp += 5;
 
 #ifdef ERTS_SMP
-    enqueue_sys_msg(SYS_MSG_TYPE_SYSMON, p->id, NIL, msg, bp);
+    enqueue_sys_msg(SYS_MSG_TYPE_SYSMON, p->common.id, NIL, msg, bp);
 #else
     erts_queue_message(monitor_p, NULL, bp, msg, NIL
 #ifdef USE_VM_PROBES
@@ -2560,21 +2564,21 @@ trace_port_open(Port *p, Eterm calling_pid, Eterm drv_name) {
     Eterm mess;
     Eterm* hp;
 
-    if (is_internal_port(p->tracer_proc)) {
+    if (is_internal_port(ERTS_TRACER_PROC(p))) {
 #define LOCAL_HEAP_SIZE (5+6)
 	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
 	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 
 	hp = local_heap;
 
-	mess = TUPLE5(hp, am_trace, calling_pid, am_open, p->id, drv_name);
+	mess = TUPLE5(hp, am_trace, calling_pid, am_open, p->common.id, drv_name);
 	hp += 6;
 	erts_smp_mtx_lock(&smq_mtx);
-	if (p->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(p) & F_TIMESTAMP) {
 	    hp = patch_ts(mess, hp);
 	}
 	/* No fake schedule */
-	send_to_port(NULL, mess, &p->tracer_proc, &p->trace_flags);
+	send_to_port(NULL, mess, &ERTS_TRACER_PROC(p), &ERTS_TRACE_FLAGS(p));
 	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 #undef LOCAL_HEAP_SIZE
 	erts_smp_mtx_unlock(&smq_mtx);
@@ -2584,25 +2588,26 @@ trace_port_open(Port *p, Eterm calling_pid, Eterm drv_name) {
 	size_t sz_data;
 	ERTS_TRACER_REF_TYPE tracer_ref;
 	
-	ASSERT(is_internal_pid(p->tracer_proc)
-	       && internal_pid_index(p->tracer_proc) < erts_max_processes);
+	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
 
 	sz_data = 6 + TS_SIZE(p);
 
-	ERTS_GET_TRACER_REF(tracer_ref, p->tracer_proc, p->trace_flags);
+	ERTS_GET_TRACER_REF(tracer_ref,
+			    ERTS_TRACER_PROC(p),
+			    ERTS_TRACE_FLAGS(p));
 
 	hp = ERTS_ALLOC_SYSMSG_HEAP(sz_data, &bp, &off_heap, tracer_ref);
 
-	mess = TUPLE5(hp, am_trace, calling_pid, am_open, p->id, drv_name);
+	mess = TUPLE5(hp, am_trace, calling_pid, am_open, p->common.id, drv_name);
 	hp += 6;
 
 	erts_smp_mtx_lock(&smq_mtx);
 
-	if (p->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(p) & F_TIMESTAMP) {
 	    hp = patch_ts(mess, hp);
 	}
 
-	ERTS_ENQ_TRACE_MSG(p->id, tracer_ref, mess, bp);
+	ERTS_ENQ_TRACE_MSG(p->common.id, tracer_ref, mess, bp);
 	erts_smp_mtx_unlock(&smq_mtx);
     }
 
@@ -2623,20 +2628,20 @@ trace_port(Port *t_p, Eterm what, Eterm data) {
     ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(t_p)
 		       || erts_thr_progress_is_blocking());
 
-    if (is_internal_port(t_p->tracer_proc)) {
+    if (is_internal_port(ERTS_TRACER_PROC(t_p))) {
 #define LOCAL_HEAP_SIZE (5+5)
 	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
 	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 
 	hp = local_heap;
-	mess = TUPLE4(hp, am_trace, t_p->id, what, data);
+	mess = TUPLE4(hp, am_trace, t_p->common.id, what, data);
 	hp += 5;
 	erts_smp_mtx_lock(&smq_mtx);
-	if (t_p->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(t_p) & F_TIMESTAMP) {
 	    hp = patch_ts(mess, hp);
 	}
 	/* No fake schedule */
-	send_to_port(NULL, mess, &t_p->tracer_proc, &t_p->trace_flags);
+	send_to_port(NULL,mess,&ERTS_TRACER_PROC(t_p),&ERTS_TRACE_FLAGS(t_p));
 	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 #undef LOCAL_HEAP_SIZE
 	erts_smp_mtx_unlock(&smq_mtx);
@@ -2646,25 +2651,26 @@ trace_port(Port *t_p, Eterm what, Eterm data) {
 	size_t sz_data;
 	ERTS_TRACER_REF_TYPE tracer_ref;
 
-	ASSERT(is_internal_pid(t_p->tracer_proc)
-	       && internal_pid_index(t_p->tracer_proc) < erts_max_processes);
+	ASSERT(is_internal_pid(ERTS_TRACER_PROC(t_p)));
 
 	sz_data = 5 + TS_SIZE(t_p);
 
-	ERTS_GET_TRACER_REF(tracer_ref, t_p->tracer_proc, t_p->trace_flags);
+	ERTS_GET_TRACER_REF(tracer_ref,
+			    ERTS_TRACER_PROC(t_p),
+			    ERTS_TRACE_FLAGS(t_p));
 
 	hp = ERTS_ALLOC_SYSMSG_HEAP(sz_data, &bp, &off_heap, tracer_ref);
 
-	mess = TUPLE4(hp, am_trace, t_p->id, what, data);
+	mess = TUPLE4(hp, am_trace, t_p->common.id, what, data);
 	hp += 5;
 
 	erts_smp_mtx_lock(&smq_mtx);
 
-	if (t_p->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(t_p) & F_TIMESTAMP) {
 	    hp = patch_ts(mess, hp);
 	}
 
-	ERTS_ENQ_TRACE_MSG(t_p->id, tracer_ref, mess, bp);
+	ERTS_ENQ_TRACE_MSG(t_p->common.id, tracer_ref, mess, bp);
 	erts_smp_mtx_unlock(&smq_mtx);
     }
 }
@@ -2689,7 +2695,7 @@ trace_sched_ports_where(Port *p, Eterm what, Eterm where) {
     int ws = 5;	
     Eterm sched_id = am_undefined;
     
-    if (is_internal_port(p->tracer_proc)) {
+    if (is_internal_port(ERTS_TRACER_PROC(p))) {
 #define LOCAL_HEAP_SIZE (5+6)
 	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
 	UseTmpHeapNoproc(LOCAL_HEAP_SIZE);
@@ -2704,21 +2710,21 @@ trace_sched_ports_where(Port *p, Eterm what, Eterm where) {
 #else
 		sched_id = make_small(1);
 #endif
-		mess = TUPLE5(hp, am_trace, p->id, what, sched_id, where);
+		mess = TUPLE5(hp, am_trace, p->common.id, what, sched_id, where);
 		ws = 6;
 	} else {
-		mess = TUPLE4(hp, am_trace, p->id, what, where);
+		mess = TUPLE4(hp, am_trace, p->common.id, what, where);
 		ws = 5;
 	}
 	hp += ws;
 	
 	erts_smp_mtx_lock(&smq_mtx);
-	if (p->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(p) & F_TIMESTAMP) {
 	    hp = patch_ts(mess, hp);
 	}
 	
 	/* No fake scheduling */
-	send_to_port(NULL, mess, &p->tracer_proc, &p->trace_flags);
+	send_to_port(NULL, mess, &ERTS_TRACER_PROC(p), &ERTS_TRACE_FLAGS(p));
 	UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 #undef LOCAL_HEAP_SIZE
 	erts_smp_mtx_unlock(&smq_mtx);
@@ -2727,12 +2733,13 @@ trace_sched_ports_where(Port *p, Eterm what, Eterm where) {
     	ErlOffHeap *off_heap;
 	ERTS_TRACER_REF_TYPE tracer_ref;
 
-	ASSERT(is_internal_pid(p->tracer_proc)
-	       && internal_pid_index(p->tracer_proc) < erts_max_processes);
+	ASSERT(is_internal_pid(ERTS_TRACER_PROC(p)));
 	
 	if (IS_TRACED_FL(p, F_TRACE_SCHED_NO)) ws = 6; /* Make place for scheduler id */
 
-	ERTS_GET_TRACER_REF(tracer_ref, p->tracer_proc, p->trace_flags);
+	ERTS_GET_TRACER_REF(tracer_ref,
+			    ERTS_TRACER_PROC(p),
+			    ERTS_TRACE_FLAGS(p));
 
 	hp = ERTS_ALLOC_SYSMSG_HEAP(ws+TS_SIZE(p), &bp, &off_heap, tracer_ref);
 
@@ -2744,19 +2751,19 @@ trace_sched_ports_where(Port *p, Eterm what, Eterm where) {
 #else
 		sched_id = make_small(1);
 #endif
-		mess = TUPLE5(hp, am_trace, p->id, what, sched_id, where);
+		mess = TUPLE5(hp, am_trace, p->common.id, what, sched_id, where);
 	} else {
-		mess = TUPLE4(hp, am_trace, p->id, what, where);
+		mess = TUPLE4(hp, am_trace, p->common.id, what, where);
 	}
 	hp += ws;
 
 	erts_smp_mtx_lock(&smq_mtx);
 
-	if (p->trace_flags & F_TIMESTAMP) {
+	if (ERTS_TRACE_FLAGS(p) & F_TIMESTAMP) {
 	    hp = patch_ts(mess, hp);
 	}
 
-	ERTS_ENQ_TRACE_MSG(p->id, tracer_ref, mess, bp);
+	ERTS_ENQ_TRACE_MSG(p->common.id, tracer_ref, mess, bp);
 	erts_smp_mtx_unlock(&smq_mtx);
     }
 }
@@ -2792,14 +2799,14 @@ profile_runnable_port(Port *p, Eterm status) {
 
     GET_NOW(&Ms, &s, &us);
     timestamp = TUPLE3(hp, make_small(Ms), make_small(s), make_small(us)); hp += 4;
-    msg = TUPLE5(hp, am_profile, p->id, status, count, timestamp); hp += 6;
+    msg = TUPLE5(hp, am_profile, p->common.id, status, count, timestamp); hp += 6;
 
 #ifndef ERTS_SMP
-    profile_send(p->id, msg);
+    profile_send(p->common.id, msg);
     UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 #undef LOCAL_HEAP_SIZE
 #else
-    enqueue_sys_msg_unlocked(SYS_MSG_TYPE_SYSPROF, p->id, NIL, msg, bp);
+    enqueue_sys_msg_unlocked(SYS_MSG_TYPE_SYSPROF, p->common.id, NIL, msg, bp);
 #endif
     erts_smp_mtx_unlock(&smq_mtx);
 }
@@ -2846,13 +2853,13 @@ profile_runnable_proc(Process *p, Eterm status){
 
     GET_NOW(&Ms, &s, &us);
     timestamp = TUPLE3(hp, make_small(Ms), make_small(s), make_small(us)); hp += 4;
-    msg = TUPLE5(hp, am_profile, p->id, status, where, timestamp); hp += 6;
+    msg = TUPLE5(hp, am_profile, p->common.id, status, where, timestamp); hp += 6;
 #ifndef ERTS_SMP
-    profile_send(p->id, msg);
+    profile_send(p->common.id, msg);
     UnUseTmpHeapNoproc(LOCAL_HEAP_SIZE);
 #undef LOCAL_HEAP_SIZE
 #else
-    enqueue_sys_msg_unlocked(SYS_MSG_TYPE_SYSPROF, p->id, NIL, msg, bp);
+    enqueue_sys_msg_unlocked(SYS_MSG_TYPE_SYSPROF, p->common.id, NIL, msg, bp);
 #endif
     erts_smp_mtx_unlock(&smq_mtx);
 }
@@ -2865,16 +2872,19 @@ profile_runnable_proc(Process *p, Eterm status){
 void
 erts_check_my_tracer_proc(Process *p)
 {
-    if (is_internal_pid(p->tracer_proc)) {
-	Process *tracer = erts_pid2proc(p, ERTS_PROC_LOCK_MAIN,
-					p->tracer_proc, ERTS_PROC_LOCK_STATUS);
-	int invalid_tracer = !tracer || !(tracer->trace_flags & F_TRACER);
+    if (is_internal_pid(ERTS_TRACER_PROC(p))) {
+	Process *tracer = erts_pid2proc(p,
+					ERTS_PROC_LOCK_MAIN,
+					ERTS_TRACER_PROC(p),
+					ERTS_PROC_LOCK_STATUS);
+	int invalid_tracer = (!tracer
+			      || !(ERTS_TRACE_FLAGS(tracer) & F_TRACER));
 	if (tracer)
 	    erts_smp_proc_unlock(tracer, ERTS_PROC_LOCK_STATUS);
 	if (invalid_tracer) {
 	    erts_smp_proc_lock(p, ERTS_PROC_LOCKS_ALL_MINOR);
-	    p->trace_flags &= ~TRACEE_FLAGS;
-	    p->tracer_proc = NIL;
+	    ERTS_TRACE_FLAGS(p) &= ~TRACEE_FLAGS;
+	    ERTS_TRACER_PROC(p) = NIL;
 	    erts_smp_proc_unlock(p, ERTS_PROC_LOCKS_ALL_MINOR);
 	}
     }
@@ -3218,7 +3228,7 @@ sys_msg_dispatcher_func(void *unused)
 		proc = erts_pid2proc(NULL, 0, receiver, proc_locks);
 		if (!proc
 		    || (smqp->type == SYS_MSG_TYPE_TRACE
-			&& !(proc->trace_flags & F_TRACER))) {
+			&& !(ERTS_TRACE_FLAGS(proc) & F_TRACER))) {
 		    /* Bad tracer */
 #ifdef DEBUG_PRINTOUTS
 		    if (smqp->type == SYS_MSG_TYPE_TRACE && proc)
@@ -3245,16 +3255,14 @@ sys_msg_dispatcher_func(void *unused)
 		proc = erts_whereis_process(NULL,0,receiver,proc_locks,0);
 		if (!proc)
 		    goto failure;
-		else if (smqp->from == proc->id)
+		else if (smqp->from == proc->common.id)
 		    goto drop_sys_msg;
 		else
 		    goto queue_proc_msg;
 	    }
 	    else if (is_internal_port(receiver)) {
-		port = erts_id2port_sflgs(receiver,
-					  NULL,
-					  0,
-					  ERTS_PORT_SFLGS_INVALID_TRACER_LOOKUP);
+		port = erts_thr_id2port_sflgs(receiver,
+					      ERTS_PORT_SFLGS_INVALID_TRACER_LOOKUP);
 		if (!port)
 		    goto failure;
 		else {
@@ -3268,7 +3276,7 @@ sys_msg_dispatcher_func(void *unused)
 #ifdef DEBUG_PRINTOUTS
 		    erts_fprintf(stderr, "delivered\n");
 #endif
-		    erts_port_release(port);
+		    erts_thr_port_release(port);
 		    if (smqp->bp)
 			free_message_buffer(smqp->bp);
 		}