erts: Replace usage of all erts_smp prefixes to just erts

14 files changed, 277 insertions, 278 deletions

diff --git a/erts/emulator/sys/common/erl_check_io.c b/erts/emulator/sys/common/erl_check_io.c
index 3e029303a7..834b77eb58 100644
--- a/erts/emulator/sys/common/erl_check_io.c
+++ b/erts/emulator/sys/common/erl_check_io.c
@@ -97,16 +97,16 @@ typedef char EventStateFlags;
 static struct pollset_info
 {
     ErtsPollSet ps;
-    erts_smp_atomic_t in_poll_wait;        /* set while doing poll */
+    erts_atomic_t in_poll_wait;        /* set while doing poll */
     struct {
 	int six; /* start index */
 	int eix; /* end index */
-	erts_smp_atomic32_t no;
+	erts_atomic32_t no;
 	int size;
 	ErtsSysFdType *array;
     } active_fd;
     struct removed_fd* removed_list;       /* list of deselected fd's*/
-    erts_smp_spinlock_t removed_list_lock;
+    erts_spinlock_t removed_list_lock;
 }pollset;
 #define NUM_OF_POLLSETS 1
 
@@ -150,11 +150,11 @@ static int max_fds = -1;
 #endif
 #define DRV_EV_STATE_LOCK_CNT 16
 static union {
-    erts_smp_mtx_t lck;
+    erts_mtx_t lck;
     byte _cache_line_alignment[64];
 }drv_ev_state_locks[DRV_EV_STATE_LOCK_CNT];
 
-static ERTS_INLINE erts_smp_mtx_t* fd_mtx(ErtsSysFdType fd)
+static ERTS_INLINE erts_mtx_t* fd_mtx(ErtsSysFdType fd)
 {
     int hash = (int)fd;
 # ifndef ERTS_SYS_CONTINOUS_FD_NUMBERS
@@ -165,15 +165,15 @@ static ERTS_INLINE erts_smp_mtx_t* fd_mtx(ErtsSysFdType fd)
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
 
-static erts_smp_atomic_t drv_ev_state_len;
+static erts_atomic_t drv_ev_state_len;
 static ErtsDrvEventState *drv_ev_state;
-static erts_smp_mtx_t drv_ev_state_grow_lock; /* prevent lock-hogging of racing growers */
+static erts_mtx_t drv_ev_state_grow_lock; /* prevent lock-hogging of racing growers */
 
 #else
 static SafeHash drv_ev_state_tab;
 static int num_state_prealloc;
 static ErtsDrvEventState *state_prealloc_first;
-erts_smp_spinlock_t state_prealloc_lock;
+erts_spinlock_t state_prealloc_lock;
 
 static ERTS_INLINE ErtsDrvEventState *hash_get_drv_ev_state(ErtsSysFdType fd)
 {
@@ -244,7 +244,7 @@ static ERTS_INLINE void
 init_iotask(ErtsIoTask *io_task)
 {
     erts_port_task_handle_init(&io_task->task);
-    erts_smp_atomic_init_nob(&io_task->executed_time, ~((erts_aint_t) 0));
+    erts_atomic_init_nob(&io_task->executed_time, ~((erts_aint_t) 0));
 }
 
 static ERTS_INLINE int
@@ -252,7 +252,7 @@ is_iotask_active(ErtsIoTask *io_task, erts_aint_t current_cio_time)
 {    
     if (erts_port_task_is_scheduled(&io_task->task))
 	return 1;
-    if (erts_smp_atomic_read_nob(&io_task->executed_time) == current_cio_time)
+    if (erts_atomic_read_nob(&io_task->executed_time) == current_cio_time)
 	return 1;
     return 0;
 }
@@ -325,8 +325,8 @@ static ERTS_INLINE void
 remember_removed(ErtsDrvEventState *state, struct pollset_info* psi)
 {
     struct removed_fd *fdlp;
-    ERTS_SMP_LC_ASSERT(erts_smp_lc_mtx_is_locked(fd_mtx(state->fd)));
-    if (erts_smp_atomic_read_nob(&psi->in_poll_wait)) {
+    ERTS_LC_ASSERT(erts_lc_mtx_is_locked(fd_mtx(state->fd)));
+    if (erts_atomic_read_nob(&psi->in_poll_wait)) {
 	state->remove_cnt++;
 	ASSERT(state->remove_cnt > 0);
 	fdlp = removed_fd_alloc();
@@ -336,10 +336,10 @@ remember_removed(ErtsDrvEventState *state, struct pollset_info* psi)
     #ifndef ERTS_SYS_CONTINOUS_FD_NUMBERS
 	fdlp->state = state;
     #endif
-	erts_smp_spin_lock(&psi->removed_list_lock);
+	erts_spin_lock(&psi->removed_list_lock);
 	fdlp->next = psi->removed_list;
 	psi->removed_list = fdlp;
-	erts_smp_spin_unlock(&psi->removed_list_lock);
+	erts_spin_unlock(&psi->removed_list_lock);
     }
 }
 
@@ -363,29 +363,29 @@ forget_removed(struct pollset_info* psi)
 
     /* Fast track: if (atomic_ptr(removed_list)==NULL) return; */
 
-    erts_smp_spin_lock(&psi->removed_list_lock);
+    erts_spin_lock(&psi->removed_list_lock);
     fdlp = psi->removed_list;
     psi->removed_list = NULL;
-    erts_smp_spin_unlock(&psi->removed_list_lock);
+    erts_spin_unlock(&psi->removed_list_lock);
 
     while (fdlp) {
         ErtsResource* resource = NULL;
 	erts_driver_t* drv_ptr = NULL;
-	erts_smp_mtx_t* mtx;
+	erts_mtx_t* mtx;
 	ErtsSysFdType fd;
 	ErtsDrvEventState *state;
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
 	fd = fdlp->fd;
 	mtx = fd_mtx(fd);
-	erts_smp_mtx_lock(mtx);
+	erts_mtx_lock(mtx);
 	state = &drv_ev_state[(int) fd];
 #else
 	state = fdlp->state;
 	fd = state->fd;
 	ASSERT(fd == fdlp->fd);
 	mtx = fd_mtx(fd);
-	erts_smp_mtx_lock(mtx);
+	erts_mtx_lock(mtx);
 #endif
 	ASSERT(state->remove_cnt > 0);
 	if (--state->remove_cnt == 0) {
@@ -420,7 +420,7 @@ forget_removed(struct pollset_info* psi)
 		ASSERT(0);
 	    }
 	}
-	erts_smp_mtx_unlock(mtx);
+	erts_mtx_unlock(mtx);
 	if (drv_ptr) {
 	    int was_unmasked = erts_block_fpe();
 	    DTRACE1(driver_stop_select, drv_ptr->name);
@@ -450,15 +450,15 @@ grow_drv_ev_state(int min_ix)
     int old_len;
     int new_len;
 
-    erts_smp_mtx_lock(&drv_ev_state_grow_lock);
-    old_len = erts_smp_atomic_read_nob(&drv_ev_state_len);
+    erts_mtx_lock(&drv_ev_state_grow_lock);
+    old_len = erts_atomic_read_nob(&drv_ev_state_len);
     if (min_ix >= old_len) {
         new_len = erts_poll_new_table_len(old_len, min_ix + 1);
         if (new_len > max_fds)
             new_len = max_fds;
 
 	for (i=0; i<DRV_EV_STATE_LOCK_CNT; i++) { /* lock all fd's */
-	    erts_smp_mtx_lock(&drv_ev_state_locks[i].lck);
+	    erts_mtx_lock(&drv_ev_state_locks[i].lck);
 	}
 	drv_ev_state = (drv_ev_state
 			? erts_realloc(ERTS_ALC_T_DRV_EV_STATE,
@@ -479,14 +479,14 @@ grow_drv_ev_state(int min_ix)
 	    drv_ev_state[i].type = ERTS_EV_TYPE_NONE;
 	    drv_ev_state[i].flags = 0;
 	}
-	erts_smp_atomic_set_nob(&drv_ev_state_len, new_len);
+	erts_atomic_set_nob(&drv_ev_state_len, new_len);
 	for (i=0; i<DRV_EV_STATE_LOCK_CNT; i++) {
-	    erts_smp_mtx_unlock(&drv_ev_state_locks[i].lck);
+	    erts_mtx_unlock(&drv_ev_state_locks[i].lck);
 	}
     }
     /*else already grown by racing thread */
 
-    erts_smp_mtx_unlock(&drv_ev_state_grow_lock);
+    erts_mtx_unlock(&drv_ev_state_grow_lock);
 }
 #endif /* ERTS_SYS_CONTINOUS_FD_NUMBERS */
 
@@ -544,7 +544,7 @@ deselect(ErtsDrvEventState *state, int mode)
 {
     int do_wake = 0;
     ErtsPollEvents rm_events;
-    ERTS_SMP_LC_ASSERT(erts_smp_lc_mtx_is_locked(fd_mtx(state->fd)));
+    ERTS_LC_ASSERT(erts_lc_mtx_is_locked(fd_mtx(state->fd)));
     ASSERT(state->events);
 
     abort_tasks(state, mode);
@@ -616,9 +616,9 @@ check_fd_cleanup(ErtsDrvEventState *state,
 {
     erts_aint_t current_cio_time;
 
-    ERTS_SMP_LC_ASSERT(erts_smp_lc_mtx_is_locked(fd_mtx(state->fd)));
+    ERTS_LC_ASSERT(erts_lc_mtx_is_locked(fd_mtx(state->fd)));
 
-    current_cio_time = erts_smp_atomic_read_acqb(&erts_check_io_time);
+    current_cio_time = erts_atomic_read_acqb(&erts_check_io_time);
     *free_select = NULL;
     if (state->driver.select
 	&& (state->type != ERTS_EV_TYPE_DRV_SEL)
@@ -671,7 +671,7 @@ check_cleanup_active_fd(ErtsSysFdType fd,
 {
     ErtsDrvEventState *state;
     int active = 0;
-    erts_smp_mtx_t *mtx = fd_mtx(fd);
+    erts_mtx_t *mtx = fd_mtx(fd);
     void *free_select = NULL;
     void *free_nif = NULL;
 #if ERTS_CIO_HAVE_DRV_EVENT
@@ -681,7 +681,7 @@ check_cleanup_active_fd(ErtsSysFdType fd,
     ErtsPollEvents evon = 0, evoff = 0;
 #endif
 
-    erts_smp_mtx_lock(mtx);
+    erts_mtx_lock(mtx);
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
     state = &drv_ev_state[(int) fd];
@@ -802,7 +802,7 @@ check_cleanup_active_fd(ErtsSysFdType fd,
 
     }
 
-    erts_smp_mtx_unlock(mtx);
+    erts_mtx_unlock(mtx);
 
     if (free_select)
 	free_drv_select_data(free_select);
@@ -836,7 +836,7 @@ check_cleanup_active_fds(erts_aint_t current_cio_time, int may_sleep)
 {
     int six = pollset.active_fd.six;
     int eix = pollset.active_fd.eix;
-    erts_aint32_t no = erts_smp_atomic32_read_dirty(&pollset.active_fd.no);
+    erts_aint32_t no = erts_atomic32_read_dirty(&pollset.active_fd.no);
     int size = pollset.active_fd.size;
     int ix = six;
 #if ERTS_CIO_DEFER_ACTIVE_EVENTS
@@ -891,7 +891,7 @@ check_cleanup_active_fds(erts_aint_t current_cio_time, int may_sleep)
 
     pollset.active_fd.six = six;
     pollset.active_fd.eix = eix;
-    erts_smp_atomic32_set_relb(&pollset.active_fd.no, no);
+    erts_atomic32_set_relb(&pollset.active_fd.no, no);
 }
 
 static void grow_active_fds(void)
@@ -920,8 +920,8 @@ add_active_fd(ErtsSysFdType fd)
     
     pollset.active_fd.array[eix] = fd;
 
-    erts_smp_atomic32_set_relb(&pollset.active_fd.no,
-			       (erts_smp_atomic32_read_dirty(&pollset.active_fd.no)
+    erts_atomic32_set_relb(&pollset.active_fd.no,
+			       (erts_atomic32_read_dirty(&pollset.active_fd.no)
 				+ 1));
 
     eix++;
@@ -961,10 +961,10 @@ ERTS_CIO_EXPORT(driver_select)(ErlDrvPort ix,
     if (prt == ERTS_INVALID_ERL_DRV_PORT)
 	return -1;
 
-    ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+    ERTS_LC_ASSERT(erts_lc_is_port_locked(prt));
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
-    if ((unsigned)fd >= (unsigned)erts_smp_atomic_read_nob(&drv_ev_state_len)) {
+    if ((unsigned)fd >= (unsigned)erts_atomic_read_nob(&drv_ev_state_len)) {
 	if (fd < 0) {
 	    return -1;    
 	}
@@ -976,7 +976,7 @@ ERTS_CIO_EXPORT(driver_select)(ErlDrvPort ix,
     }
 #endif
 
-    erts_smp_mtx_lock(fd_mtx(fd));
+    erts_mtx_lock(fd_mtx(fd));
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
     state = &drv_ev_state[(int) fd];
@@ -1157,7 +1157,7 @@ done:
                      &free_nif);
 
 done_unknown:
-    erts_smp_mtx_unlock(fd_mtx(fd));
+    erts_mtx_unlock(fd_mtx(fd));
     if (stop_select_fn) {
 	int was_unmasked = erts_block_fpe();
 	DTRACE1(driver_stop_select, name);
@@ -1206,7 +1206,7 @@ ERTS_CIO_EXPORT(enif_select)(ErlNifEnv* env,
     ASSERT(!(resource->monitors && resource->monitors->is_dying));
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
-    if ((unsigned)fd >= (unsigned)erts_smp_atomic_read_nob(&drv_ev_state_len)) {
+    if ((unsigned)fd >= (unsigned)erts_atomic_read_nob(&drv_ev_state_len)) {
 	if (fd < 0) {
 	    return INT_MIN | ERL_NIF_SELECT_INVALID_EVENT;
 	}
@@ -1218,7 +1218,7 @@ ERTS_CIO_EXPORT(enif_select)(ErlNifEnv* env,
     }
 #endif
 
-    erts_smp_mtx_lock(fd_mtx(fd));
+    erts_mtx_lock(fd_mtx(fd));
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
     state = &drv_ev_state[(int) fd];
@@ -1412,7 +1412,7 @@ done:
                      &free_nif);
 
 done_unknown:
-    erts_smp_mtx_unlock(fd_mtx(fd));
+    erts_mtx_unlock(fd_mtx(fd));
     if (call_stop) {
         erts_resource_stop(resource, (ErlNifEvent)fd, 1);
         if (call_stop == CALL_STOP_AND_RELEASE) {
@@ -1458,10 +1458,10 @@ ERTS_CIO_EXPORT(driver_event)(ErlDrvPort ix,
     if (prt == ERTS_INVALID_ERL_DRV_PORT)
 	return -1;
 
-    ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+    ERTS_LC_ASSERT(erts_lc_is_port_locked(prt));
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
-    if ((unsigned)fd >= (unsigned)erts_smp_atomic_read_nob(&drv_ev_state_len)) {
+    if ((unsigned)fd >= (unsigned)erts_atomic_read_nob(&drv_ev_state_len)) {
 	if (fd < 0)
 	    return -1;    
 	if (fd >= max_fds) {
@@ -1472,7 +1472,7 @@ ERTS_CIO_EXPORT(driver_event)(ErlDrvPort ix,
     }
 #endif
 
-    erts_smp_mtx_lock(fd_mtx(fd));
+    erts_mtx_lock(fd_mtx(fd));
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
     state = &drv_ev_state[(int) fd];
@@ -1565,7 +1565,7 @@ done:
 		     &free_select,
                      &free_nif);
 
-    erts_smp_mtx_unlock(fd_mtx(fd));
+    erts_mtx_unlock(fd_mtx(fd));
 
     if (free_select)
 	free_drv_select_data(free_select);
@@ -1995,7 +1995,7 @@ iready(Eterm id, ErtsDrvEventState *state, erts_aint_t current_cio_time)
 				 ERTS_PORT_TASK_INPUT,
 				 current_cio_time)) {
 	ErtsIoTask *iotask = &state->driver.select->iniotask;
-	erts_smp_atomic_set_nob(&iotask->executed_time, current_cio_time);
+	erts_atomic_set_nob(&iotask->executed_time, current_cio_time);
 	if (erts_port_task_schedule(id,
 				    &iotask->task,
 				    ERTS_PORT_TASK_INPUT,
@@ -2013,7 +2013,7 @@ oready(Eterm id, ErtsDrvEventState *state, erts_aint_t current_cio_time)
 				 ERTS_PORT_TASK_OUTPUT,
 				 current_cio_time)) {
 	ErtsIoTask *iotask = &state->driver.select->outiotask;
-	erts_smp_atomic_set_nob(&iotask->executed_time, current_cio_time);
+	erts_atomic_set_nob(&iotask->executed_time, current_cio_time);
 	if (erts_port_task_schedule(id,
 				    &iotask->task,
 				    ERTS_PORT_TASK_OUTPUT,
@@ -2069,7 +2069,7 @@ send_event_tuple(struct erts_nif_select_event* e, ErtsResource* resource,
     erts_queue_message(rp, rp_locks, mp, tuple, am_system);
 
     if (rp_locks)
-        erts_smp_proc_unlock(rp, rp_locks);
+        erts_proc_unlock(rp, rp_locks);
 }
 
 
@@ -2082,7 +2082,7 @@ eready(Eterm id, ErtsDrvEventState *state, ErlDrvEventData event_data,
 				 ERTS_PORT_TASK_EVENT,
 				 current_cio_time)) {
 	ErtsIoTask *iotask = &state->driver.event->iotask;
-	erts_smp_atomic_set_nob(&iotask->executed_time, current_cio_time);
+	erts_atomic_set_nob(&iotask->executed_time, current_cio_time);
 	if (erts_port_task_schedule(id,
 				    &iotask->task,
 				    ERTS_PORT_TASK_EVENT,
@@ -2157,9 +2157,9 @@ ERTS_CIO_EXPORT(erts_check_io)(int do_wait)
      * erts_check_io_time, since only one thread can
      * check io at a time.
      */
-    current_cio_time = erts_smp_atomic_read_dirty(&erts_check_io_time);
+    current_cio_time = erts_atomic_read_dirty(&erts_check_io_time);
     current_cio_time++;
-    erts_smp_atomic_set_relb(&erts_check_io_time, current_cio_time);
+    erts_atomic_set_relb(&erts_check_io_time, current_cio_time);
 
     check_cleanup_active_fds(current_cio_time,
                              timeout_time != ERTS_POLL_NO_TIMEOUT);
@@ -2168,11 +2168,11 @@ ERTS_CIO_EXPORT(erts_check_io)(int do_wait)
     erts_lc_check_exact(NULL, 0); /* No locks should be locked */
 #endif
 
-    pollres_len = erts_smp_atomic32_read_dirty(&pollset.active_fd.no) + ERTS_CHECK_IO_POLL_RES_LEN;
+    pollres_len = erts_atomic32_read_dirty(&pollset.active_fd.no) + ERTS_CHECK_IO_POLL_RES_LEN;
 
     pollres = erts_alloc(ERTS_ALC_T_TMP, sizeof(ErtsPollResFd)*pollres_len);
 
-    erts_smp_atomic_set_nob(&pollset.in_poll_wait, 1);
+    erts_atomic_set_nob(&pollset.in_poll_wait, 1);
 
     poll_ret = ERTS_CIO_POLL_WAIT(pollset.ps, pollres, &pollres_len, timeout_time);
 
@@ -2194,7 +2194,7 @@ ERTS_CIO_EXPORT(erts_check_io)(int do_wait)
 
 
     if (poll_ret != 0) {
-	erts_smp_atomic_set_nob(&pollset.in_poll_wait, 0);
+	erts_atomic_set_nob(&pollset.in_poll_wait, 0);
 	forget_removed(&pollset);
 	erts_free(ERTS_ALC_T_TMP, pollres);
 	if (poll_ret == EAGAIN) {
@@ -2220,7 +2220,7 @@ ERTS_CIO_EXPORT(erts_check_io)(int do_wait)
 	ErtsSysFdType fd = (ErtsSysFdType) pollres[i].fd;
 	ErtsDrvEventState *state;
 
-	erts_smp_mtx_lock(fd_mtx(fd));
+	erts_mtx_lock(fd_mtx(fd));
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
 	state = &drv_ev_state[ (int) fd];
@@ -2327,7 +2327,7 @@ ERTS_CIO_EXPORT(erts_check_io)(int do_wait)
                 add_active_fd(state->fd);
             }
 
-            erts_smp_mtx_unlock(fd_mtx(fd));
+            erts_mtx_unlock(fd_mtx(fd));
             if (is_not_nil(in.pid)) {
                 send_event_tuple(&in, resource, am_ready_input);
             }
@@ -2374,11 +2374,11 @@ ERTS_CIO_EXPORT(erts_check_io)(int do_wait)
 	}
 
 	next_pollres:;
-	erts_smp_mtx_unlock(fd_mtx(fd));
+	erts_mtx_unlock(fd_mtx(fd));
         next_pollres_unlocked:;
     }
 
-    erts_smp_atomic_set_nob(&pollset.in_poll_wait, 0);
+    erts_atomic_set_nob(&pollset.in_poll_wait, 0);
     erts_free(ERTS_ALC_T_TMP, pollres);
     forget_removed(&pollset);
 }
@@ -2474,16 +2474,16 @@ static int drv_ev_state_cmp(void *des1, void *des2)
 static void *drv_ev_state_alloc(void *des_tmpl)
 {
     ErtsDrvEventState *evstate;
-    erts_smp_spin_lock(&state_prealloc_lock);
+    erts_spin_lock(&state_prealloc_lock);
     if (state_prealloc_first == NULL) {
-	erts_smp_spin_unlock(&state_prealloc_lock);
+	erts_spin_unlock(&state_prealloc_lock);
 	evstate = (ErtsDrvEventState *) 
 	    erts_alloc(ERTS_ALC_T_DRV_EV_STATE, sizeof(ErtsDrvEventState));
     } else {
 	evstate = state_prealloc_first;
 	state_prealloc_first = (ErtsDrvEventState *) evstate->hb.next;
 	--num_state_prealloc;
-	erts_smp_spin_unlock(&state_prealloc_lock);
+	erts_spin_unlock(&state_prealloc_lock);
     }
     /* XXX: Already valid data if prealloced, could ignore template! */
     *evstate = *((ErtsDrvEventState *) des_tmpl);
@@ -2493,11 +2493,11 @@ static void *drv_ev_state_alloc(void *des_tmpl)
 
 static void drv_ev_state_free(void *des)
 {
-    erts_smp_spin_lock(&state_prealloc_lock);
+    erts_spin_lock(&state_prealloc_lock);
     ((ErtsDrvEventState *) des)->hb.next = &state_prealloc_first->hb;
     state_prealloc_first = (ErtsDrvEventState *) des;
     ++num_state_prealloc;
-    erts_smp_spin_unlock(&state_prealloc_lock);
+    erts_spin_unlock(&state_prealloc_lock);
 }
 #endif
 
@@ -2508,15 +2508,15 @@ ERTS_CIO_EXPORT(erts_init_check_io)(void)
                                ERL_NIF_SELECT_STOP_SCHEDULED |
                                ERL_NIF_SELECT_INVALID_EVENT |
                                ERL_NIF_SELECT_FAILED)) == 0);
-    erts_smp_atomic_init_nob(&erts_check_io_time, 0);
-    erts_smp_atomic_init_nob(&pollset.in_poll_wait, 0);
+    erts_atomic_init_nob(&erts_check_io_time, 0);
+    erts_atomic_init_nob(&pollset.in_poll_wait, 0);
 
     ERTS_CIO_POLL_INIT();
     pollset.ps = ERTS_CIO_NEW_POLLSET();
 
     pollset.active_fd.six = 0;
     pollset.active_fd.eix = 0;
-    erts_smp_atomic32_init_nob(&pollset.active_fd.no, 0);
+    erts_atomic32_init_nob(&pollset.active_fd.no, 0);
     pollset.active_fd.size = ERTS_ACTIVE_FD_INC;
     pollset.active_fd.array = erts_alloc(ERTS_ALC_T_ACTIVE_FD_ARR,
 					 sizeof(ErtsSysFdType)*ERTS_ACTIVE_FD_INC);
@@ -2531,20 +2531,20 @@ ERTS_CIO_EXPORT(erts_init_check_io)(void)
 
     init_removed_fd_alloc();
     pollset.removed_list = NULL;
-    erts_smp_spinlock_init(&pollset.removed_list_lock, "pollset_rm_list", NIL,
+    erts_spinlock_init(&pollset.removed_list_lock, "pollset_rm_list", NIL,
         ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
     {
         int i;
         for (i=0; i<DRV_EV_STATE_LOCK_CNT; i++) {
-            erts_smp_mtx_init(&drv_ev_state_locks[i].lck, "drv_ev_state", make_small(i),
+            erts_mtx_init(&drv_ev_state_locks[i].lck, "drv_ev_state", make_small(i),
                 ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
         }
     }
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
     max_fds = ERTS_CIO_POLL_MAX_FDS();
-    erts_smp_atomic_init_nob(&drv_ev_state_len, 0);
+    erts_atomic_init_nob(&drv_ev_state_len, 0);
     drv_ev_state = NULL;
-    erts_smp_mtx_init(&drv_ev_state_grow_lock, "drv_ev_state_grow", NIL,
+    erts_mtx_init(&drv_ev_state_grow_lock, "drv_ev_state_grow", NIL,
         ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
 #else
     {
@@ -2555,7 +2555,7 @@ ERTS_CIO_EXPORT(erts_init_check_io)(void)
 	hf.free = &drv_ev_state_free;
 	num_state_prealloc = 0;
 	state_prealloc_first = NULL;
-	erts_smp_spinlock_init(&state_prealloc_lock,"state_prealloc", NIL,
+	erts_spinlock_init(&state_prealloc_lock,"state_prealloc", NIL,
         ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
 
 	safe_hash_init(ERTS_ALC_T_DRV_EV_STATE, &drv_ev_state_tab, "drv_ev_state_tab",
@@ -2582,7 +2582,7 @@ ERTS_CIO_EXPORT(erts_check_io_size)(void)
     ERTS_CIO_POLL_INFO(pollset.ps, &pi);
     res = pi.memory_size;
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
-    res += sizeof(ErtsDrvEventState) * erts_smp_atomic_read_nob(&drv_ev_state_len);
+    res += sizeof(ErtsDrvEventState) * erts_atomic_read_nob(&drv_ev_state_len);
 #else
     res += safe_hash_table_sz(&drv_ev_state_tab);
     {
@@ -2590,9 +2590,9 @@ ERTS_CIO_EXPORT(erts_check_io_size)(void)
 	safe_hash_get_info(&hi, &drv_ev_state_tab);
 	res += hi.objs * sizeof(ErtsDrvEventState);
     }
-    erts_smp_spin_lock(&state_prealloc_lock);
+    erts_spin_lock(&state_prealloc_lock);
     res += num_state_prealloc * sizeof(ErtsDrvEventState);
-    erts_smp_spin_unlock(&state_prealloc_lock);
+    erts_spin_unlock(&state_prealloc_lock);
 #endif
     return res;
 }
@@ -2605,8 +2605,8 @@ ERTS_CIO_EXPORT(erts_check_io_info)(void *proc)
     Uint sz, *szp, *hp, **hpp, memory_size;
     Sint i;
     ErtsPollInfo pi;
-    erts_aint_t cio_time = erts_smp_atomic_read_acqb(&erts_check_io_time);
-    int active_fds = (int) erts_smp_atomic32_read_acqb(&pollset.active_fd.no);
+    erts_aint_t cio_time = erts_atomic_read_acqb(&erts_check_io_time);
+    int active_fds = (int) erts_atomic32_read_acqb(&pollset.active_fd.no);
 
     while (1) {
 	erts_aint_t post_cio_time;
@@ -2614,8 +2614,8 @@ ERTS_CIO_EXPORT(erts_check_io_info)(void *proc)
 
 	ERTS_CIO_POLL_INFO(pollset.ps, &pi);
 
-	post_cio_time = erts_smp_atomic_read_mb(&erts_check_io_time);
-	post_active_fds = (int) erts_smp_atomic32_read_acqb(&pollset.active_fd.no);
+	post_cio_time = erts_atomic_read_mb(&erts_check_io_time);
+	post_active_fds = (int) erts_atomic32_read_acqb(&pollset.active_fd.no);
 	if (cio_time == post_cio_time && active_fds == post_active_fds)
 	    break;
 	cio_time = post_cio_time;
@@ -2624,7 +2624,7 @@ ERTS_CIO_EXPORT(erts_check_io_info)(void *proc)
 
     memory_size = pi.memory_size;
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
-    memory_size += sizeof(ErtsDrvEventState) * erts_smp_atomic_read_nob(&drv_ev_state_len);
+    memory_size += sizeof(ErtsDrvEventState) * erts_atomic_read_nob(&drv_ev_state_len);
 #else
     memory_size += safe_hash_table_sz(&drv_ev_state_tab);
     {
@@ -2632,9 +2632,9 @@ ERTS_CIO_EXPORT(erts_check_io_info)(void *proc)
 	safe_hash_get_info(&hi, &drv_ev_state_tab);
 	memory_size += hi.objs * sizeof(ErtsDrvEventState);
     }
-    erts_smp_spin_lock(&state_prealloc_lock);
+    erts_spin_lock(&state_prealloc_lock);
     memory_size += num_state_prealloc * sizeof(ErtsDrvEventState);
-    erts_smp_spin_unlock(&state_prealloc_lock);
+    erts_spin_unlock(&state_prealloc_lock);
 #endif
 
     hpp = NULL;
@@ -3046,7 +3046,7 @@ ERTS_CIO_EXPORT(erts_check_io_debug)(ErtsCheckIoDebugInfo *ciodip)
     erts_lc_check_exact(NULL, 0); /* No locks should be locked */
 #endif
 
-    erts_smp_thr_progress_block(); /* stop the world to avoid messy locking */
+    erts_thr_progress_block(); /* stop the world to avoid messy locking */
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
     counters.epep = erts_alloc(ERTS_ALC_T_TMP, sizeof(ErtsPollEvents)*max_fds);
@@ -3059,7 +3059,7 @@ ERTS_CIO_EXPORT(erts_check_io_debug)(ErtsCheckIoDebugInfo *ciodip)
     counters.no_driver_event_structs = 0;
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
-    len = erts_smp_atomic_read_nob(&drv_ev_state_len);
+    len = erts_atomic_read_nob(&drv_ev_state_len);
     for (fd = 0; fd < len; fd++) {
 	doit_erts_check_io_debug((void *) &drv_ev_state[fd], (void *) &counters);
     }
@@ -3071,7 +3071,7 @@ ERTS_CIO_EXPORT(erts_check_io_debug)(ErtsCheckIoDebugInfo *ciodip)
     safe_hash_for_each(&drv_ev_state_tab, &doit_erts_check_io_debug, (void *) &counters);
 #endif
 
-    erts_smp_thr_progress_unblock();
+    erts_thr_progress_unblock();
 
     ciodip->no_used_fds = counters.used_fds;
     ciodip->no_driver_select_structs = counters.no_driver_select_structs;
diff --git a/erts/emulator/sys/common/erl_check_io.h b/erts/emulator/sys/common/erl_check_io.h
index d74eb764d2..777942a473 100644
--- a/erts/emulator/sys/common/erl_check_io.h
+++ b/erts/emulator/sys/common/erl_check_io.h
@@ -76,11 +76,11 @@ void erts_lcnt_update_cio_locks(int enable);
 
 #endif
 
-extern erts_smp_atomic_t erts_check_io_time;
+extern erts_atomic_t erts_check_io_time;
 
 typedef struct {
     ErtsPortTaskHandle task;
-    erts_smp_atomic_t executed_time;
+    erts_atomic_t executed_time;
 } ErtsIoTask;
 
 ERTS_GLB_INLINE void erts_io_notify_port_task_executed(ErtsPortTaskHandle *pthp);
@@ -91,8 +91,8 @@ ERTS_GLB_INLINE void
 erts_io_notify_port_task_executed(ErtsPortTaskHandle *pthp)
 {
     ErtsIoTask *itp = (ErtsIoTask *) (((char *) pthp) - offsetof(ErtsIoTask, task));
-    erts_aint_t ci_time = erts_smp_atomic_read_acqb(&erts_check_io_time);
-    erts_smp_atomic_set_relb(&itp->executed_time, ci_time);
+    erts_aint_t ci_time = erts_atomic_read_acqb(&erts_check_io_time);
+    erts_atomic_set_relb(&itp->executed_time, ci_time);
 }
 
 #endif
diff --git a/erts/emulator/sys/common/erl_mmap.c b/erts/emulator/sys/common/erl_mmap.c
index 214ed01c82..a9c6e72c5f 100644
--- a/erts/emulator/sys/common/erl_mmap.c
+++ b/erts/emulator/sys/common/erl_mmap.c
@@ -24,7 +24,6 @@
 #define ERTS_WANT_MEM_MAPPERS
 #include "sys.h"
 #include "erl_process.h"
-#include "erl_smp.h"
 #include "atom.h"
 #include "erl_mmap.h"
 #include <stddef.h>
@@ -62,11 +61,11 @@
     (((UWord) (PTR)) - ((UWord) mm->sa.bot)			\
      < ((UWord) mm->sua.top) - ((UWord) mm->sa.bot))
 #define ERTS_MMAP_IN_SUPERALIGNED_AREA(PTR)				\
-    (ERTS_SMP_LC_ASSERT(erts_lc_mtx_is_locked(&mm->mtx)),	\
+    (ERTS_LC_ASSERT(erts_lc_mtx_is_locked(&mm->mtx)),	\
      (((UWord) (PTR)) - ((UWord) mm->sa.bot)			\
       < ((UWord) mm->sa.top) - ((UWord) mm->sa.bot)))
 #define ERTS_MMAP_IN_SUPERUNALIGNED_AREA(PTR)				\
-    (ERTS_SMP_LC_ASSERT(erts_lc_mtx_is_locked(&mm->mtx)),	\
+    (ERTS_LC_ASSERT(erts_lc_mtx_is_locked(&mm->mtx)),	\
      (((UWord) (PTR)) - ((UWord) mm->sua.bot)			\
       < ((UWord) mm->sua.top) - ((UWord) mm->sua.bot)))
 
@@ -199,10 +198,10 @@ static ErtsMMapOp mmap_ops[ERTS_MMAP_OP_RINGBUF_SZ];
 
 #define ERTS_MMAP_OP_LCK(RES, IN_SZ, OUT_SZ)			\
     do {							\
-	erts_smp_mtx_lock(&mm->mtx);			\
+	erts_mtx_lock(&mm->mtx);			\
 	ERTS_MMAP_OP_START((IN_SZ));				\
 	ERTS_MMAP_OP_END((RES), (OUT_SZ));			\
-	erts_smp_mtx_unlock(&mm->mtx);			\
+	erts_mtx_unlock(&mm->mtx);			\
     } while (0)
 
 #define ERTS_MUNMAP_OP(PTR, SZ)					\
@@ -221,9 +220,9 @@ static ErtsMMapOp mmap_ops[ERTS_MMAP_OP_RINGBUF_SZ];
 
 #define ERTS_MUNMAP_OP_LCK(PTR, SZ)				\
     do {							\
-	erts_smp_mtx_lock(&mm->mtx);			\
+	erts_mtx_lock(&mm->mtx);			\
 	ERTS_MUNMAP_OP((PTR), (SZ));				\
-	erts_smp_mtx_unlock(&mm->mtx);			\
+	erts_mtx_unlock(&mm->mtx);			\
     } while (0)
 
 #define ERTS_MREMAP_OP_START(OLD_PTR, OLD_SZ, IN_SZ)		\
@@ -249,10 +248,10 @@ static ErtsMMapOp mmap_ops[ERTS_MMAP_OP_RINGBUF_SZ];
 
 #define ERTS_MREMAP_OP_LCK(RES, OLD_PTR, OLD_SZ, IN_SZ, OUT_SZ)	\
     do {							\
-	erts_smp_mtx_lock(&mm->mtx);			\
+	erts_mtx_lock(&mm->mtx);			\
 	ERTS_MREMAP_OP_START((OLD_PTR), (OLD_SZ), (IN_SZ));	\
 	ERTS_MREMAP_OP_END((RES), (OUT_SZ));			\
-	erts_smp_mtx_unlock(&mm->mtx);			\
+	erts_mtx_unlock(&mm->mtx);			\
     } while (0)
 
 #define ERTS_MMAP_OP_ABORT()					\
@@ -321,7 +320,7 @@ struct ErtsMemMapper_ {
 #if HAVE_MMAP && (!defined(MAP_ANON) && !defined(MAP_ANONYMOUS))
     int mmap_fd;
 #endif
-    erts_smp_mtx_t mtx;
+    erts_mtx_t mtx;
     struct {
 	char *free_list;
 	char *unused_start;
@@ -1536,7 +1535,7 @@ erts_mmap(ErtsMemMapper* mm, Uint32 flags, UWord *sizep)
 	ErtsFreeSegDesc *desc;
 	Uint32 superaligned = (ERTS_MMAPFLG_SUPERALIGNED & flags);
 
-	erts_smp_mtx_lock(&mm->mtx);
+	erts_mtx_lock(&mm->mtx);
 
 	ERTS_MMAP_OP_START(*sizep);
 
@@ -1660,7 +1659,7 @@ erts_mmap(ErtsMemMapper* mm, Uint32 flags, UWord *sizep)
 	}
 
 	ERTS_MMAP_OP_ABORT();
-	erts_smp_mtx_unlock(&mm->mtx);
+	erts_mtx_unlock(&mm->mtx);
     }
 
 #if ERTS_HAVE_OS_MMAP
@@ -1724,13 +1723,13 @@ supercarrier_success:
 #endif
 
     ERTS_MMAP_OP_END(seg, asize);
-    erts_smp_mtx_unlock(&mm->mtx);
+    erts_mtx_unlock(&mm->mtx);
 
     *sizep = asize;
     return (void *) seg;
 
 supercarrier_reserve_failure:
-    erts_smp_mtx_unlock(&mm->mtx);
+    erts_mtx_unlock(&mm->mtx);
     *sizep = 0;
     return NULL;
 }
@@ -1760,7 +1759,7 @@ erts_munmap(ErtsMemMapper* mm, Uint32 flags, void *ptr, UWord size)
 	start = (char *) ptr;
 	end = start + size;
 
-	erts_smp_mtx_lock(&mm->mtx);
+	erts_mtx_lock(&mm->mtx);
 
 	ERTS_MUNMAP_OP(ptr, size);
 
@@ -1829,7 +1828,7 @@ erts_munmap(ErtsMemMapper* mm, Uint32 flags, void *ptr, UWord size)
 	    if (unres_sz)
 		mm->unreserve_physical(((char *) ptr) + ad_sz, unres_sz);
 
-            erts_smp_mtx_unlock(&mm->mtx);
+            erts_mtx_unlock(&mm->mtx);
 	}
     }
 }
@@ -1948,12 +1947,12 @@ erts_mremap(ErtsMemMapper* mm,
 		 ? ERTS_SUPERALIGNED_CEILING(*sizep)
 		 : ERTS_PAGEALIGNED_CEILING(*sizep));
 
-	erts_smp_mtx_lock(&mm->mtx);
+	erts_mtx_lock(&mm->mtx);
 
 	if (ERTS_MMAP_IN_SUPERALIGNED_AREA(ptr)
 	    ? (!superaligned && lookup_free_seg(&mm->sua.map, asize))
 	    : (superaligned && lookup_free_seg(&mm->sa.map, asize))) {
-	    erts_smp_mtx_unlock(&mm->mtx);
+	    erts_mtx_unlock(&mm->mtx);
 	    /*
 	     * Segment currently in wrong area (due to a previous memory
 	     * shortage), move it to the right area.
@@ -2068,7 +2067,7 @@ erts_mremap(ErtsMemMapper* mm,
 	}
 
 	ERTS_MMAP_OP_ABORT();
-	erts_smp_mtx_unlock(&mm->mtx);
+	erts_mtx_unlock(&mm->mtx);
 
 	/* Failed to resize... */
     }
@@ -2090,14 +2089,14 @@ supercarrier_resize_success:
 #endif
 
     ERTS_MREMAP_OP_END(new_ptr, asize);
-    erts_smp_mtx_unlock(&mm->mtx);
+    erts_mtx_unlock(&mm->mtx);
 
     *sizep = asize;
     return new_ptr;
 
 supercarrier_reserve_failure:
     ERTS_MREMAP_OP_END(NULL, old_size);
-    erts_smp_mtx_unlock(&mm->mtx);
+    erts_mtx_unlock(&mm->mtx);
     *sizep = old_size;
     return NULL;
     
@@ -2212,7 +2211,7 @@ erts_mmap_init(ErtsMemMapper* mm, ErtsMMapInit *init, int executable)
 	erts_exit(1, "erts_mmap: Failed to open /dev/zero\n");
 #endif
 
-    erts_smp_mtx_init(&mm->mtx, "erts_mmap", NIL,
+    erts_mtx_init(&mm->mtx, "erts_mmap", NIL,
         ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
     if (is_first_call) {
         erts_mtx_init(&am.init_mutex, "mmap_init_atoms", NIL,
@@ -2407,7 +2406,7 @@ Eterm erts_mmap_info(ErtsMemMapper* mm,
     Eterm res = THE_NON_VALUE;
 
     if (!hpp) {
-        erts_smp_mtx_lock(&mm->mtx);
+        erts_mtx_lock(&mm->mtx);
         emis->sizes[0] = mm->size.supercarrier.total;
         emis->sizes[1] = mm->sa.top  - mm->sa.bot;
         emis->sizes[2] = mm->sua.top - mm->sua.bot;
@@ -2423,7 +2422,7 @@ Eterm erts_mmap_info(ErtsMemMapper* mm,
         emis->segs[5] = mm->sua.map.nseg;
 
         emis->os_used = mm->size.os.used;
-        erts_smp_mtx_unlock(&mm->mtx);
+        erts_mtx_unlock(&mm->mtx);
     }
 
     list[lix] = erts_mmap_info_options(mm, "option ", print_to_p, print_to_arg,
@@ -2543,14 +2542,14 @@ Eterm erts_mmap_debug_info(Process* p)
         Eterm *hp, *hp_end;
         Uint may_need;
 
-        erts_smp_mtx_lock(&mm->mtx);
+        erts_mtx_lock(&mm->mtx);
         values[0] = (UWord)mm->sa.bot;
         values[1] = (UWord)mm->sa.top;
         values[2] = (UWord)mm->sua.bot;
         values[3] = (UWord)mm->sua.top;
         sa_list = build_free_seg_list(p, &mm->sa.map);
         sua_list = build_free_seg_list(p, &mm->sua.map);
-        erts_smp_mtx_unlock(&mm->mtx);
+        erts_mtx_unlock(&mm->mtx);
 
         may_need = 4*(2+3+2) + 2*(2+3);
         hp = HAlloc(p, may_need);
diff --git a/erts/emulator/sys/common/erl_mseg.c b/erts/emulator/sys/common/erl_mseg.c
index d5b2fa87e4..bf6de9b13a 100644
--- a/erts/emulator/sys/common/erl_mseg.c
+++ b/erts/emulator/sys/common/erl_mseg.c
@@ -339,11 +339,11 @@ mseg_recreate(ErtsMsegAllctr_t *ma, Uint flags, void *old_seg, UWord old_size, U
 do {									\
     if ((MA)->is_thread_safe)						\
 	ERTS_LC_ASSERT(erts_lc_mtx_is_locked(&(MA)->mtx)		\
-		       || erts_smp_thr_progress_is_blocking()		\
+		       || erts_thr_progress_is_blocking()		\
 		       || ERTS_IS_CRASH_DUMPING);			\
     else								\
 	ERTS_LC_ASSERT((MA)->ix == (int) erts_get_scheduler_id()	\
-		       || erts_smp_thr_progress_is_blocking()		\
+		       || erts_thr_progress_is_blocking()		\
 		       || ERTS_IS_CRASH_DUMPING);			\
 } while (0)
 #else
diff --git a/erts/emulator/sys/common/erl_poll.c b/erts/emulator/sys/common/erl_poll.c
index 4171770f02..7d26839b0f 100644
--- a/erts/emulator/sys/common/erl_poll.c
+++ b/erts/emulator/sys/common/erl_poll.c
@@ -150,9 +150,9 @@ int ERTS_SELECT(int nfds, ERTS_fd_set *readfds, ERTS_fd_set *writefds,
 #define ERTS_POLL_COALESCE_KP_RES (ERTS_POLL_USE_KQUEUE || ERTS_POLL_USE_EPOLL)
 
 #define ERTS_POLLSET_LOCK(PS) \
-  erts_smp_mtx_lock(&(PS)->mtx)
+  erts_mtx_lock(&(PS)->mtx)
 #define ERTS_POLLSET_UNLOCK(PS) \
-  erts_smp_mtx_unlock(&(PS)->mtx)
+  erts_mtx_unlock(&(PS)->mtx)
 
 #define ERTS_POLLSET_SET_POLLED_CHK(PS) \
   ((int) erts_atomic32_xchg_nob(&(PS)->polled, (erts_aint32_t) 1))
@@ -163,11 +163,11 @@ int ERTS_SELECT(int nfds, ERTS_fd_set *readfds, ERTS_fd_set *writefds,
 
 
 #define ERTS_POLLSET_SET_HAVE_UPDATE_REQUESTS(PS) \
-  erts_smp_atomic32_set_nob(&(PS)->have_update_requests, (erts_aint32_t) 1)
+  erts_atomic32_set_nob(&(PS)->have_update_requests, (erts_aint32_t) 1)
 #define ERTS_POLLSET_UNSET_HAVE_UPDATE_REQUESTS(PS) \
-  erts_smp_atomic32_set_nob(&(PS)->have_update_requests, (erts_aint32_t) 0)
+  erts_atomic32_set_nob(&(PS)->have_update_requests, (erts_aint32_t) 0)
 #define ERTS_POLLSET_HAVE_UPDATE_REQUESTS(PS) \
-  ((int) erts_smp_atomic32_read_nob(&(PS)->have_update_requests))
+  ((int) erts_atomic32_read_nob(&(PS)->have_update_requests))
 
 #if ERTS_POLL_USE_FALLBACK
 #  if ERTS_POLL_USE_POLL
@@ -232,7 +232,7 @@ struct ErtsPollSet_ {
     ErtsPollSet next;
     int internal_fd_limit;
     ErtsFdStatus *fds_status;
-    erts_smp_atomic_t no_of_user_fds;
+    erts_atomic_t no_of_user_fds;
     int fds_status_len;
 #if ERTS_POLL_USE_KERNEL_POLL
     int kp_fd;
@@ -263,9 +263,9 @@ struct ErtsPollSet_ {
 #endif
     ErtsPollSetUpdateRequestsBlock update_requests;
     ErtsPollSetUpdateRequestsBlock *curr_upd_req_block;
-    erts_smp_atomic32_t have_update_requests;
+    erts_atomic32_t have_update_requests;
     erts_atomic32_t polled;
-    erts_smp_mtx_t mtx;
+    erts_mtx_t mtx;
     int wake_fds[2];
 #if ERTS_POLL_USE_TIMERFD
     int timer_fd;
@@ -276,9 +276,9 @@ struct ErtsPollSet_ {
     erts_atomic32_t wakeup_state;
     erts_atomic64_t timeout_time;
 #ifdef ERTS_POLL_COUNT_AVOIDED_WAKEUPS
-    erts_smp_atomic_t no_avoided_wakeups;
-    erts_smp_atomic_t no_avoided_interrupts;
-    erts_smp_atomic_t no_interrupt_timed;
+    erts_atomic_t no_avoided_wakeups;
+    erts_atomic_t no_avoided_interrupts;
+    erts_atomic_t no_interrupt_timed;
 #endif
 };
 
@@ -288,7 +288,7 @@ static void fatal_error_async_signal_safe(char *error_str);
 
 static int max_fds = -1;
 static ErtsPollSet pollsets;
-static erts_smp_mtx_t pollsets_lock;
+static erts_mtx_t pollsets_lock;
 
 #if ERTS_POLL_USE_POLL
 
@@ -955,7 +955,7 @@ write_batch_buf(ErtsPollSet ps, ErtsPollBatchBuf *bbp)
 		    ps->fds_status[fd].flags |= ERTS_POLL_FD_FLG_USEFLBCK;
 		    ASSERT(ps->fds_status[fd].used_events);
 		    ps->fds_status[fd].used_events = 0;
-		    erts_smp_atomic_dec_nob(&ps->no_of_user_fds);
+		    erts_atomic_dec_nob(&ps->no_of_user_fds);
 		    update_fallback_pollset(ps, fd);
 		    ASSERT(ps->fds_status[fd].flags & ERTS_POLL_FD_FLG_INFLBCK);
 		    break;
@@ -1005,11 +1005,11 @@ batch_update_pollset(ErtsPollSet ps, int fd, ErtsPollBatchBuf *bbp)
     events = ERTS_POLL_EV_E2N(ps->fds_status[fd].events);
     if (!events) {
 	buf[buf_len].events = POLLREMOVE;
-	erts_smp_atomic_dec_nob(&ps->no_of_user_fds);
+	erts_atomic_dec_nob(&ps->no_of_user_fds);
     }
     else if (!ps->fds_status[fd].used_events) {
 	buf[buf_len].events = events;
-	erts_smp_atomic_inc_nob(&ps->no_of_user_fds);
+	erts_atomic_inc_nob(&ps->no_of_user_fds);
     }
     else {
 	if ((ps->fds_status[fd].flags & ERTS_POLL_FD_FLG_RST)
@@ -1099,12 +1099,12 @@ batch_update_pollset(ErtsPollSet ps, int fd, ErtsPollBatchBuf *bbp)
 	}
 	if (used_events) {
 	    if (!events) {
-		erts_smp_atomic_dec_nob(&ps->no_of_user_fds);
+		erts_atomic_dec_nob(&ps->no_of_user_fds);
 	    }
 	}
 	else {
 	    if (events)
-		erts_smp_atomic_inc_nob(&ps->no_of_user_fds);
+		erts_atomic_inc_nob(&ps->no_of_user_fds);
 	}
 	ASSERT((events & ~(ERTS_POLL_EV_IN|ERTS_POLL_EV_OUT)) == 0);
 	ASSERT((used_events & ~(ERTS_POLL_EV_IN|ERTS_POLL_EV_OUT)) == 0);
@@ -1178,7 +1178,7 @@ update_pollset(ErtsPollSet ps, int fd)
 	    epe.data.fd = epe_templ.data.fd;
 	    res = epoll_ctl(ps->kp_fd, EPOLL_CTL_DEL, fd, &epe);
 	} while (res != 0 && errno == EINTR);
-	erts_smp_atomic_dec_nob(&ps->no_of_user_fds);
+	erts_atomic_dec_nob(&ps->no_of_user_fds);
 	ps->fds_status[fd].used_events = 0;
     }
 
@@ -1186,11 +1186,11 @@ update_pollset(ErtsPollSet ps, int fd)
 	/* A note on EPOLL_CTL_DEL: linux kernel versions before 2.6.9
 	   need a non-NULL event pointer even though it is ignored... */
 	op = EPOLL_CTL_DEL;
-	erts_smp_atomic_dec_nob(&ps->no_of_user_fds);
+	erts_atomic_dec_nob(&ps->no_of_user_fds);
     }
     else if (!ps->fds_status[fd].used_events) {
 	op = EPOLL_CTL_ADD;
-	erts_smp_atomic_inc_nob(&ps->no_of_user_fds);
+	erts_atomic_inc_nob(&ps->no_of_user_fds);
     }
     else {
 	op = EPOLL_CTL_MOD;
@@ -1240,7 +1240,7 @@ update_pollset(ErtsPollSet ps, int fd)
 	/* Fall through ... */
 	case EPOLL_CTL_ADD: {
 	    ps->fds_status[fd].flags |= ERTS_POLL_FD_FLG_USEFLBCK;
-	    erts_smp_atomic_dec_nob(&ps->no_of_user_fds);
+	    erts_atomic_dec_nob(&ps->no_of_user_fds);
 #if ERTS_POLL_USE_CONCURRENT_UPDATE
 	    if (!*update_fallback) {
 		*update_fallback = 1;
@@ -1328,7 +1328,7 @@ static int update_pollset(ErtsPollSet ps, int fd)
 #if ERTS_POLL_USE_FALLBACK
 	ASSERT(ps->fds_status[fd].flags & ERTS_POLL_FD_FLG_INFLBCK);
 #endif
-	erts_smp_atomic_dec_nob(&ps->no_of_user_fds);
+	erts_atomic_dec_nob(&ps->no_of_user_fds);
 	last_pix = --ps->no_poll_fds;
 	if (pix != last_pix) {
 	/* Move last pix to this pix */
@@ -1355,7 +1355,7 @@ static int update_pollset(ErtsPollSet ps, int fd)
 	    ASSERT(!(ps->fds_status[fd].flags & ERTS_POLL_FD_FLG_INFLBCK)
 		    || fd == ps->kp_fd);
 #endif
-	    erts_smp_atomic_inc_nob(&ps->no_of_user_fds);
+	    erts_atomic_inc_nob(&ps->no_of_user_fds);
 	    ps->fds_status[fd].pix = pix = ps->no_poll_fds++;
 	    if (pix >= ps->poll_fds_len)
 		grow_poll_fds(ps, pix);
@@ -1407,7 +1407,7 @@ static int update_pollset(ErtsPollSet ps, int fd)
 
 	if (!ps->fds_status[fd].used_events) {
 	    ASSERT(events);
-	    erts_smp_atomic_inc_nob(&ps->no_of_user_fds);
+	    erts_atomic_inc_nob(&ps->no_of_user_fds);
 #if ERTS_POLL_USE_FALLBACK
 	    ps->no_select_fds++;
 	    ps->fds_status[fd].flags |= ERTS_POLL_FD_FLG_INFLBCK;
@@ -1415,7 +1415,7 @@ static int update_pollset(ErtsPollSet ps, int fd)
 	}
 	else if (!events) {
 	    ASSERT(ps->fds_status[fd].used_events);
-	    erts_smp_atomic_dec_nob(&ps->no_of_user_fds);
+	    erts_atomic_dec_nob(&ps->no_of_user_fds);
 	    ps->fds_status[fd].events = events;
 #if ERTS_POLL_USE_FALLBACK
 	    ps->no_select_fds--;
@@ -2139,7 +2139,7 @@ check_fd_events(ErtsPollSet ps, ErtsMonotonicTime timeout_time, int max_res)
 {
     int res;
     ERTS_MSACC_PUSH_STATE_M();
-    if (erts_smp_atomic_read_nob(&ps->no_of_user_fds) == 0
+    if (erts_atomic_read_nob(&ps->no_of_user_fds) == 0
 	&& timeout_time == ERTS_POLL_NO_TIMEOUT) {
 	/* Nothing to poll and zero timeout; done... */
 	return 0;
@@ -2197,7 +2197,7 @@ check_fd_events(ErtsPollSet ps, ErtsMonotonicTime timeout_time, int max_res)
 	     * the maximum number of file descriptors in the poll set.
 	     */
 	    struct dvpoll poll_res;
-	    int nfds = (int) erts_smp_atomic_read_nob(&ps->no_of_user_fds);
+	    int nfds = (int) erts_atomic_read_nob(&ps->no_of_user_fds);
 	    nfds++; /* Wakeup pipe */
 	    timeout = (int) get_timeout(ps, 1000, timeout_time);
 	    poll_res.dp_nfds = nfds < max_res ? nfds : max_res;
@@ -2416,10 +2416,10 @@ ERTS_POLL_EXPORT(erts_poll_interrupt_timed)(ErtsPollSet ps,
 #ifdef ERTS_POLL_COUNT_AVOIDED_WAKEUPS
 	else {
 	    if (ERTS_POLLSET_IS_POLLED(ps))
-		erts_smp_atomic_inc_nob(&ps->no_avoided_wakeups);
-	    erts_smp_atomic_inc_nob(&ps->no_avoided_interrupts);
+		erts_atomic_inc_nob(&ps->no_avoided_wakeups);
+	    erts_atomic_inc_nob(&ps->no_avoided_interrupts);
 	}
-	erts_smp_atomic_inc_nob(&ps->no_interrupt_timed);
+	erts_atomic_inc_nob(&ps->no_interrupt_timed);
 #endif
     }
 }
@@ -2436,7 +2436,7 @@ ERTS_POLL_EXPORT(erts_poll_max_fds)(void)
 void
 ERTS_POLL_EXPORT(erts_poll_init)(void)
 {
-    erts_smp_mtx_init(&pollsets_lock, "pollsets_lock", NIL,
+    erts_mtx_init(&pollsets_lock, "pollsets_lock", NIL,
         ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
     pollsets = NULL;
 
@@ -2476,7 +2476,7 @@ ERTS_POLL_EXPORT(erts_poll_create_pollset)(void)
     ps->internal_fd_limit = 0;
     ps->fds_status = NULL;
     ps->fds_status_len = 0;
-    erts_smp_atomic_init_nob(&ps->no_of_user_fds, 0);
+    erts_atomic_init_nob(&ps->no_of_user_fds, 0);
 #if ERTS_POLL_USE_KERNEL_POLL
     ps->kp_fd = -1;
 #if ERTS_POLL_USE_EPOLL
@@ -2538,9 +2538,9 @@ ERTS_POLL_EXPORT(erts_poll_create_pollset)(void)
     ps->update_requests.next = NULL;
     ps->update_requests.len = 0;
     ps->curr_upd_req_block = &ps->update_requests;
-    erts_smp_atomic32_init_nob(&ps->have_update_requests, 0);
+    erts_atomic32_init_nob(&ps->have_update_requests, 0);
     erts_atomic32_init_nob(&ps->polled, 0);
-    erts_smp_mtx_init(&ps->mtx, "pollset", NIL, ERTS_LOCK_FLAGS_CATEGORY_IO);
+    erts_mtx_init(&ps->mtx, "pollset", NIL, ERTS_LOCK_FLAGS_CATEGORY_IO);
     erts_atomic32_init_nob(&ps->wakeup_state, (erts_aint32_t) 0);
     create_wakeup_pipe(ps);
 #if ERTS_POLL_USE_TIMERFD
@@ -2565,20 +2565,20 @@ ERTS_POLL_EXPORT(erts_poll_create_pollset)(void)
 #endif
     init_timeout_time(ps);
 #ifdef ERTS_POLL_COUNT_AVOIDED_WAKEUPS
-    erts_smp_atomic_init_nob(&ps->no_avoided_wakeups, 0);
-    erts_smp_atomic_init_nob(&ps->no_avoided_interrupts, 0);
-    erts_smp_atomic_init_nob(&ps->no_interrupt_timed, 0);
+    erts_atomic_init_nob(&ps->no_avoided_wakeups, 0);
+    erts_atomic_init_nob(&ps->no_avoided_interrupts, 0);
+    erts_atomic_init_nob(&ps->no_interrupt_timed, 0);
 #endif
     handle_update_requests(ps);
 #if ERTS_POLL_USE_FALLBACK
     ps->fallback_used = 0;
 #endif
-    erts_smp_atomic_set_nob(&ps->no_of_user_fds, 0); /* Don't count wakeup pipe and fallback fd */
+    erts_atomic_set_nob(&ps->no_of_user_fds, 0); /* Don't count wakeup pipe and fallback fd */
 
-    erts_smp_mtx_lock(&pollsets_lock);
+    erts_mtx_lock(&pollsets_lock);
     ps->next = pollsets;
     pollsets = ps;
-    erts_smp_mtx_unlock(&pollsets_lock);
+    erts_mtx_unlock(&pollsets_lock);
 
     return ps;
 }
@@ -2623,7 +2623,7 @@ ERTS_POLL_EXPORT(erts_poll_destroy_pollset)(ErtsPollSet ps)
 	    free_update_requests_block(ps, free_urqbp);
 	}
     }
-    erts_smp_mtx_destroy(&ps->mtx);
+    erts_mtx_destroy(&ps->mtx);
     if (ps->wake_fds[0] >= 0)
 	close(ps->wake_fds[0]);
     if (ps->wake_fds[1] >= 0)
@@ -2633,7 +2633,7 @@ ERTS_POLL_EXPORT(erts_poll_destroy_pollset)(ErtsPollSet ps)
         close(ps->timer_fd);
 #endif
 
-    erts_smp_mtx_lock(&pollsets_lock);
+    erts_mtx_lock(&pollsets_lock);
     if (ps == pollsets)
 	pollsets = pollsets->next;
     else {
@@ -2643,7 +2643,7 @@ ERTS_POLL_EXPORT(erts_poll_destroy_pollset)(ErtsPollSet ps)
 	ASSERT(ps == prev_ps->next);
 	prev_ps->next = ps->next;
     }
-    erts_smp_mtx_unlock(&pollsets_lock);
+    erts_mtx_unlock(&pollsets_lock);
 
     erts_free(ERTS_ALC_T_POLLSET, (void *) ps);
 }
@@ -2728,7 +2728,7 @@ ERTS_POLL_EXPORT(erts_poll_info)(ErtsPollSet ps, ErtsPollInfo *pip)
 
     pip->memory_size = size;
 
-    pip->poll_set_size = (int) erts_smp_atomic_read_nob(&ps->no_of_user_fds);
+    pip->poll_set_size = (int) erts_atomic_read_nob(&ps->no_of_user_fds);
     pip->poll_set_size++; /* Wakeup pipe */
 #if ERTS_POLL_USE_TIMERFD
     pip->poll_set_size++; /* timerfd */
@@ -2779,9 +2779,9 @@ ERTS_POLL_EXPORT(erts_poll_info)(ErtsPollSet ps, ErtsPollInfo *pip)
     pip->max_fds = max_fds;
 
 #ifdef ERTS_POLL_COUNT_AVOIDED_WAKEUPS
-    pip->no_avoided_wakeups = erts_smp_atomic_read_nob(&ps->no_avoided_wakeups);
-    pip->no_avoided_interrupts = erts_smp_atomic_read_nob(&ps->no_avoided_interrupts);
-    pip->no_interrupt_timed = erts_smp_atomic_read_nob(&ps->no_interrupt_timed);
+    pip->no_avoided_wakeups = erts_atomic_read_nob(&ps->no_avoided_wakeups);
+    pip->no_avoided_interrupts = erts_atomic_read_nob(&ps->no_avoided_interrupts);
+    pip->no_interrupt_timed = erts_atomic_read_nob(&ps->no_interrupt_timed);
 #endif
 
     ERTS_POLLSET_UNLOCK(ps);
@@ -2980,12 +2980,12 @@ static void erts_lcnt_enable_pollset_lock_count(ErtsPollSet pollset, int enable)
 void ERTS_POLL_EXPORT(erts_lcnt_update_pollset_locks)(int enable) {
     ErtsPollSet iterator;
 
-    erts_smp_mtx_lock(&pollsets_lock);
+    erts_mtx_lock(&pollsets_lock);
 
     for(iterator = pollsets; iterator != NULL; iterator = iterator->next) {
         erts_lcnt_enable_pollset_lock_count(iterator, enable);
     }
 
-    erts_smp_mtx_unlock(&pollsets_lock);
+    erts_mtx_unlock(&pollsets_lock);
 }
 #endif
diff --git a/erts/emulator/sys/common/erl_sys_common_misc.c b/erts/emulator/sys/common/erl_sys_common_misc.c
index 79f87eb3a9..09237c81ce 100644
--- a/erts/emulator/sys/common/erl_sys_common_misc.c
+++ b/erts/emulator/sys/common/erl_sys_common_misc.c
@@ -51,7 +51,7 @@
  * (often) exist two versions of erl_check_io (kernel-poll and
  * non-kernel-poll), and we dont want two versions of this variable.
  */
-erts_smp_atomic_t erts_check_io_time;
+erts_atomic_t erts_check_io_time;
 
 /* Written once and only once */
 
diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 83edca1c2f..237614b0fb 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -63,7 +63,7 @@
 #include "erl_mseg.h"
 
 extern char **environ;
-erts_smp_rwmtx_t environ_rwmtx;
+erts_rwmtx_t environ_rwmtx;
 
 #define MAX_VSIZE 16		/* Max number of entries allowed in an I/O
 				 * vector sock_sendv().
@@ -92,11 +92,11 @@ extern void erts_sys_init_float(void);
 static int debug_log = 0;
 #endif
 
-static erts_smp_atomic32_t have_prepared_crash_dump;
+static erts_atomic32_t have_prepared_crash_dump;
 #define ERTS_PREPARED_CRASH_DUMP \
-  ((int) erts_smp_atomic32_xchg_nob(&have_prepared_crash_dump, 1))
+  ((int) erts_atomic32_xchg_nob(&have_prepared_crash_dump, 1))
 
-erts_smp_atomic_t sys_misc_mem_sz;
+erts_atomic_t sys_misc_mem_sz;
 
 static void smp_sig_notify(int signum);
 static int sig_notify_fds[2] = {-1, -1};
@@ -118,11 +118,11 @@ static int max_files = -1;
 /* 
  * a few variables used by the break handler 
  */
-erts_smp_atomic32_t erts_break_requested;
+erts_atomic32_t erts_break_requested;
 #define ERTS_SET_BREAK_REQUESTED \
-  erts_smp_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 1)
+  erts_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 1)
 #define ERTS_UNSET_BREAK_REQUESTED \
-  erts_smp_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 0)
+  erts_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 0)
 
 
 /* set early so the break handler has access to initial mode */
@@ -262,7 +262,7 @@ Uint
 erts_sys_misc_mem_sz(void)
 {
     Uint res = ERTS_CHK_IO_SZ();
-    res += erts_smp_atomic_read_mb(&sys_misc_mem_sz);
+    res += erts_atomic_read_mb(&sys_misc_mem_sz);
     return res;
 }
 
@@ -399,11 +399,11 @@ erts_sys_pre_init(void)
     erts_init_sys_time_sup();
 
 
-    erts_smp_atomic32_init_nob(&erts_break_requested, 0);
-    erts_smp_atomic32_init_nob(&have_prepared_crash_dump, 0);
+    erts_atomic32_init_nob(&erts_break_requested, 0);
+    erts_atomic32_init_nob(&have_prepared_crash_dump, 0);
 
 
-    erts_smp_atomic_init_nob(&sys_misc_mem_sz, 0);
+    erts_atomic_init_nob(&sys_misc_mem_sz, 0);
 
     {
       /*
@@ -605,7 +605,7 @@ static void signal_notify_requested(Eterm type) {
         erts_queue_message(p, locks, msgp, msg, am_system);
 
         if (locks)
-            erts_smp_proc_unlock(p, locks);
+            erts_proc_unlock(p, locks);
         erts_proc_dec_refc(p);
     }
 }
@@ -869,7 +869,7 @@ void os_version(int *pMajor, int *pMinor, int *pBuild) {
 
 void init_getenv_state(GETENV_STATE *state)
 {
-   erts_smp_rwmtx_rlock(&environ_rwmtx);
+   erts_rwmtx_rlock(&environ_rwmtx);
    *state = NULL;
 }
 
@@ -878,7 +878,7 @@ char *getenv_string(GETENV_STATE *state0)
    char **state = (char **) *state0;
    char *cp;
 
-   ERTS_SMP_LC_ASSERT(erts_smp_lc_rwmtx_is_rlocked(&environ_rwmtx));
+   ERTS_LC_ASSERT(erts_lc_rwmtx_is_rlocked(&environ_rwmtx));
 
    if (state == NULL)
       state = environ;
@@ -892,7 +892,7 @@ char *getenv_string(GETENV_STATE *state0)
 void fini_getenv_state(GETENV_STATE *state)
 {
    *state = NULL;
-   erts_smp_rwmtx_runlock(&environ_rwmtx);
+   erts_rwmtx_runlock(&environ_rwmtx);
 }
 
 void erts_do_break_handling(void)
@@ -905,7 +905,7 @@ void erts_do_break_handling(void)
      * therefore, make sure that all threads but this one are blocked before
      * proceeding!
      */
-    erts_smp_thr_progress_block();
+    erts_thr_progress_block();
 
     /* during break we revert to initial settings */
     /* this is done differently for oldshell */
@@ -933,7 +933,7 @@ void erts_do_break_handling(void)
       tcsetattr(0,TCSANOW,&temp_mode);
     }
 
-    erts_smp_thr_progress_unblock();
+    erts_thr_progress_unblock();
 }
 
 
@@ -963,14 +963,14 @@ erts_sys_putenv(char *key, char *value)
     env = erts_alloc(ERTS_ALC_T_TMP, need);
 #else
     env = erts_alloc(ERTS_ALC_T_PUTENV_STR, need);
-    erts_smp_atomic_add_nob(&sys_misc_mem_sz, need);
+    erts_atomic_add_nob(&sys_misc_mem_sz, need);
 #endif
     strcpy(env,key);
     strcat(env,"=");
     strcat(env,value);
-    erts_smp_rwmtx_rwlock(&environ_rwmtx);
+    erts_rwmtx_rwlock(&environ_rwmtx);
     res = putenv(env);
-    erts_smp_rwmtx_rwunlock(&environ_rwmtx);
+    erts_rwmtx_rwunlock(&environ_rwmtx);
 #ifdef HAVE_COPYING_PUTENV
     erts_free(ERTS_ALC_T_TMP, env);
 #endif
@@ -1017,9 +1017,9 @@ int
 erts_sys_getenv(char *key, char *value, size_t *size)
 {
     int res;
-    erts_smp_rwmtx_rlock(&environ_rwmtx);
+    erts_rwmtx_rlock(&environ_rwmtx);
     res = erts_sys_getenv__(key, value, size);
-    erts_smp_rwmtx_runlock(&environ_rwmtx);
+    erts_rwmtx_runlock(&environ_rwmtx);
     return res;
 }
 
@@ -1027,9 +1027,9 @@ int
 erts_sys_unsetenv(char *key)
 {
     int res;
-    erts_smp_rwmtx_rwlock(&environ_rwmtx);
+    erts_rwmtx_rwlock(&environ_rwmtx);
     res = unsetenv(key);
-    erts_smp_rwmtx_rwunlock(&environ_rwmtx);
+    erts_rwmtx_rwunlock(&environ_rwmtx);
     return res;
 }
 
@@ -1200,12 +1200,12 @@ void
 erl_sys_schedule(int runnable)
 {
     ERTS_CHK_IO(!runnable);
-    ERTS_SMP_LC_ASSERT(!erts_thr_progress_is_blocking());
+    ERTS_LC_ASSERT(!erts_thr_progress_is_blocking());
 }
 
 
 
-static erts_smp_tid_t sig_dispatcher_tid;
+static erts_tid_t sig_dispatcher_tid;
 
 static void
 smp_sig_notify(int signum)
@@ -1279,7 +1279,7 @@ signal_dispatcher_thread_func(void *unused)
                 }
                 signal_notify_requested(signal);
         }
-        ERTS_SMP_LC_ASSERT(!erts_thr_progress_is_blocking());
+        ERTS_LC_ASSERT(!erts_thr_progress_is_blocking());
     }
     return NULL;
 }
@@ -1287,7 +1287,7 @@ signal_dispatcher_thread_func(void *unused)
 static void
 init_smp_sig_notify(void)
 {
-    erts_smp_thr_opts_t thr_opts = ERTS_SMP_THR_OPTS_DEFAULT_INITER;
+    erts_thr_opts_t thr_opts = ERTS_THR_OPTS_DEFAULT_INITER;
     thr_opts.detached = 1;
     thr_opts.name = "sys_sig_dispatcher";
 
@@ -1299,7 +1299,7 @@ init_smp_sig_notify(void)
     }
 
     /* Start signal handler thread */
-    erts_smp_thr_create(&sig_dispatcher_tid,
+    erts_thr_create(&sig_dispatcher_tid,
 			signal_dispatcher_thread_func,
 			NULL,
 			&thr_opts);
@@ -1425,7 +1425,7 @@ erl_sys_args(int* argc, char** argv)
 {
     int i, j;
 
-    erts_smp_rwmtx_init(&environ_rwmtx, "environ", NIL,
+    erts_rwmtx_init(&environ_rwmtx, "environ", NIL,
         ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 
     i = 1;
diff --git a/erts/emulator/sys/unix/sys_drivers.c b/erts/emulator/sys/unix/sys_drivers.c
index c451a0a674..7c9a532fed 100644
--- a/erts/emulator/sys/unix/sys_drivers.c
+++ b/erts/emulator/sys/unix/sys_drivers.c
@@ -56,9 +56,9 @@
 #include "erl_threads.h"
 
 extern char **environ;
-extern erts_smp_rwmtx_t environ_rwmtx;
+extern erts_rwmtx_t environ_rwmtx;
 
-extern erts_smp_atomic_t sys_misc_mem_sz;
+extern erts_atomic_t sys_misc_mem_sz;
 
 static Eterm forker_port;
 
@@ -343,7 +343,7 @@ static int set_blocking_data(ErtsSysDriverData *dd) {
 
     dd->blocking = erts_alloc(ERTS_ALC_T_SYS_BLOCKING, sizeof(ErtsSysBlocking));
 
-    erts_smp_atomic_add_nob(&sys_misc_mem_sz, sizeof(ErtsSysBlocking));
+    erts_atomic_add_nob(&sys_misc_mem_sz, sizeof(ErtsSysBlocking));
 
     dd->blocking->pdl = driver_pdl_create(dd->port_num);
     dd->blocking->res = 0;
@@ -386,7 +386,7 @@ create_driver_data(ErlDrvPort port_num,
         size += sizeof(ErtsSysFdData);
 
     data = erts_alloc(ERTS_ALC_T_DRV_TAB,size);
-    erts_smp_atomic_add_nob(&sys_misc_mem_sz, size);
+    erts_atomic_add_nob(&sys_misc_mem_sz, size);
 
     driver_data = (ErtsSysDriverData*)data;
     data += sizeof(*driver_data);
@@ -452,7 +452,7 @@ static char **build_unix_environment(char *block)
     char **cpp;
     char** old_env;
     
-    ERTS_SMP_LC_ASSERT(erts_smp_lc_rwmtx_is_rlocked(&environ_rwmtx));
+    ERTS_LC_ASSERT(erts_lc_rwmtx_is_rlocked(&environ_rwmtx));
 
     cp = block;
     len = 0;
@@ -600,12 +600,12 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
 	len = CMD_LINE_PREFIX_STR_SZ + len + 1;
     }
 
-    erts_smp_rwmtx_rlock(&environ_rwmtx);
+    erts_rwmtx_rlock(&environ_rwmtx);
 
     if (opts->envir == NULL) {
 	new_environ = environ;
     } else if ((new_environ = build_unix_environment(opts->envir)) == NULL) {
-	erts_smp_rwmtx_runlock(&environ_rwmtx);
+	erts_rwmtx_runlock(&environ_rwmtx);
         close_pipes(ifd, ofd);
 	erts_free(ERTS_ALC_T_TMP, (void *) cmd_line);
 	errno = ENOMEM;
@@ -621,7 +621,7 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
         erts_free(ERTS_ALC_T_TMP, (void *) cmd_line);
         if (new_environ != environ)
             erts_free(ERTS_ALC_T_ENVIRONMENT, (void *) new_environ);
-        erts_smp_rwmtx_runlock(&environ_rwmtx);
+        erts_rwmtx_runlock(&environ_rwmtx);
         errno = err;
         return ERL_DRV_ERROR_ERRNO;
     }
@@ -661,7 +661,7 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
 
         if (!io_vector) {
             close_pipes(ifd, ofd);
-            erts_smp_rwmtx_runlock(&environ_rwmtx);
+            erts_rwmtx_runlock(&environ_rwmtx);
             erts_free(ERTS_ALC_T_TMP, (void *) cmd_line);
             if (new_environ != environ)
                 erts_free(ERTS_ALC_T_ENVIRONMENT, (void *) new_environ);
@@ -746,7 +746,7 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
                 erts_free(ERTS_ALC_T_TMP, io_vector);
                 if (new_environ != environ)
                     erts_free(ERTS_ALC_T_ENVIRONMENT, (void *) new_environ);
-                erts_smp_rwmtx_runlock(&environ_rwmtx);
+                erts_rwmtx_runlock(&environ_rwmtx);
                 erts_free(ERTS_ALC_T_TMP, (void *) cmd_line);
                 errno = err;
                 return ERL_DRV_ERROR_ERRNO;
@@ -775,7 +775,7 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name,
     if (new_environ != environ)
 	erts_free(ERTS_ALC_T_ENVIRONMENT, (void *) new_environ);
 
-    erts_smp_rwmtx_runlock(&environ_rwmtx);
+    erts_rwmtx_runlock(&environ_rwmtx);
 
     dd = create_driver_data(port_num, ifd[0], ofd[1], opts->packet_bytes,
                              DO_WRITE | DO_READ, opts->exit_status,
@@ -1048,8 +1048,8 @@ static void clear_fd_data(ErtsSysFdData *fdd)
 {
     if (fdd->sz > 0) {
 	erts_free(ERTS_ALC_T_FD_ENTRY_BUF, (void *) fdd->buf);
-	ASSERT(erts_smp_atomic_read_nob(&sys_misc_mem_sz) >= fdd->sz);
-	erts_smp_atomic_add_nob(&sys_misc_mem_sz, -1*fdd->sz);
+	ASSERT(erts_atomic_read_nob(&sys_misc_mem_sz) >= fdd->sz);
+	erts_atomic_add_nob(&sys_misc_mem_sz, -1*fdd->sz);
     }
     fdd->buf = NULL;
     fdd->sz = 0;
@@ -1088,7 +1088,7 @@ static void fd_stop(ErlDrvData ev)  /* Does not close the fds */
     }
 
      erts_free(ERTS_ALC_T_DRV_TAB, dd);
-     erts_smp_atomic_add_nob(&sys_misc_mem_sz, -sz);
+     erts_atomic_add_nob(&sys_misc_mem_sz, -sz);
 }
 
 static void fd_flush(ErlDrvData ev)
@@ -1384,7 +1384,7 @@ static void ready_input(ErlDrvData e, ErlDrvEvent ready_fd)
 
             if (dd->ifd->fd < 0) {
                 driver_select(port_num, abs(dd->ifd->fd), ERL_DRV_READ|ERL_DRV_USE, 0);
-                erts_smp_atomic_add_nob(&sys_misc_mem_sz, -sizeof(ErtsSysFdData));
+                erts_atomic_add_nob(&sys_misc_mem_sz, -sizeof(ErtsSysFdData));
                 dd->ifd = NULL;
             }
 
@@ -1490,7 +1490,7 @@ static void ready_input(ErlDrvData e, ErlDrvEvent ready_fd)
 			port_inp_failure(dd, -1);
 		    }
 		    else {
-			erts_smp_atomic_add_nob(&sys_misc_mem_sz, h);
+			erts_atomic_add_nob(&sys_misc_mem_sz, h);
 			sys_memcpy(buf, cpos, bytes_left);
 			dd->ifd->buf = buf;
 			dd->ifd->sz = h;
@@ -1525,7 +1525,7 @@ static void ready_output(ErlDrvData e, ErlDrvEvent ready_fd)
                should close the output fd as soon as the command has
                been sent. */
             driver_select(ix, ready_fd, ERL_DRV_WRITE|ERL_DRV_USE, 0);
-            erts_smp_atomic_add_nob(&sys_misc_mem_sz, -sizeof(ErtsSysFdData));
+            erts_atomic_add_nob(&sys_misc_mem_sz, -sizeof(ErtsSysFdData));
             dd->ofd = NULL;
         }
         if (dd->terminating)
diff --git a/erts/emulator/sys/unix/sys_time.c b/erts/emulator/sys/unix/sys_time.c
index 60afb3b672..ef05380d17 100644
--- a/erts/emulator/sys/unix/sys_time.c
+++ b/erts/emulator/sys/unix/sys_time.c
@@ -160,7 +160,7 @@ struct sys_time_internal_state_read_mostly__ {
 
 #ifdef ERTS_SYS_TIME_INTERNAL_STATE_WRITE_FREQ__
 struct sys_time_internal_state_write_freq__ {
-    erts_smp_mtx_t mtx;
+    erts_mtx_t mtx;
 #if defined(__linux__) && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)
     ErtsMonotonicTime last_delivered;
 #endif
@@ -304,7 +304,7 @@ sys_init_time(ErtsSysInitTimeResult *init_resp)
 	    erts_sys_time_data__.r.o.os_times =
 		clock_gettime_times_verified;
 #endif
-            erts_smp_mtx_init(&internal_state.w.f.mtx, "os_monotonic_time", NIL,
+            erts_mtx_init(&internal_state.w.f.mtx, "os_monotonic_time", NIL,
                 ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
 	    internal_state.w.f.last_delivered
 		= clock_gettime_monotonic();
@@ -525,12 +525,12 @@ static ErtsMonotonicTime clock_gettime_monotonic_verified(void)
     mtime = (ErtsMonotonicTime) posix_clock_gettime(MONOTONIC_CLOCK_ID,
 						    MONOTONIC_CLOCK_ID_STR);
 
-    erts_smp_mtx_lock(&internal_state.w.f.mtx);
+    erts_mtx_lock(&internal_state.w.f.mtx);
     if (mtime < internal_state.w.f.last_delivered)
 	mtime = internal_state.w.f.last_delivered;
     else
 	internal_state.w.f.last_delivered = mtime;
-    erts_smp_mtx_unlock(&internal_state.w.f.mtx);
+    erts_mtx_unlock(&internal_state.w.f.mtx);
 
     return mtime;
 }
@@ -547,12 +547,12 @@ static void clock_gettime_times_verified(ErtsMonotonicTime *mtimep,
 			      WALL_CLOCK_ID_STR,
 			      stimep);
 
-    erts_smp_mtx_lock(&internal_state.w.f.mtx);
+    erts_mtx_lock(&internal_state.w.f.mtx);
     if (*mtimep < internal_state.w.f.last_delivered)
 	*mtimep = internal_state.w.f.last_delivered;
     else
 	internal_state.w.f.last_delivered = *mtimep;
-    erts_smp_mtx_unlock(&internal_state.w.f.mtx);
+    erts_mtx_unlock(&internal_state.w.f.mtx);
 }
 
 #endif /* defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME) */
diff --git a/erts/emulator/sys/win32/erl_poll.c b/erts/emulator/sys/win32/erl_poll.c
index 41ff186c44..0bd43bb4fb 100644
--- a/erts/emulator/sys/win32/erl_poll.c
+++ b/erts/emulator/sys/win32/erl_poll.c
@@ -286,26 +286,26 @@ struct ErtsPollSet_ {
     CRITICAL_SECTION standby_crit;     /* CS to guard the counter */
     HANDLE standby_wait_event;         /* Event signalled when counte == 0 */
     erts_atomic32_t wakeup_state;
-    erts_smp_mtx_t mtx;
+    erts_mtx_t mtx;
     erts_atomic64_t timeout_time;
 };
 
 
 #define ERTS_POLLSET_LOCK(PS) \
-  erts_smp_mtx_lock(&(PS)->mtx)
+  erts_mtx_lock(&(PS)->mtx)
 #define ERTS_POLLSET_UNLOCK(PS) \
-  erts_smp_mtx_unlock(&(PS)->mtx)
+  erts_mtx_unlock(&(PS)->mtx)
 
 
 /*
  * Communication with sys_interrupt
  */
 
-extern erts_smp_atomic32_t erts_break_requested;
+extern erts_atomic32_t erts_break_requested;
 #define ERTS_SET_BREAK_REQUESTED \
-  erts_smp_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 1)
+  erts_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 1)
 #define ERTS_UNSET_BREAK_REQUESTED \
-  erts_smp_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 0)
+  erts_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 0)
 
 static erts_mtx_t break_waiter_lock;
 static HANDLE break_happened_event;
@@ -1340,7 +1340,7 @@ ErtsPollSet erts_poll_create_pollset(void)
     ps->restore_events = 0;
 
     erts_atomic32_init_nob(&ps->wakeup_state, ERTS_POLL_NOT_WOKEN);
-    erts_smp_mtx_init(&ps->mtx, "pollset", NIL, ERTS_LOCK_FLAGS_CATEGORY_IO);
+    erts_mtx_init(&ps->mtx, "pollset", NIL, ERTS_LOCK_FLAGS_CATEGORY_IO);
     init_timeout_time(ps);
 
     HARDTRACEF(("Out erts_poll_create_pollset"));
@@ -1370,7 +1370,7 @@ void erts_poll_destroy_pollset(ErtsPollSet ps)
     CloseHandle(ps->event_io_ready);
     CloseHandle(ps->standby_wait_event);
     ERTS_POLLSET_UNLOCK(ps);
-    erts_smp_mtx_destroy(&ps->mtx);
+    erts_mtx_destroy(&ps->mtx);
     SEL_FREE(ERTS_ALC_T_POLLSET, (void *) ps);
     HARDTRACEF(("Out erts_poll_destroy_pollset"));
 }
diff --git a/erts/emulator/sys/win32/sys.c b/erts/emulator/sys/win32/sys.c
index 4c06535e4e..b23dbecbac 100644
--- a/erts/emulator/sys/win32/sys.c
+++ b/erts/emulator/sys/win32/sys.c
@@ -80,9 +80,9 @@ static int application_type(const wchar_t* originalName, wchar_t fullPath[MAX_PA
 
 HANDLE erts_service_event;
 
-static erts_smp_tsd_key_t win32_errstr_key;
+static erts_tsd_key_t win32_errstr_key;
 
-static erts_smp_atomic_t pipe_creation_counter;
+static erts_atomic_t pipe_creation_counter;
 
 /* Results from application_type(_w) is one of */
 #define APPL_NONE 0
@@ -141,7 +141,7 @@ static BOOL (WINAPI *fpCancelIoEx)(HANDLE,LPOVERLAPPED);
    - call erl_start() to parse arguments and do other init
 */
 
-static erts_smp_atomic_t sys_misc_mem_sz;
+static erts_atomic_t sys_misc_mem_sz;
 
 HMODULE beam_module = NULL;
 
@@ -192,7 +192,7 @@ Uint
 erts_sys_misc_mem_sz(void)
 {
     Uint res = (Uint) erts_check_io_size();
-    res += (Uint) erts_smp_atomic_read_mb(&sys_misc_mem_sz);
+    res += (Uint) erts_atomic_read_mb(&sys_misc_mem_sz);
     return res;
 }
 
@@ -659,7 +659,7 @@ new_driver_data(ErlDrvPort port_num, int packet_bytes, int wait_objs_required, i
     dp->inbuf = DRV_BUF_ALLOC(dp->inBufSize);
     if (dp->inbuf == NULL)
 	goto buf_alloc_error;
-    erts_smp_atomic_add_nob(&sys_misc_mem_sz, dp->inBufSize);
+    erts_atomic_add_nob(&sys_misc_mem_sz, dp->inBufSize);
     dp->outBufSize = 0;
     dp->outbuf = NULL;
     dp->port_num = port_num;
@@ -729,8 +729,8 @@ release_driver_data(DriverData* dp)
     }
 
     if (dp->inbuf != NULL) {
-	ASSERT(erts_smp_atomic_read_nob(&sys_misc_mem_sz) >= dp->inBufSize);
-	erts_smp_atomic_add_nob(&sys_misc_mem_sz, -1*dp->inBufSize);
+	ASSERT(erts_atomic_read_nob(&sys_misc_mem_sz) >= dp->inBufSize);
+	erts_atomic_add_nob(&sys_misc_mem_sz, -1*dp->inBufSize);
 	DRV_BUF_FREE(dp->inbuf);
 	dp->inBufSize = 0;
 	dp->inbuf = NULL;
@@ -738,8 +738,8 @@ release_driver_data(DriverData* dp)
     ASSERT(dp->inBufSize == 0);
 
     if (dp->outbuf != NULL) {
-	ASSERT(erts_smp_atomic_read_nob(&sys_misc_mem_sz) >= dp->outBufSize);
-	erts_smp_atomic_add_nob(&sys_misc_mem_sz, -1*dp->outBufSize);
+	ASSERT(erts_atomic_read_nob(&sys_misc_mem_sz) >= dp->outBufSize);
+	erts_atomic_add_nob(&sys_misc_mem_sz, -1*dp->outBufSize);
 	DRV_BUF_FREE(dp->outbuf);
 	dp->outBufSize = 0;
 	dp->outbuf = NULL;
@@ -1737,7 +1737,7 @@ static int create_pipe(HANDLE *phRead, HANDLE *phWrite, BOOL inheritRead, BOOL o
      * Otherwise, create named pipes.
      */
 
-    calls = (UWord) erts_smp_atomic_inc_read_nob(&pipe_creation_counter);
+    calls = (UWord) erts_atomic_inc_read_nob(&pipe_creation_counter);
     erts_snprintf(pipe_name, sizeof(pipe_name),
 		  "\\\\.\\pipe\\erlang44_%d_%bpu", getpid(), calls);
 
@@ -2422,7 +2422,7 @@ output(ErlDrvData drv_data, char* buf, ErlDrvSizeT len)
     }
 
     dp->outBufSize = pb+len;
-    erts_smp_atomic_add_nob(&sys_misc_mem_sz, dp->outBufSize);
+    erts_atomic_add_nob(&sys_misc_mem_sz, dp->outBufSize);
 
     /*
      * Store header bytes (if any).
@@ -2451,8 +2451,8 @@ output(ErlDrvData drv_data, char* buf, ErlDrvSizeT len)
     } else {
 	dp->out.ov.Offset += pb+len; /* For vanilla driver. */
 	/* XXX OffsetHigh should be changed too. */
-	ASSERT(erts_smp_atomic_read_nob(&sys_misc_mem_sz) >= dp->outBufSize);
-	erts_smp_atomic_add_nob(&sys_misc_mem_sz, -1*dp->outBufSize);
+	ASSERT(erts_atomic_read_nob(&sys_misc_mem_sz) >= dp->outBufSize);
+	erts_atomic_add_nob(&sys_misc_mem_sz, -1*dp->outBufSize);
 	DRV_BUF_FREE(dp->outbuf);
 	dp->outBufSize = 0;
 	dp->outbuf = NULL;
@@ -2563,8 +2563,8 @@ ready_input(ErlDrvData drv_data, ErlDrvEvent ready_event)
 			    error = ERROR_NOT_ENOUGH_MEMORY;
 			    break; /* Break out of loop into error handler. */
 			}
-			ASSERT(erts_smp_atomic_read_nob(&sys_misc_mem_sz) >= dp->inBufSize);
-			erts_smp_atomic_add_nob(&sys_misc_mem_sz,
+			ASSERT(erts_atomic_read_nob(&sys_misc_mem_sz) >= dp->inBufSize);
+			erts_atomic_add_nob(&sys_misc_mem_sz,
 						dp->totalNeeded - dp->inBufSize);
 			dp->inBufSize = dp->totalNeeded;
 			dp->inbuf = new_buf;
@@ -2663,8 +2663,8 @@ ready_output(ErlDrvData drv_data, ErlDrvEvent ready_event)
 	   write... */
 	return;
     }
-    ASSERT(erts_smp_atomic_read_nob(&sys_misc_mem_sz) >= dp->outBufSize);
-    erts_smp_atomic_add_nob(&sys_misc_mem_sz, -1*dp->outBufSize);
+    ASSERT(erts_atomic_read_nob(&sys_misc_mem_sz) >= dp->outBufSize);
+    erts_atomic_add_nob(&sys_misc_mem_sz, -1*dp->outBufSize);
     DRV_BUF_FREE(dp->outbuf);
     dp->outBufSize = 0;
     dp->outbuf = NULL;
@@ -2812,7 +2812,7 @@ Preload* sys_preloaded(void)
 			   (num_preloaded+1)*sizeof(Preload));
     res_name = erts_alloc(ERTS_ALC_T_PRELOADED,
 			  (num_preloaded+1)*sizeof(unsigned));
-    erts_smp_atomic_add_nob(&sys_misc_mem_sz,
+    erts_atomic_add_nob(&sys_misc_mem_sz,
 			    (num_preloaded+1)*sizeof(Preload)
 			    + (num_preloaded+1)*sizeof(unsigned));
     for (i = 0; i < num_preloaded; i++) {
@@ -2825,7 +2825,7 @@ Preload* sys_preloaded(void)
 	n = GETWORD(data);
 	data += 2;
 	preloaded[i].name = erts_alloc(ERTS_ALC_T_PRELOADED, n+1);
-	erts_smp_atomic_add_nob(&sys_misc_mem_sz, n+1);
+	erts_atomic_add_nob(&sys_misc_mem_sz, n+1);
 	sys_memcpy(preloaded[i].name, data, n);
 	preloaded[i].name[n] = '\0';
 	data += n;
@@ -2907,7 +2907,7 @@ sys_get_key(int fd)
 
 char* win32_errorstr(int error)
 {
-  LPTSTR lpBufPtr = erts_smp_tsd_get(win32_errstr_key);
+  LPTSTR lpBufPtr = erts_tsd_get(win32_errstr_key);
   if (lpBufPtr) {
       LocalFree(lpBufPtr);
   }
@@ -2921,7 +2921,7 @@ char* win32_errorstr(int error)
 		0,
 		NULL);
   SetLastError(error);
-  erts_smp_tsd_set(win32_errstr_key,lpBufPtr);
+  erts_tsd_set(win32_errstr_key,lpBufPtr);
   return lpBufPtr;
 }
 
@@ -3170,7 +3170,7 @@ erts_sys_pre_init(void)
 
     erts_init_sys_time_sup();
 
-    erts_smp_atomic_init_nob(&sys_misc_mem_sz, 0);
+    erts_atomic_init_nob(&sys_misc_mem_sz, 0);
 }
 
 void noinherit_std_handle(DWORD type)
@@ -3190,9 +3190,9 @@ void erl_sys_init(void)
     noinherit_std_handle(STD_INPUT_HANDLE);
     noinherit_std_handle(STD_ERROR_HANDLE);
 
-    erts_smp_tsd_key_create(&win32_errstr_key,"win32_errstr_key");
+    erts_tsd_key_create(&win32_errstr_key,"win32_errstr_key");
     InitializeCriticalSection(&htbc_lock);
-    erts_smp_atomic_init_nob(&pipe_creation_counter,0);
+    erts_atomic_init_nob(&pipe_creation_counter,0);
     /*
      * Test if we have named pipes or not.
      */
@@ -3269,6 +3269,6 @@ void
 erl_sys_schedule(int runnable)
 {
     erts_check_io(!runnable);
-    ERTS_SMP_LC_ASSERT(!erts_thr_progress_is_blocking());
+    ERTS_LC_ASSERT(!erts_thr_progress_is_blocking());
 }
 
diff --git a/erts/emulator/sys/win32/sys_env.c b/erts/emulator/sys/win32/sys_env.c
index 8fcee1cbb6..5792816267 100644
--- a/erts/emulator/sys/win32/sys_env.c
+++ b/erts/emulator/sys/win32/sys_env.c
@@ -32,12 +32,12 @@ static WCHAR **env_to_arg(WCHAR *env);
 static WCHAR **find_arg(WCHAR **arg, WCHAR *str);

 static int compare(const void *a, const void *b);

 

-static erts_smp_rwmtx_t environ_rwmtx;

+static erts_rwmtx_t environ_rwmtx;
 

 void

 erts_sys_env_init(void)

 {

-    erts_smp_rwmtx_init(&environ_rwmtx, "environ", NIL,

+    erts_rwmtx_init(&environ_rwmtx, "environ", NIL,
         ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);

 }

 

@@ -45,10 +45,10 @@ int
 erts_sys_putenv_raw(char *key, char *value)

 {

     int res;

-    erts_smp_rwmtx_rwlock(&environ_rwmtx);

+    erts_rwmtx_rwlock(&environ_rwmtx);
     res = (SetEnvironmentVariable((LPCTSTR) key,

 				  (LPCTSTR) value) ? 0 : 1);

-    erts_smp_rwmtx_rwunlock(&environ_rwmtx);

+    erts_rwmtx_rwunlock(&environ_rwmtx);
     return res;

 }

 

@@ -58,10 +58,10 @@ erts_sys_putenv(char *key, char *value)
     int res;

     WCHAR *wkey = (WCHAR *) key;

     WCHAR *wvalue = (WCHAR *) value;

-    erts_smp_rwmtx_rwlock(&environ_rwmtx);

+    erts_rwmtx_rwlock(&environ_rwmtx);
     res = (SetEnvironmentVariableW(wkey,

 				   wvalue) ? 0 : 1);

-    erts_smp_rwmtx_rwunlock(&environ_rwmtx);

+    erts_rwmtx_rwunlock(&environ_rwmtx);
     return res;

 }

 

@@ -76,12 +76,12 @@ erts_sys_getenv(char *key, char *value, size_t *size)
     DWORD wsize = *size / (sizeof(WCHAR) / sizeof(char));

 

     SetLastError(0);

-    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    erts_rwmtx_rlock(&environ_rwmtx);
     new_size = GetEnvironmentVariableW(wkey,

 				       wvalue,

 				      (DWORD) wsize);

     res = !new_size && GetLastError() == ERROR_ENVVAR_NOT_FOUND ? -1 : 0;

-    erts_smp_rwmtx_runlock(&environ_rwmtx);

+    erts_rwmtx_runlock(&environ_rwmtx);
     if (res < 0)

 	return res;

     res = new_size > wsize ? 1 : 0;

@@ -111,22 +111,22 @@ int
 erts_sys_getenv_raw(char *key, char *value, size_t *size)

 {

     int res;

-    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    erts_rwmtx_rlock(&environ_rwmtx);
     res = erts_sys_getenv__(key, value, size);

-    erts_smp_rwmtx_runlock(&environ_rwmtx);

+    erts_rwmtx_runlock(&environ_rwmtx);
     return res;

 }

 

 void init_getenv_state(GETENV_STATE *state)

 {

-    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    erts_rwmtx_rlock(&environ_rwmtx);
     state->environment_strings = GetEnvironmentStringsW();

     state->next_string = state->environment_strings;

 }

 

 char *getenv_string(GETENV_STATE *state)

 {

-    ERTS_SMP_LC_ASSERT(erts_smp_lc_rwmtx_is_rlocked(&environ_rwmtx));

+    ERTS_LC_ASSERT(erts_lc_rwmtx_is_rlocked(&environ_rwmtx));
     if (state->next_string[0] == L'\0') {

 	return NULL;

     } else {

@@ -140,7 +140,7 @@ void fini_getenv_state(GETENV_STATE *state)
 {

     FreeEnvironmentStringsW(state->environment_strings);

     state->environment_strings = state->next_string = NULL;

-    erts_smp_rwmtx_runlock(&environ_rwmtx);

+    erts_rwmtx_runlock(&environ_rwmtx);
 }

 

 int erts_sys_unsetenv(char *key)

@@ -149,7 +149,7 @@ int erts_sys_unsetenv(char *key)
     WCHAR *wkey = (WCHAR *) key;

 

     SetLastError(0);

-    erts_smp_rwmtx_rlock(&environ_rwmtx);

+    erts_rwmtx_rlock(&environ_rwmtx);
     GetEnvironmentVariableW(wkey,

                             NULL,

                             0);

@@ -157,7 +157,7 @@ int erts_sys_unsetenv(char *key)
         res = (SetEnvironmentVariableW(wkey,

                                        NULL) ? 0 : 1);

     }

-    erts_smp_rwmtx_runlock(&environ_rwmtx);

+    erts_rwmtx_runlock(&environ_rwmtx);
     return res;

 }

 

@@ -171,12 +171,12 @@ win_build_environment(char* new_env)
 

 	tmp_new = (WCHAR *) new_env;

 	

-	erts_smp_rwmtx_rlock(&environ_rwmtx);

+	erts_rwmtx_rlock(&environ_rwmtx);
 	tmp = GetEnvironmentStringsW();

 	merged = merge_environment(tmp, tmp_new);

 

 	FreeEnvironmentStringsW(tmp);

-	erts_smp_rwmtx_runlock(&environ_rwmtx);

+	erts_rwmtx_runlock(&environ_rwmtx);
 	return (char *) merged;

     }

 }

diff --git a/erts/emulator/sys/win32/sys_interrupt.c b/erts/emulator/sys/win32/sys_interrupt.c
index 4632ab52b1..02aa50500f 100644
--- a/erts/emulator/sys/win32/sys_interrupt.c
+++ b/erts/emulator/sys/win32/sys_interrupt.c
@@ -35,11 +35,11 @@
 #  define WIN_SYS_INLINE __forceinline
 #endif
 
-erts_smp_atomic32_t erts_break_requested;
+erts_atomic32_t erts_break_requested;
 #define ERTS_SET_BREAK_REQUESTED \
-  erts_smp_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 1)
+  erts_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 1)
 #define ERTS_UNSET_BREAK_REQUESTED \
-  erts_smp_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 0)
+  erts_atomic32_set_nob(&erts_break_requested, (erts_aint32_t) 0)
 
 extern int nohup;
 HANDLE erts_sys_break_event = NULL;
@@ -51,14 +51,14 @@ void erts_do_break_handling(void)
      * therefore, make sure that all threads but this one are blocked before
      * proceeding!
      */
-    erts_smp_thr_progress_block();
+    erts_thr_progress_block();
     /* call the break handling function, reset the flag */
     do_break();
 
     ResetEvent(erts_sys_break_event);
     ERTS_UNSET_BREAK_REQUESTED;
 
-    erts_smp_thr_progress_unblock();
+    erts_thr_progress_unblock();
 }
 
 
diff --git a/erts/emulator/sys/win32/sys_time.c b/erts/emulator/sys/win32/sys_time.c
index 359010e9f1..25c2ad385c 100644
--- a/erts/emulator/sys/win32/sys_time.c
+++ b/erts/emulator/sys/win32/sys_time.c
@@ -95,7 +95,7 @@ struct sys_time_internal_state_read_mostly__ {
 };
 
 struct sys_time_internal_state_write_freq__ {
-    erts_smp_mtx_t mtime_mtx;
+    erts_mtx_t mtime_mtx;
     ULONGLONG wrap;
     ULONGLONG last_tick_count;
 };
@@ -294,7 +294,7 @@ sys_init_time(ErtsSysInitTimeResult *init_resp)
     module = GetModuleHandle(kernel_dll_name);
     if (!module) {
     get_tick_count:
-        erts_smp_mtx_init(&internal_state.w.f.mtime_mtx, "os_monotonic_time", NIL,
+        erts_mtx_init(&internal_state.w.f.mtime_mtx, "os_monotonic_time", NIL,
             ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_GENERIC);
 	internal_state.w.f.wrap = 0;
 	internal_state.w.f.last_tick_count = 0;