Merge branch 'rickard/improve-psd/OTP-13428'

* rickard/improve-psd/OTP-13428:
  Improve process/port specific data management

8 files changed, 146 insertions, 140 deletions

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 5d471d168b..74c9d3ee53 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -974,7 +974,7 @@ erts_trace_time_call(Process* c_p, BeamInstr* I, BpDataTime* bdt)
     if (pbt == 0) {
 	/* First call of process to instrumented function */
 	pbt = Alloc(sizeof(process_breakpoint_time_t));
-	(void) ERTS_PROC_SET_CALL_TIME(c_p, ERTS_PROC_LOCK_MAIN, pbt);
+	(void) ERTS_PROC_SET_CALL_TIME(c_p, pbt);
     } else {
 	ASSERT(pbt->pc);
 	/* add time to previous code */
@@ -1598,9 +1598,7 @@ bp_time_unref(BpDataTime* bdt)
 			h_p = erts_pid2proc(NULL, 0, item->pid,
 					    ERTS_PROC_LOCK_MAIN);
 			if (h_p) {
-			    pbt = ERTS_PROC_SET_CALL_TIME(h_p,
-							  ERTS_PROC_LOCK_MAIN,
-							  NULL);
+			    pbt = ERTS_PROC_SET_CALL_TIME(h_p, NULL);
 			    if (pbt) {
 				Free(pbt);
 			    }
diff --git a/erts/emulator/beam/bif.c b/erts/emulator/beam/bif.c
index 37bb28c6f8..97d690db9f 100644
--- a/erts/emulator/beam/bif.c
+++ b/erts/emulator/beam/bif.c
@@ -1567,7 +1567,7 @@ static BIF_RETTYPE process_flag_aux(Process *BIF_P,
 	   scb->n = 0;
        }
 
-       scb = ERTS_PROC_SET_SAVED_CALLS_BUF(rp, ERTS_PROC_LOCK_MAIN, scb);
+       scb = ERTS_PROC_SET_SAVED_CALLS_BUF(rp, scb);
 
        if (!scb)
 	   old_value = make_small(0);
@@ -1595,9 +1595,7 @@ BIF_RETTYPE process_flag_2(BIF_ALIST_2)
       if (is_not_atom(BIF_ARG_2)) {
 	 goto error;
       }
-      old_value = erts_proc_set_error_handler(BIF_P,
-					      ERTS_PROC_LOCK_MAIN,
-					      BIF_ARG_2);
+      old_value = erts_proc_set_error_handler(BIF_P, BIF_ARG_2);
       BIF_RET(old_value);
    }
    else if (BIF_ARG_1 == am_priority) {
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index 8580bc2689..855d5deea1 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -1653,7 +1653,7 @@ allocate_nif_sched_data(Process* proc, int argc)
 	ep->exp.addressv[i] = &ep->exp.code[3];
     }
     ep->exp.code[3] = (BeamInstr) em_call_nif;
-    (void) ERTS_PROC_SET_NIF_TRAP_EXPORT(proc, ERTS_PROC_LOCK_MAIN, ep);
+    (void) ERTS_PROC_SET_NIF_TRAP_EXPORT(proc, ep);
     return ep;
 }
 
diff --git a/erts/emulator/beam/erl_port.h b/erts/emulator/beam/erl_port.h
index fa97707a87..c25e08545e 100644
--- a/erts/emulator/beam/erl_port.h
+++ b/erts/emulator/beam/erl_port.h
@@ -185,7 +185,7 @@ struct _erl_drv_port {
     int control_flags;		 /* Flags for port_control()  */
     ErlDrvPDL port_data_lock;
 
-    ErtsPrtSD *psd;		 /* Port specific data */
+    erts_smp_atomic_t psd;	 /* Port specific data */
     int reds; /* Only used while executing driver callbacks */
 
     struct {
@@ -252,22 +252,51 @@ ERTS_GLB_INLINE void *erts_prtsd_set(Port *p, int ix, void *new);
 ERTS_GLB_INLINE void *
 erts_prtsd_get(Port *prt, int ix)
 {
-    return prt->psd ? prt->psd->data[ix] : NULL;
+    ErtsPrtSD *psd = (ErtsPrtSD *) erts_smp_atomic_read_nob(&prt->psd);
+    if (!psd)
+	return NULL;
+    ERTS_SMP_DATA_DEPENDENCY_READ_MEMORY_BARRIER;
+    return psd->data[ix];
 }
 
 ERTS_GLB_INLINE void *
 erts_prtsd_set(Port *prt, int ix, void *data)
 {
-    if (prt->psd) {
-	void *old = prt->psd->data[ix];
-	prt->psd->data[ix] = data;
+    ErtsPrtSD *psd, *new_psd;
+    void *old;
+    int i;
+
+    psd = (ErtsPrtSD *) erts_smp_atomic_read_nob(&prt->psd);
+
+    if (psd) {
+#ifdef ERTS_SMP
+#ifdef ETHR_ORDERED_READ_DEPEND
+	ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
+#else
+	ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreStore);
+#endif
+#endif
+	old = psd->data[ix];
+	psd->data[ix] = data;
 	return old;
     }
-    else {
-	prt->psd = erts_alloc(ERTS_ALC_T_PRTSD, sizeof(ErtsPrtSD));
-	prt->psd->data[ix] = data;
+
+    if (!data)
 	return NULL;
-    }
+
+    new_psd = erts_alloc(ERTS_ALC_T_PRTSD, sizeof(ErtsPrtSD));
+    for (i = 0; i < ERTS_PRTSD_SIZE; i++)
+	new_psd->data[i] = NULL;
+    psd = (ErtsPrtSD *) erts_smp_atomic_cmpxchg_mb(&prt->psd,
+						   (erts_aint_t) new_psd,
+						   (erts_aint_t) NULL);
+    if (psd)
+	erts_free(ERTS_ALC_T_PRTSD, new_psd);
+    else
+	psd = new_psd;
+    old = psd->data[ix];
+    psd->data[ix] = data;
+    return old;
 }
 
 #endif
diff --git a/erts/emulator/beam/erl_process.c b/erts/emulator/beam/erl_process.c
index 63a610e4aa..1fb8502ebe 100644
--- a/erts/emulator/beam/erl_process.c
+++ b/erts/emulator/beam/erl_process.c
@@ -687,45 +687,36 @@ erts_pre_init_process(void)
 	= "DEBUG_WAIT_COMPLETED";
 
 #ifdef ERTS_ENABLE_LOCK_CHECK
- {
-     int ix;
 
-     erts_psd_required_locks[ERTS_PSD_ERROR_HANDLER].get_locks
-	 = ERTS_PSD_ERROR_HANDLER_BUF_GET_LOCKS;
-     erts_psd_required_locks[ERTS_PSD_ERROR_HANDLER].set_locks
-	 = ERTS_PSD_ERROR_HANDLER_BUF_SET_LOCKS;
+    erts_psd_required_locks[ERTS_PSD_ERROR_HANDLER].get_locks
+	= ERTS_PSD_ERROR_HANDLER_BUF_GET_LOCKS;
+    erts_psd_required_locks[ERTS_PSD_ERROR_HANDLER].set_locks
+	= ERTS_PSD_ERROR_HANDLER_BUF_SET_LOCKS;
 
-     erts_psd_required_locks[ERTS_PSD_SAVED_CALLS_BUF].get_locks
-	 = ERTS_PSD_SAVED_CALLS_BUF_GET_LOCKS;
-     erts_psd_required_locks[ERTS_PSD_SAVED_CALLS_BUF].set_locks
-	 = ERTS_PSD_SAVED_CALLS_BUF_SET_LOCKS;
+    erts_psd_required_locks[ERTS_PSD_SAVED_CALLS_BUF].get_locks
+	= ERTS_PSD_SAVED_CALLS_BUF_GET_LOCKS;
+    erts_psd_required_locks[ERTS_PSD_SAVED_CALLS_BUF].set_locks
+	= ERTS_PSD_SAVED_CALLS_BUF_SET_LOCKS;
 
-     erts_psd_required_locks[ERTS_PSD_SCHED_ID].get_locks
-	 = ERTS_PSD_SCHED_ID_GET_LOCKS;
-     erts_psd_required_locks[ERTS_PSD_SCHED_ID].set_locks
-	 = ERTS_PSD_SCHED_ID_SET_LOCKS;
+    erts_psd_required_locks[ERTS_PSD_SCHED_ID].get_locks
+	= ERTS_PSD_SCHED_ID_GET_LOCKS;
+    erts_psd_required_locks[ERTS_PSD_SCHED_ID].set_locks
+	= ERTS_PSD_SCHED_ID_SET_LOCKS;
 
-     erts_psd_required_locks[ERTS_PSD_CALL_TIME_BP].get_locks
-	 = ERTS_PSD_CALL_TIME_BP_GET_LOCKS;
-     erts_psd_required_locks[ERTS_PSD_CALL_TIME_BP].set_locks
-	 = ERTS_PSD_CALL_TIME_BP_SET_LOCKS;
+    erts_psd_required_locks[ERTS_PSD_CALL_TIME_BP].get_locks
+	= ERTS_PSD_CALL_TIME_BP_GET_LOCKS;
+    erts_psd_required_locks[ERTS_PSD_CALL_TIME_BP].set_locks
+	= ERTS_PSD_CALL_TIME_BP_SET_LOCKS;
 
-     erts_psd_required_locks[ERTS_PSD_DELAYED_GC_TASK_QS].get_locks
-	 = ERTS_PSD_DELAYED_GC_TASK_QS_GET_LOCKS;
-     erts_psd_required_locks[ERTS_PSD_DELAYED_GC_TASK_QS].set_locks
-	 = ERTS_PSD_DELAYED_GC_TASK_QS_SET_LOCKS;
+    erts_psd_required_locks[ERTS_PSD_DELAYED_GC_TASK_QS].get_locks
+	= ERTS_PSD_DELAYED_GC_TASK_QS_GET_LOCKS;
+    erts_psd_required_locks[ERTS_PSD_DELAYED_GC_TASK_QS].set_locks
+	= ERTS_PSD_DELAYED_GC_TASK_QS_SET_LOCKS;
 
-     erts_psd_required_locks[ERTS_PSD_NIF_TRAP_EXPORT].get_locks
-	 = ERTS_PSD_NIF_TRAP_EXPORT_GET_LOCKS;
-     erts_psd_required_locks[ERTS_PSD_NIF_TRAP_EXPORT].set_locks
-	 = ERTS_PSD_NIF_TRAP_EXPORT_SET_LOCKS;
-
-     /* Check that we have locks for all entries */
-     for (ix = 0; ix < ERTS_PSD_SIZE; ix++) {
-	 ERTS_SMP_LC_ASSERT(erts_psd_required_locks[ix].get_locks);
-	 ERTS_SMP_LC_ASSERT(erts_psd_required_locks[ix].set_locks);
-     }
- }
+    erts_psd_required_locks[ERTS_PSD_NIF_TRAP_EXPORT].get_locks
+	= ERTS_PSD_NIF_TRAP_EXPORT_GET_LOCKS;
+    erts_psd_required_locks[ERTS_PSD_NIF_TRAP_EXPORT].set_locks
+	= ERTS_PSD_NIF_TRAP_EXPORT_SET_LOCKS;
 #endif
 }
 
@@ -1314,46 +1305,25 @@ erts_proclist_destroy(ErtsProcList *plp)
 }
 
 void *
-erts_psd_set_init(Process *p, ErtsProcLocks plocks, int ix, void *data)
+erts_psd_set_init(Process *p, int ix, void *data)
 {
     void *old;
-    ErtsProcLocks xplocks;
-    int refc = 0;
-    ErtsPSD *psd = erts_alloc(ERTS_ALC_T_PSD, sizeof(ErtsPSD));
+    ErtsPSD *psd, *new_psd;
     int i;
-    for (i = 0; i < ERTS_PSD_SIZE; i++)
-	psd->data[i] = NULL;
 
-    ERTS_SMP_LC_ASSERT(plocks);
-    ERTS_SMP_LC_ASSERT(plocks == erts_proc_lc_my_proc_locks(p));
+    new_psd = erts_alloc(ERTS_ALC_T_PSD, sizeof(ErtsPSD));
+    for (i = 0; i < ERTS_PSD_SIZE; i++)
+	new_psd->data[i] = NULL;
 
-    xplocks = ERTS_PROC_LOCKS_ALL;
-    xplocks &= ~plocks;
-    if (xplocks && erts_smp_proc_trylock(p, xplocks) == EBUSY) {
-	if (xplocks & ERTS_PROC_LOCK_MAIN) {
-	    erts_proc_inc_refc(p);
-	    erts_smp_proc_unlock(p, plocks);
-	    erts_smp_proc_lock(p, ERTS_PROC_LOCKS_ALL);
-	    refc = 1;
-	}
-	else {
-	    if (plocks & ERTS_PROC_LOCKS_ALL_MINOR)
-		erts_smp_proc_unlock(p, plocks & ERTS_PROC_LOCKS_ALL_MINOR);
-	    erts_smp_proc_lock(p, ERTS_PROC_LOCKS_ALL_MINOR);
-	}
-    }
-    if (!p->psd)
-	p->psd = psd;
-    if (xplocks)
-	erts_smp_proc_unlock(p, xplocks);
-    if (refc)
-	erts_proc_dec_refc(p);
-    ASSERT(p->psd);
-    if (p->psd != psd)
-	erts_free(ERTS_ALC_T_PSD, psd);
-    old = p->psd->data[ix];
-    p->psd->data[ix] = data;
-    ERTS_SMP_LC_ASSERT(plocks == erts_proc_lc_my_proc_locks(p));
+    psd = (ErtsPSD *) erts_smp_atomic_cmpxchg_mb(&p->psd,
+						 (erts_aint_t) new_psd,
+						 (erts_aint_t) NULL);
+    if (psd)
+	erts_free(ERTS_ALC_T_PSD, new_psd);
+    else
+	psd = new_psd;
+    old = psd->data[ix];
+    psd->data[ix] = data;
     return old;
 }
 
@@ -9796,10 +9766,7 @@ Process *schedule(Process *p, int calls)
 
 	if (erts_sched_stat.enabled) {
 	    int prio;
-	    UWord old = ERTS_PROC_SCHED_ID(p,
-					  (ERTS_PROC_LOCK_MAIN
-					   | ERTS_PROC_LOCK_STATUS),
-					  (UWord) esdp->no);
+	    UWord old = ERTS_PROC_SCHED_ID(p, (UWord) esdp->no);
 	    int migrated = old && old != esdp->no;
 
 #ifdef ERTS_DIRTY_SCHEDULERS
@@ -10472,7 +10439,7 @@ save_gc_task(Process *c_p, ErtsProcSysTask *st, int prio)
 	qs->q[PRIORITY_NORMAL] = NULL;
 	qs->q[PRIORITY_LOW] = NULL;
 	qs->q[prio] = st;
-	(void) ERTS_PROC_SET_DELAYED_GC_TASK_QS(c_p, ERTS_PROC_LOCK_MAIN, qs);
+	(void) ERTS_PROC_SET_DELAYED_GC_TASK_QS(c_p, qs);
     }
     else {
 	if (!qs->q[prio]) {
@@ -10619,7 +10586,7 @@ erts_set_gc_state(Process *c_p, int enable)
 
     erts_smp_proc_unlock(c_p, ERTS_PROC_LOCK_STATUS);
 
-    (void) ERTS_PROC_SET_DELAYED_GC_TASK_QS(c_p, ERTS_PROC_LOCK_MAIN, NULL);
+    (void) ERTS_PROC_SET_DELAYED_GC_TASK_QS(c_p, NULL);
 
     if (dgc_tsk_qs)
 	proc_sys_task_queues_free(dgc_tsk_qs);
@@ -11105,7 +11072,7 @@ erl_create_process(Process* parent, /* Parent of process (default group leader).
     p->mbuf = NULL;
     p->msg_frag = NULL;
     p->mbuf_sz = 0;
-    p->psd = NULL;
+    erts_smp_atomic_init_nob(&p->psd, (erts_aint_t) NULL);
     p->dictionary = NULL;
     p->seq_trace_lastcnt = 0;
     p->seq_trace_clock = 0;
@@ -11274,7 +11241,7 @@ void erts_init_empty_process(Process *p)
     p->mbuf = NULL;
     p->msg_frag = NULL;
     p->mbuf_sz = 0;
-    p->psd = NULL;
+    erts_smp_atomic_init_nob(&p->psd, (erts_aint_t) NULL);
     ERTS_P_MONITORS(p) = NULL;
     ERTS_P_LINKS(p) = NULL;         /* List of links */
     p->nodes_monitors = NULL;
@@ -11444,14 +11411,17 @@ static void
 delete_process(Process* p)
 {
     Eterm *heap;
+    ErtsPSD *psd;
     VERBOSE(DEBUG_PROCESSES, ("Removing process: %T\n",p->common.id));
     VERBOSE(DEBUG_SHCOPY, ("[pid=%T] delete process: %p %p %p %p\n", p->common.id,
                            HEAP_START(p), HEAP_END(p), OLD_HEAP(p), OLD_HEND(p)));
 
     /* Cleanup psd */
 
-    if (p->psd)
-	erts_free(ERTS_ALC_T_PSD, p->psd);
+    psd = (ErtsPSD *) erts_smp_atomic_read_nob(&p->psd);
+
+    if (psd)
+	erts_free(ERTS_ALC_T_PSD, psd);
 
     /* Clean binaries and funs */
     erts_cleanup_offheap(&p->off_heap);
@@ -12530,9 +12500,9 @@ erts_continue_exit_process(Process *p)
     }
     
     dep = (p->flags & F_DISTRIBUTION) ? erts_this_dist_entry : NULL;
-    scb = ERTS_PROC_SET_SAVED_CALLS_BUF(p, ERTS_PROC_LOCKS_ALL, NULL);
-    pbt = ERTS_PROC_SET_CALL_TIME(p, ERTS_PROC_LOCKS_ALL, NULL);
-    nif_export = ERTS_PROC_SET_NIF_TRAP_EXPORT(p, ERTS_PROC_LOCKS_ALL, NULL);
+    scb = ERTS_PROC_SET_SAVED_CALLS_BUF(p, NULL);
+    pbt = ERTS_PROC_SET_CALL_TIME(p, NULL);
+    nif_export = ERTS_PROC_SET_NIF_TRAP_EXPORT(p, NULL);
 
     erts_smp_proc_unlock(p, ERTS_PROC_LOCKS_ALL);
 #ifdef BM_COUNTERS
diff --git a/erts/emulator/beam/erl_process.h b/erts/emulator/beam/erl_process.h
index c88bd7056c..c07337b325 100644
--- a/erts/emulator/beam/erl_process.h
+++ b/erts/emulator/beam/erl_process.h
@@ -818,8 +818,8 @@ typedef struct {
 #define ERTS_PSD_ERROR_HANDLER_BUF_GET_LOCKS ERTS_PROC_LOCK_MAIN
 #define ERTS_PSD_ERROR_HANDLER_BUF_SET_LOCKS ERTS_PROC_LOCK_MAIN
 
-#define ERTS_PSD_SAVED_CALLS_BUF_GET_LOCKS ERTS_PROC_LOCK_MAIN
-#define ERTS_PSD_SAVED_CALLS_BUF_SET_LOCKS ERTS_PROC_LOCK_MAIN
+#define ERTS_PSD_SAVED_CALLS_BUF_GET_LOCKS ((ErtsProcLocks) 0)
+#define ERTS_PSD_SAVED_CALLS_BUF_SET_LOCKS ((ErtsProcLocks) 0)
 
 #define ERTS_PSD_SCHED_ID_GET_LOCKS ERTS_PROC_LOCK_STATUS
 #define ERTS_PSD_SCHED_ID_SET_LOCKS ERTS_PROC_LOCK_STATUS
@@ -830,8 +830,8 @@ typedef struct {
 #define ERTS_PSD_DELAYED_GC_TASK_QS_GET_LOCKS ERTS_PROC_LOCK_MAIN
 #define ERTS_PSD_DELAYED_GC_TASK_QS_SET_LOCKS ERTS_PROC_LOCK_MAIN
 
-#define ERTS_PSD_NIF_TRAP_EXPORT_GET_LOCKS ERTS_PROC_LOCK_MAIN
-#define ERTS_PSD_NIF_TRAP_EXPORT_SET_LOCKS ERTS_PROC_LOCK_MAIN
+#define ERTS_PSD_NIF_TRAP_EXPORT_GET_LOCKS ((ErtsProcLocks) 0)
+#define ERTS_PSD_NIF_TRAP_EXPORT_SET_LOCKS ((ErtsProcLocks) 0)
 
 typedef struct {
     ErtsProcLocks get_locks;
@@ -1026,7 +1026,7 @@ struct process {
     ErlHeapFragment* live_hf_end;
     ErtsMessage *msg_frag;	/* Pointer to message fragment list */
     Uint mbuf_sz;		/* Total size of heap fragments and message fragments */
-    ErtsPSD *psd;		/* Rarely used process specific data */
+    erts_smp_atomic_t psd;		/* Rarely used process specific data */
 
     Uint64 bin_vheap_sz;	/* Virtual heap block size for binaries */
     Uint64 bin_old_vheap_sz;	/* Virtual old heap block size for binaries */
@@ -1903,18 +1903,19 @@ do {									\
 #define ERTS_SMP_LC_CHK_RUNQ_LOCK(RQ, L)
 #endif
 
-void *erts_psd_set_init(Process *p, ErtsProcLocks plocks, int ix, void *data);
+void *erts_psd_set_init(Process *p, int ix, void *data);
 
 ERTS_GLB_INLINE void *
 erts_psd_get(Process *p, int ix);
 ERTS_GLB_INLINE void *
-erts_psd_set(Process *p, ErtsProcLocks plocks, int ix, void *new);
+erts_psd_set(Process *p, int ix, void *new);
 
 #if ERTS_GLB_INLINE_INCL_FUNC_DEF
 
 ERTS_GLB_INLINE void *
 erts_psd_get(Process *p, int ix)
 {
+    ErtsPSD *psd;
 #if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK)
     ErtsProcLocks locks = erts_proc_lc_my_proc_locks(p);
     if (ERTS_LC_PSD_ANY_LOCK == erts_psd_required_locks[ix].get_locks)
@@ -1925,17 +1926,19 @@ erts_psd_get(Process *p, int ix)
 			   || erts_thr_progress_is_blocking());
     }
 #endif
+
+    psd = (ErtsPSD *) erts_smp_atomic_read_nob(&p->psd);
     ASSERT(0 <= ix && ix < ERTS_PSD_SIZE);
-    return p->psd ? p->psd->data[ix] : NULL;
+    if (!psd)
+	return NULL;
+    ERTS_SMP_DATA_DEPENDENCY_READ_MEMORY_BARRIER;
+    return psd->data[ix];
 }
 
-
-/*
- * NOTE: erts_psd_set() might release and reacquire locks on 'p'.
- */
 ERTS_GLB_INLINE void *
-erts_psd_set(Process *p, ErtsProcLocks plocks, int ix, void *data)
+erts_psd_set(Process *p, int ix, void *data)
 {
+    ErtsPSD *psd;
 #if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK)
     ErtsProcLocks locks = erts_proc_lc_my_proc_locks(p);
     if (ERTS_LC_PSD_ANY_LOCK == erts_psd_required_locks[ix].set_locks)
@@ -1946,50 +1949,56 @@ erts_psd_set(Process *p, ErtsProcLocks plocks, int ix, void *data)
 			   || erts_thr_progress_is_blocking());
     }
 #endif
+    psd = (ErtsPSD *) erts_smp_atomic_read_nob(&p->psd);
     ASSERT(0 <= ix && ix < ERTS_PSD_SIZE);
-    if (p->psd) {
-	void *old = p->psd->data[ix];
-	p->psd->data[ix] = data;
+    if (psd) {
+	void *old;
+#ifdef ERTS_SMP
+#ifdef ETHR_ORDERED_READ_DEPEND
+	ETHR_MEMBAR(ETHR_LoadStore|ETHR_StoreStore);
+#else
+	ETHR_MEMBAR(ETHR_LoadLoad|ETHR_LoadStore|ETHR_StoreStore);
+#endif
+#endif
+	old = psd->data[ix];
+	psd->data[ix] = data;
 	return old;
     }
-    else {
-	if (!data)
-	    return NULL;
-	else
-	    return erts_psd_set_init(p, plocks, ix, data);
-    }
+
+    if (!data)
+	return NULL;
+
+    return erts_psd_set_init(p, ix, data);
 }
 
 #endif
 
-#define ERTS_PROC_SCHED_ID(P, L, ID) \
-  ((UWord) erts_psd_set((P), (L), ERTS_PSD_SCHED_ID, (void *) (ID)))
+#define ERTS_PROC_SCHED_ID(P, ID) \
+  ((UWord) erts_psd_set((P), ERTS_PSD_SCHED_ID, (void *) (ID)))
 
 #define ERTS_PROC_GET_SAVED_CALLS_BUF(P) \
   ((struct saved_calls *) erts_psd_get((P), ERTS_PSD_SAVED_CALLS_BUF))
-#define ERTS_PROC_SET_SAVED_CALLS_BUF(P, L, SCB) \
-  ((struct saved_calls *) erts_psd_set((P), (L), ERTS_PSD_SAVED_CALLS_BUF, (void *) (SCB)))
+#define ERTS_PROC_SET_SAVED_CALLS_BUF(P, SCB) \
+  ((struct saved_calls *) erts_psd_set((P), ERTS_PSD_SAVED_CALLS_BUF, (void *) (SCB)))
 
 #define ERTS_PROC_GET_CALL_TIME(P) \
   ((process_breakpoint_time_t *) erts_psd_get((P), ERTS_PSD_CALL_TIME_BP))
-#define ERTS_PROC_SET_CALL_TIME(P, L, PBT) \
-  ((process_breakpoint_time_t *) erts_psd_set((P), (L), ERTS_PSD_CALL_TIME_BP, (void *) (PBT)))
+#define ERTS_PROC_SET_CALL_TIME(P, PBT) \
+  ((process_breakpoint_time_t *) erts_psd_set((P), ERTS_PSD_CALL_TIME_BP, (void *) (PBT)))
 
 #define ERTS_PROC_GET_DELAYED_GC_TASK_QS(P) \
     ((ErtsProcSysTaskQs *) erts_psd_get((P), ERTS_PSD_DELAYED_GC_TASK_QS))
-#define ERTS_PROC_SET_DELAYED_GC_TASK_QS(P, L, PBT) \
-    ((ErtsProcSysTaskQs *) erts_psd_set((P), (L), ERTS_PSD_DELAYED_GC_TASK_QS, (void *) (PBT)))
+#define ERTS_PROC_SET_DELAYED_GC_TASK_QS(P, PBT) \
+    ((ErtsProcSysTaskQs *) erts_psd_set((P), ERTS_PSD_DELAYED_GC_TASK_QS, (void *) (PBT)))
 
 #define ERTS_PROC_GET_NIF_TRAP_EXPORT(P) \
     erts_psd_get((P), ERTS_PSD_NIF_TRAP_EXPORT)
-#define ERTS_PROC_SET_NIF_TRAP_EXPORT(P, L, NTE) \
-    erts_psd_set((P), (L), ERTS_PSD_NIF_TRAP_EXPORT, (void *) (NTE))
+#define ERTS_PROC_SET_NIF_TRAP_EXPORT(P, NTE) \
+    erts_psd_set((P), ERTS_PSD_NIF_TRAP_EXPORT, (void *) (NTE))
 
 
 ERTS_GLB_INLINE Eterm erts_proc_get_error_handler(Process *p);
-ERTS_GLB_INLINE Eterm erts_proc_set_error_handler(Process *p,
-						  ErtsProcLocks plocks,
-						  Eterm handler);
+ERTS_GLB_INLINE Eterm erts_proc_set_error_handler(Process *p, Eterm handler);
 
 #if ERTS_GLB_INLINE_INCL_FUNC_DEF
 ERTS_GLB_INLINE Eterm
@@ -2005,13 +2014,13 @@ erts_proc_get_error_handler(Process *p)
 }
 
 ERTS_GLB_INLINE Eterm
-erts_proc_set_error_handler(Process *p, ErtsProcLocks plocks, Eterm handler)
+erts_proc_set_error_handler(Process *p, Eterm handler)
 {
     void *old_val;
     void *new_val;
     ASSERT(is_atom(handler));
     new_val = (handler == am_error_handler) ? NULL : (void *) (UWord) handler;
-    old_val = erts_psd_set(p, plocks, ERTS_PSD_ERROR_HANDLER, new_val);
+    old_val = erts_psd_set(p, ERTS_PSD_ERROR_HANDLER, new_val);
     if (!old_val)
 	return am_error_handler;
     else {
diff --git a/erts/emulator/beam/erl_process_dump.c b/erts/emulator/beam/erl_process_dump.c
index 39c36ee7a9..73552b28de 100644
--- a/erts/emulator/beam/erl_process_dump.c
+++ b/erts/emulator/beam/erl_process_dump.c
@@ -103,7 +103,7 @@ Uint erts_process_memory(Process *p, int incl_msg_inq) {
     size += p->arity * sizeof(p->arg_reg[0]);
   }
 
-  if (p->psd)
+  if (erts_smp_atomic_read_nob(&p->psd) != (erts_aint_t) NULL)
     size += sizeof(ErtsPSD);
 
   scb = ERTS_PROC_GET_SAVED_CALLS_BUF(p);
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
index 324c05c766..b2fd8984fd 100644
--- a/erts/emulator/beam/io.c
+++ b/erts/emulator/beam/io.c
@@ -397,7 +397,7 @@ static Port *create_port(char *name,
     prt->common.u.alive.reg = NULL;
     ERTS_PTMR_INIT(prt);
     erts_port_task_handle_init(&prt->timeout_task);
-    prt->psd = NULL;
+    erts_smp_atomic_init_nob(&prt->psd, (erts_aint_t) NULL);
     prt->async_open_port = NULL;
     prt->drv_data = (SWord) 0;
     prt->os_pid = -1;
@@ -3531,6 +3531,7 @@ terminate_port(Port *prt)
     Eterm connected_id = NIL /* Initialize to silence compiler */;
     erts_driver_t *drv;
     erts_aint32_t state;
+    ErtsPrtSD *psd;
 
     ERTS_SMP_CHK_NO_PROC_LOCKS;
     ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
@@ -3584,8 +3585,9 @@ terminate_port(Port *prt)
 
     erts_cleanup_port_data(prt);
 
-    if (prt->psd)
-	erts_free(ERTS_ALC_T_PRTSD, prt->psd);
+    psd = (ErtsPrtSD *) erts_smp_atomic_read_nob(&prt->psd);
+    if (psd)
+	erts_free(ERTS_ALC_T_PRTSD, psd);
 
     ASSERT(prt->dist_entry == NULL);