erts: Remove ERTS_SMP and USE_THREAD defines

This refactor was done using the unifdef tool like this:
    for file in $(find erts/ -name *.[ch]); do unifdef -t -f defile -o $file $file; done

where defile contained:
    #define ERTS_SMP 1
    #define USE_THREADS 1
    #define DDLL_SMP 1
    #define ERTS_HAVE_SMP_EMU 1
    #define SMP 1
    #define ERL_BITS_REENTRANT 1
    #define ERTS_USE_ASYNC_READY_Q 1
    #define FDBLOCK 1
    #undef ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
    #define ERTS_POLL_ASYNC_INTERRUPT_SUPPORT 0
    #define ERTS_POLL_USE_WAKEUP_PIPE 1
    #define ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE 1
    #undef ERTS_HAVE_PLAIN_EMU
    #undef ERTS_SIGNAL_STATE

15 files changed, 5 insertions, 515 deletions

diff --git a/erts/emulator/sys/common/erl_check_io.c b/erts/emulator/sys/common/erl_check_io.c
index 799f67fc45..ce9f6e3f06 100644
--- a/erts/emulator/sys/common/erl_check_io.c
+++ b/erts/emulator/sys/common/erl_check_io.c
@@ -84,9 +84,6 @@ typedef char EventStateFlags;
 #define ERTS_CIO_POLL_CTL	ERTS_POLL_EXPORT(erts_poll_control)
 #define ERTS_CIO_POLL_CTLV	ERTS_POLL_EXPORT(erts_poll_controlv)
 #define ERTS_CIO_POLL_WAIT	ERTS_POLL_EXPORT(erts_poll_wait)
-#ifdef ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
-#define ERTS_CIO_POLL_AS_INTR 	ERTS_POLL_EXPORT(erts_poll_async_sig_interrupt)
-#endif
 #define ERTS_CIO_POLL_INTR 	ERTS_POLL_EXPORT(erts_poll_interrupt)
 #define ERTS_CIO_POLL_INTR_TMD	ERTS_POLL_EXPORT(erts_poll_interrupt_timed)
 #define ERTS_CIO_NEW_POLLSET 	ERTS_POLL_EXPORT(erts_poll_create_pollset)
@@ -108,10 +105,8 @@ static struct pollset_info
 	int size;
 	ErtsSysFdType *array;
     } active_fd;
-#ifdef ERTS_SMP
     struct removed_fd* removed_list;       /* list of deselected fd's*/
     erts_smp_spinlock_t removed_list_lock;
-#endif
 }pollset;
 #define NUM_OF_POLLSETS 1
 
@@ -137,7 +132,6 @@ typedef struct {
     EventStateFlags flags;
 } ErtsDrvEventState;
 
-#ifdef ERTS_SMP
 struct removed_fd {
     struct removed_fd *next;
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
@@ -150,7 +144,6 @@ struct removed_fd {
 #endif
 
 };
-#endif
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
 static int max_fds = -1;
@@ -161,7 +154,6 @@ static union {
     byte _cache_line_alignment[64];
 }drv_ev_state_locks[DRV_EV_STATE_LOCK_CNT];
 
-#ifdef ERTS_SMP
 static ERTS_INLINE erts_smp_mtx_t* fd_mtx(ErtsSysFdType fd)
 {
     int hash = (int)fd;
@@ -170,9 +162,6 @@ static ERTS_INLINE erts_smp_mtx_t* fd_mtx(ErtsSysFdType fd)
 # endif
     return &drv_ev_state_locks[hash % DRV_EV_STATE_LOCK_CNT].lck;
 }
-#else
-#  define fd_mtx(fd) NULL
-#endif
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
 
@@ -249,9 +238,7 @@ static void
 steal_pending_stop_nif(erts_dsprintf_buf_t *dsbufp, ErtsResource*,
                        ErtsDrvEventState *state, int mode, int on);
 
-#ifdef ERTS_SMP
 ERTS_SCHED_PREF_QUICK_ALLOC_IMPL(removed_fd, struct removed_fd, 64, ERTS_ALC_T_FD_LIST)
-#endif
 
 static ERTS_INLINE void
 init_iotask(ErtsIoTask *io_task)
@@ -337,7 +324,6 @@ free_drv_event_data(ErtsDrvEventDataState *dep)
 static ERTS_INLINE void
 remember_removed(ErtsDrvEventState *state, struct pollset_info* psi)
 {
-#ifdef ERTS_SMP
     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)) {
@@ -355,29 +341,23 @@ remember_removed(ErtsDrvEventState *state, struct pollset_info* psi)
 	psi->removed_list = fdlp;
 	erts_smp_spin_unlock(&psi->removed_list_lock);
     }
-#endif
 }
 
 
 static ERTS_INLINE int
 is_removed(ErtsDrvEventState *state)
 {
-#ifdef ERTS_SMP
     /* Note that there is a possible race here, where an fd is removed
        (increasing remove_cnt) and then added again just before erts_poll_wait
        is called by erts_check_io. Any polled event on the re-added fd will then
        be falsely ignored. But that does not matter, as the event will trigger
        again next time erl_check_io is called. */
     return state->remove_cnt > 0;
-#else
-    return 0;
-#endif
 }
 
 static void
 forget_removed(struct pollset_info* psi)
 {
-#ifdef ERTS_SMP
     struct removed_fd* fdlp;
     struct removed_fd* tofree;
 
@@ -460,7 +440,6 @@ forget_removed(struct pollset_info* psi)
 	fdlp = fdlp->next;
 	removed_fd_free(tofree);
     }
-#endif /* ERTS_SMP */
 }
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
@@ -2118,13 +2097,6 @@ eready(Eterm id, ErtsDrvEventState *state, ErlDrvEventData event_data,
 
 static void bad_fd_in_pollset(ErtsDrvEventState *, Eterm inport, Eterm outport);
 
-#ifdef ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
-void
-ERTS_CIO_EXPORT(erts_check_io_async_sig_interrupt)(void)
-{
-    ERTS_CIO_POLL_AS_INTR(pollset.ps);
-}
-#endif
 
 void
 ERTS_CIO_EXPORT(erts_check_io_interrupt)(int set)
@@ -2355,9 +2327,7 @@ ERTS_CIO_EXPORT(erts_check_io)(int do_wait)
                 add_active_fd(state->fd);
             }
 
-#ifdef ERTS_SMP
             erts_smp_mtx_unlock(fd_mtx(fd));
-#endif
             if (is_not_nil(in.pid)) {
                 send_event_tuple(&in, resource, am_ready_input);
             }
@@ -2404,9 +2374,7 @@ ERTS_CIO_EXPORT(erts_check_io)(int do_wait)
 	}
 
 	next_pollres:;
-#ifdef ERTS_SMP
 	erts_smp_mtx_unlock(fd_mtx(fd));
-#endif
         next_pollres_unlocked:;
     }
 
@@ -2561,7 +2529,6 @@ ERTS_CIO_EXPORT(erts_init_check_io)(void)
 #endif
 
 
-#ifdef ERTS_SMP
     init_removed_fd_alloc();
     pollset.removed_list = NULL;
     erts_smp_spinlock_init(&pollset.removed_list_lock, "pollset_rm_list", NIL,
@@ -2573,7 +2540,6 @@ ERTS_CIO_EXPORT(erts_init_check_io)(void)
                 ERTS_LOCK_FLAGS_PROPERTY_STATIC | ERTS_LOCK_FLAGS_CATEGORY_IO);
         }
     }
-#endif
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
     max_fds = ERTS_CIO_POLL_MAX_FDS();
     erts_smp_atomic_init_nob(&drv_ev_state_len, 0);
diff --git a/erts/emulator/sys/common/erl_check_io.h b/erts/emulator/sys/common/erl_check_io.h
index 2d3bb98afa..d74eb764d2 100644
--- a/erts/emulator/sys/common/erl_check_io.h
+++ b/erts/emulator/sys/common/erl_check_io.h
@@ -44,10 +44,6 @@ Eterm erts_check_io_info_kp(void *);
 Eterm erts_check_io_info_nkp(void *);
 int erts_check_io_max_files_kp(void);
 int erts_check_io_max_files_nkp(void);
-#ifdef ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
-void erts_check_io_async_sig_interrupt_kp(void);
-void erts_check_io_async_sig_interrupt_nkp(void);
-#endif
 void erts_check_io_interrupt_kp(int);
 void erts_check_io_interrupt_nkp(int);
 void erts_check_io_interrupt_timed_kp(int, ErtsMonotonicTime);
@@ -69,9 +65,6 @@ void erts_lcnt_update_cio_locks_nkp(int enable);
 Uint erts_check_io_size(void);
 Eterm erts_check_io_info(void *);
 int erts_check_io_max_files(void);
-#ifdef ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
-void erts_check_io_async_sig_interrupt(void);
-#endif
 void erts_check_io_interrupt(int);
 void erts_check_io_interrupt_timed(int, ErtsMonotonicTime);
 void erts_check_io(int);
diff --git a/erts/emulator/sys/common/erl_mseg.c b/erts/emulator/sys/common/erl_mseg.c
index d69a79dc2a..d5b2fa87e4 100644
--- a/erts/emulator/sys/common/erl_mseg.c
+++ b/erts/emulator/sys/common/erl_mseg.c
@@ -188,7 +188,6 @@ typedef union {
 static int no_mseg_allocators;
 static ErtsAlgndMsegAllctr_t *aligned_mseg_allctr;
 
-#ifdef ERTS_SMP
 
 #define ERTS_MSEG_ALLCTR_IX(IX) \
   (&aligned_mseg_allctr[(IX)].mseg_alloc)
@@ -199,18 +198,6 @@ static ErtsAlgndMsegAllctr_t *aligned_mseg_allctr;
 #define ERTS_MSEG_ALLCTR_OPT(OPT) \
   ((OPT)->sched_spec ? ERTS_MSEG_ALLCTR_SS() : ERTS_MSEG_ALLCTR_IX(0))
 
-#else
-
-#define ERTS_MSEG_ALLCTR_IX(IX) \
-  (&aligned_mseg_allctr[0].mseg_alloc)
-
-#define ERTS_MSEG_ALLCTR_SS() \
-  (&aligned_mseg_allctr[0].mseg_alloc)
-
-#define ERTS_MSEG_ALLCTR_OPT(OPT) \
-  (&aligned_mseg_allctr[0].mseg_alloc)
-
-#endif
 
 #define ERTS_MSEG_LOCK(MA)		\
 do {					\
@@ -1404,11 +1391,7 @@ erts_mseg_init(ErtsMsegInit_t *init)
     int i;
     UWord x;
 
-#ifdef ERTS_SMP
     no_mseg_allocators = init->nos + 1;
-#else
-    no_mseg_allocators = 1;
-#endif
 
     x = (UWord) malloc(sizeof(ErtsAlgndMsegAllctr_t)
 		       *no_mseg_allocators
diff --git a/erts/emulator/sys/common/erl_os_monotonic_time_extender.c b/erts/emulator/sys/common/erl_os_monotonic_time_extender.c
index d53190fdd5..341845cc2a 100644
--- a/erts/emulator/sys/common/erl_os_monotonic_time_extender.c
+++ b/erts/emulator/sys/common/erl_os_monotonic_time_extender.c
@@ -23,7 +23,6 @@
 #endif
 #include "erl_os_monotonic_time_extender.h"
 
-#ifdef USE_THREADS
 
 static void *os_monotonic_time_extender(void *vstatep)
 {
@@ -49,30 +48,22 @@ static void *os_monotonic_time_extender(void *vstatep)
 }
 
 static erts_tid_t os_monotonic_extender_tid;
-#endif
 
 void
 erts_init_os_monotonic_time_extender(ErtsOsMonotonicTimeExtendState *statep,
 				     Uint32 (*raw_os_monotonic_time)(void),
 				     int check_seconds)
 {
-#ifdef USE_THREADS
     statep->raw_os_monotonic_time = raw_os_monotonic_time;
     erts_atomic32_init_nob(&statep->extend[0], (erts_aint32_t) 0);
     erts_atomic32_init_nob(&statep->extend[1], (erts_aint32_t) 0);
     statep->check_interval = check_seconds;
 
-#else
-    statep->extend[0] = (Uint32) 0;
-    statep->extend[1] = (Uint32) 0;
-    statep->last_msb = (ErtsMonotonicTime) 0;
-#endif
 }
 
 void
 erts_late_init_os_monotonic_time_extender(ErtsOsMonotonicTimeExtendState *statep)
 {
-#ifdef USE_THREADS
     erts_thr_opts_t thr_opts = ERTS_THR_OPTS_DEFAULT_INITER;
     thr_opts.detached = 1;
     thr_opts.suggested_stack_size = 4;
@@ -85,5 +76,4 @@ erts_late_init_os_monotonic_time_extender(ErtsOsMonotonicTimeExtendState *statep
 		    os_monotonic_time_extender,
 		    (void*) statep,
 		    &thr_opts);
-#endif
 }
diff --git a/erts/emulator/sys/common/erl_os_monotonic_time_extender.h b/erts/emulator/sys/common/erl_os_monotonic_time_extender.h
index 8089c9aed9..2266f26e24 100644
--- a/erts/emulator/sys/common/erl_os_monotonic_time_extender.h
+++ b/erts/emulator/sys/common/erl_os_monotonic_time_extender.h
@@ -25,36 +25,17 @@
 #include "erl_threads.h"
 
 typedef struct {
-#ifdef USE_THREADS
     Uint32 (*raw_os_monotonic_time)(void);
     erts_atomic32_t extend[2];
     int check_interval;
-#else
-    Uint32 extend[2];
-    ErtsMonotonicTime last_msb;
-#endif
 } ErtsOsMonotonicTimeExtendState;
 
-#ifdef USE_THREADS
 #  define ERTS_CHK_EXTEND_OS_MONOTONIC_TIME(S, RT) ((void) 1)
 #  define ERTS_EXTEND_OS_MONOTONIC_TIME(S, RT)				\
     ((((ErtsMonotonicTime)						\
        erts_atomic32_read_nob(&((S)->extend[((int) ((RT) >> 31)) & 1]))) \
       << 32)								\
      + (RT))
-#else
-#  define ERTS_CHK_EXTEND_OS_MONOTONIC_TIME(S, RT)			\
-    do {								\
-	Uint32 msb__ = (RT) & (((Uint32) 1) << 31);			\
-	if (msb__ != (S)->last_msb) {					\
-	    int ix__ = ((int) ((S)->last_msb >> 31)) & 1;		\
-	    (S)->extend[ix__]++;					\
-	    (S)->last_msb = msb;					\
-	}								\
-    } while (0)
-#  define ERTS_EXTEND_OS_MONOTONIC_TIME(S, RT)				\
-    ((((ErtsMonotonicTime) (S)->extend[((int) ((RT) >> 31)) & 1]) << 32) + (RT))
-#endif
 
 void
 erts_init_os_monotonic_time_extender(ErtsOsMonotonicTimeExtendState *statep,
diff --git a/erts/emulator/sys/common/erl_poll.c b/erts/emulator/sys/common/erl_poll.c
index 52a8b6a53f..3a6ae85b42 100644
--- a/erts/emulator/sys/common/erl_poll.c
+++ b/erts/emulator/sys/common/erl_poll.c
@@ -95,9 +95,6 @@
 #define ERTS_POLL_DEBUG_PRINT
 #endif
 
-#if defined(DEBUG) && 0
-#define HARD_DEBUG
-#endif
 
 #ifdef _DARWIN_UNLIMITED_SELECT
 typedef struct {
@@ -155,16 +152,11 @@ 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)
 
-#ifdef ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
-#  define ERTS_POLL_ASYNC_INTERRUPT_SUPPORT 1
-#else
 #  define ERTS_POLL_ASYNC_INTERRUPT_SUPPORT 0
-#endif
 
 #define ERTS_POLL_USE_WAKEUP_PIPE \
    (ERTS_POLL_ASYNC_INTERRUPT_SUPPORT || defined(USE_THREADS))
 
-#ifdef ERTS_SMP
 
 #define ERTS_POLLSET_LOCK(PS) \
   erts_smp_mtx_lock(&(PS)->mtx)
@@ -178,28 +170,13 @@ int ERTS_SELECT(int nfds, ERTS_fd_set *readfds, ERTS_fd_set *writefds,
 #define ERTS_POLLSET_IS_POLLED(PS) \
   ((int) erts_atomic32_read_nob(&(PS)->polled))
 
-#else
-
-#define ERTS_POLLSET_LOCK(PS)
-#define ERTS_POLLSET_UNLOCK(PS)
-#define ERTS_POLLSET_SET_POLLED_CHK(PS) 0
-#define ERTS_POLLSET_UNSET_POLLED(PS)
-#define ERTS_POLLSET_IS_POLLED(PS) 0
 
-#endif
-
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
 #define ERTS_POLLSET_SET_HAVE_UPDATE_REQUESTS(PS) \
   erts_smp_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)
 #define ERTS_POLLSET_HAVE_UPDATE_REQUESTS(PS) \
   ((int) erts_smp_atomic32_read_nob(&(PS)->have_update_requests))
-#else
-#define ERTS_POLLSET_SET_HAVE_UPDATE_REQUESTS(PS)
-#define ERTS_POLLSET_UNSET_HAVE_UPDATE_REQUESTS(PS)
-#define ERTS_POLLSET_HAVE_UPDATE_REQUESTS(PS) 0
-#endif
 
 #if ERTS_POLL_USE_FALLBACK
 #  if ERTS_POLL_USE_POLL
@@ -212,7 +189,6 @@ int ERTS_SELECT(int nfds, ERTS_fd_set *readfds, ERTS_fd_set *writefds,
  * --- Data types ------------------------------------------------------------
  */
 
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
 #define ERTS_POLLSET_UPDATE_REQ_BLOCK_SIZE 128
 
 typedef struct ErtsPollSetUpdateRequestsBlock_ ErtsPollSetUpdateRequestsBlock;
@@ -222,19 +198,14 @@ struct ErtsPollSetUpdateRequestsBlock_ {
     int fds[ERTS_POLLSET_UPDATE_REQ_BLOCK_SIZE];
 };
 
-#endif
 
 
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
 #  define ERTS_POLL_FD_FLG_INURQ	(((unsigned short) 1) << 0)
-#endif
 #if ERTS_POLL_USE_FALLBACK
 #  define ERTS_POLL_FD_FLG_INFLBCK	(((unsigned short) 1) << 1)
 #  define ERTS_POLL_FD_FLG_USEFLBCK	(((unsigned short) 1) << 2)
 #endif
-#if ERTS_POLL_USE_KERNEL_POLL || defined(ERTS_SMP)
 #  define ERTS_POLL_FD_FLG_RST		(((unsigned short) 1) << 3)
-#endif
 typedef struct {
 #if ERTS_POLL_USE_POLL
     int pix;
@@ -244,9 +215,7 @@ typedef struct {
 #if ERTS_POLL_COALESCE_KP_RES
     unsigned short res_ev_ix;
 #endif
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE || ERTS_POLL_USE_FALLBACK
     unsigned short flags;
-#endif
 
 } ErtsFdStatus;
 
@@ -301,27 +270,19 @@ struct ErtsPollSet_ {
     ERTS_fd_set output_fds;
     ERTS_fd_set res_output_fds;
 #endif
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
     ErtsPollSetUpdateRequestsBlock update_requests;
     ErtsPollSetUpdateRequestsBlock *curr_upd_req_block;
     erts_smp_atomic32_t have_update_requests;
-#endif
-#ifdef ERTS_SMP
     erts_atomic32_t polled;
     erts_smp_mtx_t mtx;
-#endif
-#if ERTS_POLL_USE_WAKEUP_PIPE
     int wake_fds[2];
-#endif
 #if ERTS_POLL_USE_TIMERFD
     int timer_fd;
 #endif
 #if ERTS_POLL_USE_FALLBACK
     int fallback_used;
 #endif
-#if defined(USE_THREADS) || ERTS_POLL_ASYNC_INTERRUPT_SUPPORT
     erts_atomic32_t wakeup_state;
-#endif
     erts_atomic64_t timeout_time;
 #ifdef ERTS_POLL_COUNT_AVOIDED_WAKEUPS
     erts_smp_atomic_t no_avoided_wakeups;
@@ -413,50 +374,37 @@ get_timeout_time(ErtsPollSet ps)
 static ERTS_INLINE void
 reset_wakeup_state(ErtsPollSet ps)
 {
-#if defined(USE_THREADS) || ERTS_POLL_ASYNC_INTERRUPT_SUPPORT
     erts_atomic32_set_mb(&ps->wakeup_state, ERTS_POLL_NOT_WOKEN);
-#endif
 }
 
 static ERTS_INLINE int
 is_woken(ErtsPollSet ps)
 {
-#if defined(USE_THREADS) || ERTS_POLL_ASYNC_INTERRUPT_SUPPORT
     return erts_atomic32_read_acqb(&ps->wakeup_state) != ERTS_POLL_NOT_WOKEN;
-#else
-    return 0;
-#endif
 }
 
 static ERTS_INLINE int
 is_interrupted_reset(ErtsPollSet ps)
 {
-#if defined(USE_THREADS) || ERTS_POLL_ASYNC_INTERRUPT_SUPPORT
     return (erts_atomic32_xchg_acqb(&ps->wakeup_state, ERTS_POLL_NOT_WOKEN)
 	    == ERTS_POLL_WOKEN_INTR);
-#else
-    return 0;
-#endif
 }
 
 static ERTS_INLINE void
 woke_up(ErtsPollSet ps)
 {
-#if defined(USE_THREADS) || ERTS_POLL_ASYNC_INTERRUPT_SUPPORT
     erts_aint32_t wakeup_state = erts_atomic32_read_acqb(&ps->wakeup_state);
     if (wakeup_state == ERTS_POLL_NOT_WOKEN)
 	(void) erts_atomic32_cmpxchg_nob(&ps->wakeup_state,
 					 ERTS_POLL_WOKEN,
 					 ERTS_POLL_NOT_WOKEN);
     ASSERT(erts_atomic32_read_nob(&ps->wakeup_state) != ERTS_POLL_NOT_WOKEN);
-#endif
 }
 
 /*
  * --- Wakeup pipe -----------------------------------------------------------
  */
 
-#if ERTS_POLL_USE_WAKEUP_PIPE
 
 static ERTS_INLINE void
 wake_poller(ErtsPollSet ps, int interrupted, int async_signal_safe)
@@ -507,18 +455,11 @@ wake_poller(ErtsPollSet ps, int interrupted, int async_signal_safe)
 static ERTS_INLINE void
 cleanup_wakeup_pipe(ErtsPollSet ps)
 {
-#if ERTS_POLL_ASYNC_INTERRUPT_SUPPORT
-    int intr = 0;
-#endif
     int fd = ps->wake_fds[0];
     int res;
     do {
 	char buf[32];
 	res = read(fd, buf, sizeof(buf));
-#if ERTS_POLL_ASYNC_INTERRUPT_SUPPORT
-	if (res > 0)
-	    intr = 1;
-#endif
     } while (res > 0 || (res < 0 && errno == EINTR));
     if (res < 0 && errno != ERRNO_BLOCK) {
 	fatal_error("%s:%d:cleanup_wakeup_pipe(): "
@@ -528,10 +469,6 @@ cleanup_wakeup_pipe(ErtsPollSet ps)
 		    fd,
 		    erl_errno_id(errno), errno);
     }
-#if ERTS_POLL_ASYNC_INTERRUPT_SUPPORT
-    if (intr)
-	erts_atomic32_set_nob(&ps->wakeup_state, ERTS_POLL_WOKEN_INTR);
-#endif
 }
 
 static void
@@ -574,7 +511,6 @@ create_wakeup_pipe(ErtsPollSet ps)
     ps->wake_fds[1] = wake_fds[1];
 }
 
-#endif /* ERTS_POLL_USE_WAKEUP_PIPE */
 
 /*
  * --- timer fd -----------------------------------------------------------
@@ -648,7 +584,6 @@ timerfd_clear(ErtsPollSet ps, int res, int max_res) {
 /*
  * --- Poll set update requests ----------------------------------------------
  */
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
 
 static ERTS_INLINE void
 enqueue_update_request(ErtsPollSet ps, int fd)
@@ -691,7 +626,6 @@ free_update_requests_block(ErtsPollSet ps,
     }
 }
 
-#endif /* ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE */
 
 /*
  * --- Growing poll set structures -------------------------------------------
@@ -819,9 +753,7 @@ grow_fds_status(ErtsPollSet ps, int min_fd)
 #if ERTS_POLL_COALESCE_KP_RES
 	ps->fds_status[i].res_ev_ix = (unsigned short) ERTS_POLL_MAX_RES;
 #endif
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE || ERTS_POLL_USE_FALLBACK
 	ps->fds_status[i].flags = (unsigned short) 0;
-#endif
     }
     ps->fds_status_len = new_len;
 }
@@ -849,7 +781,7 @@ need_update(ErtsPollSet ps, int fd)
 	ps->fds_status[fd].flags &= ~ERTS_POLL_FD_FLG_RST;
 	reset = 0;
     }
-#elif defined(ERTS_SMP)
+#else
     ps->fds_status[fd].flags &= ~ERTS_POLL_FD_FLG_RST;
 #endif
 
@@ -1518,7 +1450,6 @@ static int update_pollset(ErtsPollSet ps, int fd)
 
 #endif /* ERTS_POLL_USE_POLL || ERTS_POLL_USE_SELECT || ERTS_POLL_USE_FALLBACK */
 
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
 
 static void
 handle_update_requests(ErtsPollSet ps)
@@ -1565,7 +1496,6 @@ handle_update_requests(ErtsPollSet ps)
     ERTS_POLLSET_UNSET_HAVE_UPDATE_REQUESTS(ps);
 }
 
-#endif /* ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE */
 
 static ERTS_INLINE ErtsPollEvents
 poll_control(ErtsPollSet ps, int fd, ErtsPollEvents events, int on, int *do_wake)
@@ -1583,12 +1513,10 @@ poll_control(ErtsPollSet ps, int fd, ErtsPollEvents events, int on, int *do_wake
 	    goto done;
 	}
 #endif
-#if ERTS_POLL_USE_WAKEUP_PIPE
 	if (fd == ps->wake_fds[0] || fd == ps->wake_fds[1]) {
 	    new_events = ERTS_POLL_EV_NVAL;
 	    goto done;
 	}
-#endif
 #if ERTS_POLL_USE_TIMERFD
 	if (fd == ps->timer_fd) {
 	    new_events = ERTS_POLL_EV_NVAL;
@@ -1615,9 +1543,7 @@ poll_control(ErtsPollSet ps, int fd, ErtsPollEvents events, int on, int *do_wake
 	new_events &= ~events;
 
     if (new_events == (ErtsPollEvents) 0) {
-#if ERTS_POLL_USE_KERNEL_POLL || defined(ERTS_SMP)
 	ps->fds_status[fd].flags |= ERTS_POLL_FD_FLG_RST;
-#endif
 #if ERTS_POLL_USE_FALLBACK
 	ps->fds_status[fd].flags &= ~ERTS_POLL_FD_FLG_USEFLBCK;
 #endif
@@ -1626,18 +1552,12 @@ poll_control(ErtsPollSet ps, int fd, ErtsPollEvents events, int on, int *do_wake
     ps->fds_status[fd].events = new_events;
 
     if (new_events == ps->fds_status[fd].used_events
-#if ERTS_POLL_USE_KERNEL_POLL || defined(ERTS_SMP)
 	&& !(ps->fds_status[fd].flags & ERTS_POLL_FD_FLG_RST)
-#endif
 	) {
 	*do_wake = 0;
 	goto done;
     }
 
-#if !ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
-    if (update_pollset(ps, fd) != 0)
-	new_events = ERTS_POLL_EV_ERR;
-#else /* ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE */
 
 #if ERTS_POLL_USE_CONCURRENT_UPDATE
     if (ERTS_POLLSET_IS_POLLED(ps)) {
@@ -1652,7 +1572,6 @@ poll_control(ErtsPollSet ps, int fd, ErtsPollEvents events, int on, int *do_wake
 
     enqueue_update_request(ps, fd);
 	
-#ifdef ERTS_SMP
     /*
      * If new events have been added, we need to wake up the
      * polling thread, but if events have been removed we don't.
@@ -1660,9 +1579,7 @@ poll_control(ErtsPollSet ps, int fd, ErtsPollEvents events, int on, int *do_wake
     if ((new_events && (ps->fds_status[fd].flags & ERTS_POLL_FD_FLG_RST))
 	|| (~ps->fds_status[fd].used_events & new_events))
 	*do_wake = 1;
-#endif /* ERTS_SMP */
 
-#endif /* ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE */
 
  done:
 #ifdef ERTS_POLL_DEBUG_PRINT
@@ -1695,10 +1612,8 @@ ERTS_POLL_EXPORT(erts_poll_controlv)(ErtsPollSet ps,
 
     ERTS_POLLSET_UNLOCK(ps);
 
-#ifdef ERTS_SMP
     if (final_do_wake)
 	wake_poller(ps, 0, 0);
-#endif /* ERTS_SMP */
 
 }
 
@@ -1718,11 +1633,9 @@ ERTS_POLL_EXPORT(erts_poll_control)(ErtsPollSet ps,
 
     ERTS_POLLSET_UNLOCK(ps);
 
-#ifdef ERTS_SMP
     if (*do_wake) {
 	wake_poller(ps, 0, 0);
     }
-#endif /* ERTS_SMP */
 
     return res;
 }
@@ -1739,9 +1652,7 @@ save_kp_result(ErtsPollSet ps, ErtsPollResFd pr[], int max_res, int chk_fds_res)
     int res = 0;
     int i;
     int n = chk_fds_res < max_res ? chk_fds_res : max_res;
-#if ERTS_POLL_USE_WAKEUP_PIPE
     int wake_fd = ps->wake_fds[0];
-#endif
 #if ERTS_POLL_USE_TIMERFD
     int timer_fd = ps->timer_fd;
 #endif
@@ -1754,12 +1665,10 @@ save_kp_result(ErtsPollSet ps, ErtsPollResFd pr[], int max_res, int chk_fds_res)
 	    int fd = ps->res_events[i].data.fd;
 	    int ix;
 	    ErtsPollEvents revents;
-#if ERTS_POLL_USE_WAKEUP_PIPE
 	    if (fd == wake_fd) {
 		cleanup_wakeup_pipe(ps);
 		continue;
 	    }
-#endif
 #if ERTS_POLL_USE_TIMERFD
             if (fd == timer_fd) {
                 continue;
@@ -1805,12 +1714,10 @@ save_kp_result(ErtsPollSet ps, ErtsPollResFd pr[], int max_res, int chk_fds_res)
 	}
 
 	if (ev->filter == EVFILT_READ) {
-#if ERTS_POLL_USE_WAKEUP_PIPE
 	    if (fd == wake_fd) {
 		cleanup_wakeup_pipe(ps);
 		continue;
 	    }
-#endif
 	    pr[ix].events |= ERTS_POLL_EV_IN;
 	}
 	else if (ev->filter == EVFILT_WRITE)
@@ -1833,12 +1740,10 @@ save_kp_result(ErtsPollSet ps, ErtsPollResFd pr[], int max_res, int chk_fds_res)
 	if (ps->res_events[i].revents) {
 	    int fd = ps->res_events[i].fd;
 	    ErtsPollEvents revents;
-#if ERTS_POLL_USE_WAKEUP_PIPE
 	    if (fd == wake_fd) {
 		cleanup_wakeup_pipe(ps);
 		continue;
 	    }
-#endif
 #if ERTS_POLL_USE_TIMERFD
 	    if (fd == timer_fd) {
 		continue;
@@ -1938,7 +1843,7 @@ save_poll_result(ErtsPollSet ps, ErtsPollResFd pr[], int max_res,
 			i++;
 			continue;
 		    }
-#elif ERTS_POLL_USE_WAKEUP_PIPE
+#else
 		    if (fd == wake_fd) {
 			cleanup_wakeup_pipe(ps);
 			i++;
@@ -1988,7 +1893,7 @@ save_poll_result(ErtsPollSet ps, ErtsPollResFd pr[], int max_res,
 			    fd++;
 			    continue;
 			}
-#elif ERTS_POLL_USE_WAKEUP_PIPE
+#else
 			if (fd == wake_fd) {
 			    cleanup_wakeup_pipe(ps);
 			    fd++;
@@ -2051,7 +1956,7 @@ save_poll_result(ErtsPollSet ps, ErtsPollResFd pr[], int max_res,
 				fd++;
 				continue;
 			    }
-#elif ERTS_POLL_USE_WAKEUP_PIPE
+#else
 			    if (fd == wake_fd) {
 				cleanup_wakeup_pipe(ps);
 				fd++;
@@ -2073,7 +1978,7 @@ save_poll_result(ErtsPollSet ps, ErtsPollResFd pr[], int max_res,
 				    fd++;
 				    continue;
 				}
-#elif ERTS_POLL_USE_WAKEUP_PIPE
+#else
 				if (fd == wake_fd) {
 				    cleanup_wakeup_pipe(ps);
 				    fd++;
@@ -2261,9 +2166,7 @@ check_fd_events(ErtsPollSet ps, ErtsMonotonicTime timeout_time, int max_res)
                 struct itimerspec its;
                 timeout = get_timeout_itimerspec(ps, &its, timeout_time);
                 if (timeout) {
-#ifdef ERTS_SMP
                     erts_thr_progress_prepare_wait(NULL);
-#endif
                     ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_SLEEP);
                     timerfd_set(ps, &its);
                     res = epoll_wait(ps->kp_fd, ps->res_events, max_res, -1);
@@ -2275,9 +2178,7 @@ check_fd_events(ErtsPollSet ps, ErtsMonotonicTime timeout_time, int max_res)
 #else /* !ERTS_POLL_USE_TIMERFD */
 	    timeout = (int) get_timeout(ps, 1000, timeout_time);
             if (timeout) {
-#ifdef ERTS_SMP
 		erts_thr_progress_prepare_wait(NULL);
-#endif
                 ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_SLEEP);
             }
 	    res = epoll_wait(ps->kp_fd, ps->res_events, max_res, timeout);
@@ -2288,9 +2189,7 @@ check_fd_events(ErtsPollSet ps, ErtsMonotonicTime timeout_time, int max_res)
 		grow_res_events(ps, max_res);
 	    timeout = get_timeout_timespec(ps, &ts, timeout_time);
             if (timeout) {
-#ifdef ERTS_SMP
 		erts_thr_progress_prepare_wait(NULL);
-#endif
 		ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_SLEEP);
             }
 	    res = kevent(ps->kp_fd, NULL, 0, ps->res_events, max_res, &ts);
@@ -2308,18 +2207,14 @@ check_fd_events(ErtsPollSet ps, ErtsMonotonicTime timeout_time, int max_res)
 	     */
 	    struct dvpoll poll_res;
 	    int nfds = (int) erts_smp_atomic_read_nob(&ps->no_of_user_fds);
-#if ERTS_POLL_USE_WAKEUP_PIPE
 	    nfds++; /* Wakeup pipe */
-#endif
 	    timeout = (int) get_timeout(ps, 1000, timeout_time);
 	    poll_res.dp_nfds = nfds < max_res ? nfds : max_res;
 	    if (poll_res.dp_nfds > ps->res_events_len)
 		grow_res_events(ps, poll_res.dp_nfds);
 	    poll_res.dp_fds = ps->res_events;
 	    if (timeout) {
-#ifdef ERTS_SMP
 		erts_thr_progress_prepare_wait(NULL);
-#endif
                 ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_SLEEP);
             }
 	    poll_res.dp_timeout = timeout;
@@ -2328,9 +2223,7 @@ check_fd_events(ErtsPollSet ps, ErtsMonotonicTime timeout_time, int max_res)
             struct timespec ts;
 	    timeout = get_timeout_timespec(ps, &ts, timeout_time);
             if (timeout) {
-#ifdef ERTS_SMP
 		erts_thr_progress_prepare_wait(NULL);
-#endif
 		ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_SLEEP);
             }
             res = ppoll(ps->poll_fds, ps->no_poll_fds, &ts, NULL);
@@ -2338,9 +2231,7 @@ check_fd_events(ErtsPollSet ps, ErtsMonotonicTime timeout_time, int max_res)
 	    timeout = (int) get_timeout(ps, 1000, timeout_time);
 
 	    if (timeout) {
-#ifdef ERTS_SMP
 		erts_thr_progress_prepare_wait(NULL);
-#endif
 		ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_SLEEP);
             }
 	    res = poll(ps->poll_fds, ps->no_poll_fds, timeout);
@@ -2352,9 +2243,7 @@ check_fd_events(ErtsPollSet ps, ErtsMonotonicTime timeout_time, int max_res)
 	    ERTS_FD_COPY(&ps->output_fds, &ps->res_output_fds);
 
 	    if (timeout) {
-#ifdef ERTS_SMP
 		erts_thr_progress_prepare_wait(NULL);
-#endif
 		ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_SLEEP);
 	    }
 	    res = ERTS_SELECT(ps->max_fd + 1,
@@ -2362,7 +2251,6 @@ check_fd_events(ErtsPollSet ps, ErtsMonotonicTime timeout_time, int max_res)
 			      &ps->res_output_fds,
 			      NULL,
 			      &to);
-#ifdef ERTS_SMP
 	    if (timeout) {
 		erts_thr_progress_finalize_wait(NULL);
 		ERTS_MSACC_POP_STATE_M();
@@ -2397,14 +2285,11 @@ check_fd_events(ErtsPollSet ps, ErtsMonotonicTime timeout_time, int max_res)
 		    res = -1;
 		}
 	    }
-#endif /* ERTS_SMP */
 	    return res;
 #endif				/* ----------------------------------------- */
 	}
 	if (timeout) {
-#ifdef ERTS_SMP
 	    erts_thr_progress_finalize_wait(NULL);
-#endif
 	    ERTS_MSACC_POP_STATE_M();
 	}
 	return res;
@@ -2420,9 +2305,7 @@ ERTS_POLL_EXPORT(erts_poll_wait)(ErtsPollSet ps,
     ErtsMonotonicTime to;
     int res, no_fds;
     int ebadf = 0;
-#ifdef ERTS_SMP
     int ps_locked = 0;
-#endif
 
     no_fds = *len;
 #ifdef ERTS_POLL_MAX_RES
@@ -2447,13 +2330,11 @@ ERTS_POLL_EXPORT(erts_poll_wait)(ErtsPollSet ps,
 	  ? ERTS_POLL_NO_TIMEOUT /* Use zero timeout */
 	  : timeout_time);
 
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
     if (ERTS_POLLSET_HAVE_UPDATE_REQUESTS(ps)) {
 	ERTS_POLLSET_LOCK(ps);
 	handle_update_requests(ps);
 	ERTS_POLLSET_UNLOCK(ps);
     }
-#endif
 
     while (1) {
 	res = check_fd_events(ps, to, no_fds);
@@ -2484,10 +2365,8 @@ ERTS_POLL_EXPORT(erts_poll_wait)(ErtsPollSet ps,
     save_results:
 #endif
 
-#ifdef ERTS_SMP
 	ps_locked = 1;
 	ERTS_POLLSET_LOCK(ps);
-#endif
 
 	no_fds = save_poll_result(ps, pr, no_fds, res, ebadf);
 
@@ -2499,11 +2378,9 @@ ERTS_POLL_EXPORT(erts_poll_wait)(ErtsPollSet ps,
 	*len = no_fds;
     }
 
-#ifdef ERTS_SMP
     if (ps_locked)
 	ERTS_POLLSET_UNLOCK(ps);
     ERTS_POLLSET_UNSET_POLLED(ps);
-#endif
 
  done:
     set_timeout_time(ps, ERTS_MONOTONIC_TIME_MAX);
@@ -2522,25 +2399,12 @@ ERTS_POLL_EXPORT(erts_poll_wait)(ErtsPollSet ps,
 void
 ERTS_POLL_EXPORT(erts_poll_interrupt)(ErtsPollSet ps, int set)
 {
-#if defined(USE_THREADS) || ERTS_POLL_ASYNC_INTERRUPT_SUPPORT
     if (!set)
 	reset_wakeup_state(ps);
     else
 	wake_poller(ps, 1, 0);
-#endif
 }
 
-#if ERTS_POLL_ASYNC_INTERRUPT_SUPPORT
-void
-ERTS_POLL_EXPORT(erts_poll_async_sig_interrupt)(ErtsPollSet ps)
-{
-    /*
-     * NOTE: This function is called from signal handlers, it,
-     *       therefore, it has to be async-signal safe.
-     */
-    wake_poller(ps, 1, 1);
-}
-#endif
 
 /*
  * erts_poll_interrupt_timed():
@@ -2552,7 +2416,6 @@ ERTS_POLL_EXPORT(erts_poll_interrupt_timed)(ErtsPollSet ps,
 					    int set,
 					    ErtsMonotonicTime timeout_time)
 {
-#if ERTS_POLL_ASYNC_INTERRUPT_SUPPORT || defined(ERTS_SMP)
     if (!set)
 	reset_wakeup_state(ps);
     else {
@@ -2568,7 +2431,6 @@ ERTS_POLL_EXPORT(erts_poll_interrupt_timed)(ErtsPollSet ps,
 	erts_smp_atomic_inc_nob(&ps->no_interrupt_timed);
 #endif
     }
-#endif
 }
 
 int
@@ -2682,22 +2544,14 @@ ERTS_POLL_EXPORT(erts_poll_create_pollset)(void)
     ERTS_FD_ZERO(&ps->res_output_fds);
 #endif
 #endif
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
     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);
-#endif
-#ifdef ERTS_SMP
     erts_atomic32_init_nob(&ps->polled, 0);
     erts_smp_mtx_init(&ps->mtx, "pollset", NIL, ERTS_LOCK_FLAGS_CATEGORY_IO);
-#endif
-#if defined(USE_THREADS) || ERTS_POLL_ASYNC_INTERRUPT_SUPPORT
     erts_atomic32_init_nob(&ps->wakeup_state, (erts_aint32_t) 0);
-#endif
-#if ERTS_POLL_USE_WAKEUP_PIPE
     create_wakeup_pipe(ps);
-#endif
 #if ERTS_POLL_USE_TIMERFD
     create_timerfd(ps);
 #endif
@@ -2724,9 +2578,7 @@ ERTS_POLL_EXPORT(erts_poll_create_pollset)(void)
     erts_smp_atomic_init_nob(&ps->no_avoided_interrupts, 0);
     erts_smp_atomic_init_nob(&ps->no_interrupt_timed, 0);
 #endif
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
     handle_update_requests(ps);
-#endif
 #if ERTS_POLL_USE_FALLBACK
     ps->fallback_used = 0;
 #endif
@@ -2772,7 +2624,6 @@ ERTS_POLL_EXPORT(erts_poll_destroy_pollset)(ErtsPollSet ps)
 	erts_free(ERTS_ALC_T_SELECT_FDS, (void *) ps->res_output_fds.ptr);
 #endif
 #endif
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
     {
 	ErtsPollSetUpdateRequestsBlock *urqbp = ps->update_requests.next;
 	while (urqbp) {
@@ -2781,16 +2632,11 @@ ERTS_POLL_EXPORT(erts_poll_destroy_pollset)(ErtsPollSet ps)
 	    free_update_requests_block(ps, free_urqbp);
 	}
     }
-#endif
-#ifdef ERTS_SMP
     erts_smp_mtx_destroy(&ps->mtx);
-#endif
-#if ERTS_POLL_USE_WAKEUP_PIPE
     if (ps->wake_fds[0] >= 0)
 	close(ps->wake_fds[0]);
     if (ps->wake_fds[1] >= 0)
 	close(ps->wake_fds[1]);
-#endif
 #if ERTS_POLL_USE_TIMERFD
     if (ps->timer_fd >= 0)
         close(ps->timer_fd);
@@ -2818,9 +2664,7 @@ ERTS_POLL_EXPORT(erts_poll_destroy_pollset)(ErtsPollSet ps)
 void
 ERTS_POLL_EXPORT(erts_poll_info)(ErtsPollSet ps, ErtsPollInfo *pip)
 {
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
     int pending_updates;
-#endif
     Uint size = 0;
 
     ERTS_POLLSET_LOCK(ps);
@@ -2845,7 +2689,6 @@ ERTS_POLL_EXPORT(erts_poll_info)(ErtsPollSet ps, ErtsPollInfo *pip)
 #endif
 #endif
 
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
     {
 	ErtsPollSetUpdateRequestsBlock *urqbp = ps->update_requests.next;
 	pending_updates = ps->update_requests.len;
@@ -2855,7 +2698,6 @@ ERTS_POLL_EXPORT(erts_poll_info)(ErtsPollSet ps, ErtsPollInfo *pip)
 	    urqbp = urqbp->next;
 	}
     }
-#endif
 
     pip->primary = 
 #if ERTS_POLL_USE_KQUEUE
@@ -2896,9 +2738,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);
-#if ERTS_POLL_USE_WAKEUP_PIPE
     pip->poll_set_size++; /* Wakeup pipe */
-#endif
 #if ERTS_POLL_USE_TIMERFD
     pip->poll_set_size++; /* timerfd */
 #endif
@@ -2922,19 +2762,11 @@ ERTS_POLL_EXPORT(erts_poll_info)(ErtsPollSet ps, ErtsPollInfo *pip)
 #endif
 
     pip->lazy_updates =
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
 	1
-#else
-	0
-#endif
 	;
 
     pip->pending_updates = 
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
 	pending_updates
-#else
-	0
-#endif
 	;
 
     pip->batch_updates = 
@@ -3031,9 +2863,7 @@ ERTS_POLL_EXPORT(erts_poll_get_selected_events)(ErtsPollSet ps,
 	else {
 	    ev[fd] = ps->fds_status[fd].events;
             if (
-#if ERTS_POLL_USE_WAKEUP_PIPE
                 fd == ps->wake_fds[0] || fd == ps->wake_fds[1] ||
-#endif
 #if ERTS_POLL_USE_TIMERFD
                 fd == ps->timer_fd ||
 #endif
@@ -3121,11 +2951,7 @@ print_misc_debug_info(void)
 		"select"
 #endif
 		,
-#if ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE
 		"true"
-#else
-		"false"
-#endif
 		,
 #if ERTS_POLL_USE_BATCH_UPDATE_POLLSET
 		"true"
diff --git a/erts/emulator/sys/common/erl_poll.h b/erts/emulator/sys/common/erl_poll.h
index b3b4d79984..a57dc51e5b 100644
--- a/erts/emulator/sys/common/erl_poll.h
+++ b/erts/emulator/sys/common/erl_poll.h
@@ -227,9 +227,6 @@ typedef struct {
 #endif
 } ErtsPollInfo;
 
-#ifdef ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
-void		ERTS_POLL_EXPORT(erts_poll_async_sig_interrupt)(ErtsPollSet);
-#endif
 void		ERTS_POLL_EXPORT(erts_poll_interrupt)(ErtsPollSet,
 						      int);
 void		ERTS_POLL_EXPORT(erts_poll_interrupt_timed)(ErtsPollSet,
diff --git a/erts/emulator/sys/unix/erl_unix_sys.h b/erts/emulator/sys/unix/erl_unix_sys.h
index 22059d21d5..cbbd0e6f40 100644
--- a/erts/emulator/sys/unix/erl_unix_sys.h
+++ b/erts/emulator/sys/unix/erl_unix_sys.h
@@ -128,10 +128,6 @@
 /* File descriptors are numbers anc consecutively allocated on Unix */
 #define  ERTS_SYS_CONTINOUS_FD_NUMBERS
 
-#ifndef ERTS_SMP
-#  undef ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
-#  define ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
-#endif
 
 typedef void *GETENV_STATE;
 
@@ -354,9 +350,7 @@ extern void erts_sys_unix_later_init(void);
 #ifdef NO_FPE_SIGNALS
 
 #define erts_get_current_fp_exception() NULL
-#ifdef ERTS_SMP
 #define erts_thread_init_fp_exception() do{}while(0)
-#endif
 #  define __ERTS_FP_CHECK_INIT(fpexnp) do {} while (0)
 #  define __ERTS_FP_ERROR(fpexnp, f, Action) if (!isfinite(f)) { Action; } else {}
 #  define __ERTS_FP_ERROR_THOROUGH(fpexnp, f, Action) __ERTS_FP_ERROR(fpexnp, f, Action)
@@ -369,9 +363,7 @@ extern void erts_sys_unix_later_init(void);
 #else /* !NO_FPE_SIGNALS */
 
 extern volatile unsigned long *erts_get_current_fp_exception(void);
-#ifdef ERTS_SMP
 extern void erts_thread_init_fp_exception(void);
-#endif
 #  if (defined(__i386__) || defined(__x86_64__)) && defined(__GNUC__)
 #    define erts_fwait(fpexnp,f) \
 	__asm__ __volatile__("fwait" : "=m"(*(fpexnp)) : "m"(f))
@@ -438,10 +430,8 @@ void erts_sys_unblock_fpe(int);
 
 
 /* Threads */
-#ifdef USE_THREADS
 extern int init_async(int);
 extern int exit_async(void);
-#endif
 
 #define ERTS_EXIT_AFTER_DUMP _exit
 
diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 50d8a35217..83edca1c2f 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -58,9 +58,7 @@
 #define __DARWIN__ 1
 #endif
 
-#ifdef USE_THREADS
 #include "erl_threads.h"
-#endif
 
 #include "erl_mseg.h"
 
@@ -94,19 +92,12 @@ extern void erts_sys_init_float(void);
 static int debug_log = 0;
 #endif
 
-#ifdef ERTS_SMP
 static erts_smp_atomic32_t have_prepared_crash_dump;
 #define ERTS_PREPARED_CRASH_DUMP \
   ((int) erts_smp_atomic32_xchg_nob(&have_prepared_crash_dump, 1))
-#else
-static volatile int have_prepared_crash_dump;
-#define ERTS_PREPARED_CRASH_DUMP \
-  (have_prepared_crash_dump++)
-#endif
 
 erts_smp_atomic_t sys_misc_mem_sz;
 
-#if defined(ERTS_SMP)
 static void smp_sig_notify(int signum);
 static int sig_notify_fds[2] = {-1, -1};
 
@@ -114,7 +105,6 @@ static int sig_notify_fds[2] = {-1, -1};
 static int sig_suspend_fds[2] = {-1, -1};
 #endif
 
-#endif
 
 jmp_buf erts_sys_sigsegv_jmp;
 
@@ -128,38 +118,12 @@ static int max_files = -1;
 /* 
  * a few variables used by the break handler 
  */
-#ifdef ERTS_SMP
 erts_smp_atomic32_t erts_break_requested;
 #define ERTS_SET_BREAK_REQUESTED \
   erts_smp_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)
-#else
-volatile int erts_break_requested = 0;
-#define ERTS_SET_BREAK_REQUESTED (erts_break_requested = 1)
-#define ERTS_UNSET_BREAK_REQUESTED (erts_break_requested = 0)
-#endif
 
-#ifndef ERTS_SMP
-static Eterm signalstate_sigterm[] = {
-    am_sigint,   /* 0 */
-    am_sighup,   /* 1 */
-    am_sigquit,  /* 2 */
-    am_sigabrt,  /* 3 */
-    am_sigalrm,  /* 4 */
-    am_sigterm,  /* 5 */
-    am_sigusr1,  /* 6 */
-    am_sigusr2,  /* 7 */
-    am_sigchld,  /* 8 */
-    am_sigstop,  /* 9 */
-    am_sigtstp   /* 10 */
-};
-
-volatile Uint erts_signal_state = 0;
-#define ERTS_SET_SIGNAL_STATE(S) (erts_signal_state |= signum_to_signalstate(S))
-#define ERTS_CLEAR_SIGNAL_STATE (erts_signal_state = 0)
-static ERTS_INLINE Uint signum_to_signalstate(int signum);
-#endif
 
 /* set early so the break handler has access to initial mode */
 static struct termios initial_tty_mode;
@@ -223,9 +187,6 @@ init_check_io(void)
 	io_func.select			= driver_select_kp;
         io_func.enif_select		= enif_select_kp;
 	io_func.event			= driver_event_kp;
-#ifdef ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
-	io_func.check_io_as_interrupt	= erts_check_io_async_sig_interrupt_kp;
-#endif
 	io_func.check_io_interrupt	= erts_check_io_interrupt_kp;
 	io_func.check_io_interrupt_tmd	= erts_check_io_interrupt_timed_kp;
 	io_func.check_io		= erts_check_io_kp;
@@ -239,9 +200,6 @@ init_check_io(void)
 	io_func.select			= driver_select_nkp;
         io_func.enif_select		= enif_select_nkp;
 	io_func.event			= driver_event_nkp;
-#ifdef ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
-	io_func.check_io_as_interrupt	= erts_check_io_async_sig_interrupt_nkp;
-#endif
 	io_func.check_io_interrupt	= erts_check_io_interrupt_nkp;
 	io_func.check_io_interrupt_tmd	= erts_check_io_interrupt_timed_nkp;
 	io_func.check_io		= erts_check_io_nkp;
@@ -253,11 +211,7 @@ init_check_io(void)
     }
 }
 
-#ifdef ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
-#define ERTS_CHK_IO_AS_INTR()	(*io_func.check_io_as_interrupt)()
-#else
 #define ERTS_CHK_IO_AS_INTR()	(*io_func.check_io_interrupt)(1)
-#endif
 #define ERTS_CHK_IO_INTR	(*io_func.check_io_interrupt)
 #define ERTS_CHK_IO_INTR_TMD	(*io_func.check_io_interrupt_tmd)
 #define ERTS_CHK_IO		(*io_func.check_io)
@@ -272,11 +226,7 @@ init_check_io(void)
     max_files = erts_check_io_max_files();
 }
 
-#ifdef ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
-#define ERTS_CHK_IO_AS_INTR()	erts_check_io_async_sig_interrupt()
-#else
 #define ERTS_CHK_IO_AS_INTR()	erts_check_io_interrupt(1)
-#endif
 #define ERTS_CHK_IO_INTR	erts_check_io_interrupt
 #define ERTS_CHK_IO_INTR_TMD	erts_check_io_interrupt_timed
 #define ERTS_CHK_IO		erts_check_io
@@ -290,13 +240,11 @@ erts_sys_schedule_interrupt(int set)
     ERTS_CHK_IO_INTR(set);
 }
 
-#ifdef ERTS_SMP
 void
 erts_sys_schedule_interrupt_timed(int set, ErtsMonotonicTime timeout_time)
 {
     ERTS_CHK_IO_INTR_TMD(set, timeout_time);
 }
-#endif
 
 UWord
 erts_sys_get_page_size(void)
@@ -339,7 +287,6 @@ MALLOC_USE_HASH(1);
 #endif
 #endif
 
-#ifdef USE_THREADS
 
 #ifdef ERTS_THR_HAVE_SIG_FUNCS
 
@@ -418,19 +365,15 @@ thr_create_prepare_child(void *vtcdp)
     erts_sched_bind_atthrcreate_child(tcdp->sched_bind_data);
 }
 
-#endif /* #ifdef USE_THREADS */
 
 void
 erts_sys_pre_init(void)
 {
-#ifdef USE_THREADS
     erts_thr_init_data_t eid = ERTS_THR_INIT_DATA_DEF_INITER;
-#endif
 
     erts_printf_add_cr_to_stdout = 1;
     erts_printf_add_cr_to_stderr = 1;
 
-#ifdef USE_THREADS
 
     eid.thread_create_child_func = thr_create_prepare_child;
     /* Before creation in parent */
@@ -452,21 +395,13 @@ erts_sys_pre_init(void)
     erts_lc_init();
 #endif
 
-#endif /* USE_THREADS */
 
     erts_init_sys_time_sup();
 
-#ifdef USE_THREADS
 
-#ifdef ERTS_SMP
     erts_smp_atomic32_init_nob(&erts_break_requested, 0);
     erts_smp_atomic32_init_nob(&have_prepared_crash_dump, 0);
-#else
-    erts_break_requested = 0;
-    have_prepared_crash_dump = 0;
-#endif
 
-#endif /* USE_THREADS */
 
     erts_smp_atomic_init_nob(&sys_misc_mem_sz, 0);
 
@@ -531,10 +466,8 @@ SIGFUNC sys_signal(int sig, SIGFUNC func)
     return(oact.sa_handler);
 }
 
-#ifdef USE_THREADS
 #undef  sigprocmask
 #define sigprocmask erts_thr_sigmask
-#endif
 
 void sys_sigblock(int sig)
 {
@@ -697,11 +630,7 @@ break_requested(void)
 
 static RETSIGTYPE request_break(int signum)
 {
-#ifdef ERTS_SMP
     smp_sig_notify(signum);
-#else
-    break_requested();
-#endif
 }
 
 #ifdef ETHR_UNUSABLE_SIGUSRX
@@ -810,35 +739,10 @@ signum_to_signalterm(int signum)
     }
 }
 
-#ifndef ERTS_SMP
-static ERTS_INLINE Uint
-signum_to_signalstate(int signum)
-{
-    switch (signum) {
-    case SIGINT:  return (1 <<  0);
-    case SIGHUP:  return (1 <<  1);
-    case SIGQUIT: return (1 <<  2);
-    case SIGABRT: return (1 <<  3);
-    case SIGALRM: return (1 <<  4);
-    case SIGTERM: return (1 <<  5);
-    case SIGUSR1: return (1 <<  6);
-    case SIGUSR2: return (1 <<  7);
-    case SIGCHLD: return (1 <<  8);
-    case SIGSTOP: return (1 <<  9);
-    case SIGTSTP: return (1 << 10);
-    default:      return 0;
-    }
-}
-#endif
 
 static RETSIGTYPE generic_signal_handler(int signum)
 {
-#ifdef ERTS_SMP
     smp_sig_notify(signum);
-#else
-    ERTS_SET_SIGNAL_STATE(signum);
-    ERTS_CHK_IO_AS_INTR(); /* Make sure we don't sleep in poll */
-#endif
 }
 
 int erts_set_signal(Eterm signal, Eterm type) {
@@ -1032,22 +936,6 @@ void erts_do_break_handling(void)
     erts_smp_thr_progress_unblock();
 }
 
-#ifdef ERTS_SIGNAL_STATE
-void erts_handle_signal_state(void) {
-    Uint signal_state = ERTS_SIGNAL_STATE;
-    Uint i = 0;
-
-    ERTS_CLEAR_SIGNAL_STATE;
-
-    while (signal_state) {
-        if (signal_state & 0x1) {
-            signal_notify_requested(signalstate_sigterm[i]);
-        }
-        i++;
-        signal_state = signal_state >> 1;
-    }
-}
-#endif
 
 /* Fills in the systems representation of the jam/beam process identifier.
 ** The Pid is put in STRING representation in the supplied buffer,
@@ -1282,16 +1170,6 @@ erl_assert_error(const char* expr, const char* func, const char* file, int line)
     fprintf(stderr, "%s:%d:%s() Assertion failed: %s\n",
             file, line, func, expr);
     fflush(stderr);
-#if !defined(ERTS_SMP) && 0
-    /* Writing a crashdump from a failed assertion when smp support
-     * is enabled almost a guaranteed deadlocking, don't even bother.
-     *
-     * It could maybe be useful (but I'm not convinced) to write the
-     * crashdump if smp support is disabled...
-     */
-    if (erts_initialized)
-	erl_crash_dump(file, line, "Assertion failed: %s\n", expr);
-#endif
     abort();
 }
 
@@ -1326,7 +1204,6 @@ erl_sys_schedule(int runnable)
 }
 
 
-#ifdef ERTS_SMP
 
 static erts_smp_tid_t sig_dispatcher_tid;
 
@@ -1515,7 +1392,6 @@ erts_sys_main_thread(void)
     }
 }
 
-#endif /* ERTS_SMP */
 
 #ifdef ERTS_ENABLE_KERNEL_POLL /* get_value() is currently only used when
 				  kernel-poll is enabled */
@@ -1602,10 +1478,8 @@ erl_sys_args(int* argc, char** argv)
 
     init_check_io();
 
-#ifdef ERTS_SMP
     init_smp_sig_notify();
     init_smp_sig_suspend();
-#endif
 
     /* Handled arguments have been marked with NULL. Slide arguments
        not handled towards the beginning of argv. */
diff --git a/erts/emulator/sys/unix/sys_drivers.c b/erts/emulator/sys/unix/sys_drivers.c
index 834706d86f..03d948c6e9 100644
--- a/erts/emulator/sys/unix/sys_drivers.c
+++ b/erts/emulator/sys/unix/sys_drivers.c
@@ -53,9 +53,7 @@
 #define WANT_NONBLOCKING    /* must define this to pull in defs from sys.h */
 #include "sys.h"
 
-#ifdef USE_THREADS
 #include "erl_threads.h"
-#endif
 
 extern char **environ;
 extern erts_smp_rwmtx_t environ_rwmtx;
@@ -86,11 +84,7 @@ static Eterm forker_port;
 #define MAXIOV 16
 #endif
 
-#ifdef USE_THREADS
 #  define FDBLOCK 1
-#else
-#  define FDBLOCK 0
-#endif
 
 /* Used by the fd driver iff the fd could not be set to non-blocking */
 typedef struct ErtsSysBlocking_ {
@@ -178,9 +172,7 @@ void
 erl_sys_late_init(void)
 {
     SysDriverOpts opts;
-#ifdef ERTS_SMP
     Port *port;
-#endif
 
     sys_signal(SIGPIPE, SIG_IGN); /* Ignore - we'll handle the write failure */
 
@@ -197,13 +189,9 @@ erl_sys_late_init(void)
     opts.argv = NULL;
     opts.parallelism = erts_port_parallelism;
 
-#ifdef ERTS_SMP
     port =
-#endif
         erts_open_driver(&forker_driver, make_internal_pid(0), "forker", &opts, NULL, NULL);
-#ifdef ERTS_SMP
     erts_mtx_unlock(port->lock);
-#endif
     erts_sys_unix_later_init(); /* Need to be called after forker has been started */
 }
 
@@ -220,10 +208,8 @@ static ErlDrvData vanilla_start(ErlDrvPort, char*, SysDriverOpts*);
 
 /* II.III FD prototypes */
 static ErlDrvData fd_start(ErlDrvPort, char*, SysDriverOpts*);
-#if FDBLOCK
 static void fd_async(void *);
 static void fd_ready_async(ErlDrvData drv_data, ErlDrvThreadData thread_data);
-#endif
 static ErlDrvSSizeT fd_control(ErlDrvData, unsigned int, char *, ErlDrvSizeT,
 			       char **, ErlDrvSizeT);
 static void fd_stop(ErlDrvData);
@@ -287,11 +273,7 @@ struct erl_drv_entry fd_driver_entry = {
     fd_control,
     NULL,
     outputv,
-#if FDBLOCK
     fd_ready_async, /* ready_async */
-#else
-    NULL,
-#endif
     fd_flush, /* flush */
     NULL, /* call */
     NULL, /* event */
@@ -1092,13 +1074,11 @@ static void fd_stop(ErlDrvData ev)  /* Does not close the fds */
     ErlDrvPort prt = dd->port_num;
     int sz = sizeof(ErtsSysDriverData);
 
-#if FDBLOCK
     if (dd->blocking) {
         erts_free(ERTS_ALC_T_SYS_BLOCKING, dd->blocking);
         dd->blocking = NULL;
         sz += sizeof(ErtsSysBlocking);
     }
-#endif
 
     if (dd->ifd) {
         sz += sizeof(ErtsSysFdData);
@@ -1220,7 +1200,6 @@ static void outputv(ErlDrvData e, ErlIOVec* ev)
 	driver_enqv(ix, ev, n);  /* n is the skip value */
 	driver_select(ix, ofd, ERL_DRV_WRITE|ERL_DRV_USE, 1);
     }
-#if FDBLOCK
     else {
         if (ev->size != 0) {
             driver_enqv(ix, ev, 0);
@@ -1231,7 +1210,6 @@ static void outputv(ErlDrvData e, ErlIOVec* ev)
             driver_pdl_unlock(dd->blocking->pdl);
         }
     }
-#endif
     /* return 0;*/
 }
 
@@ -1579,7 +1557,6 @@ static void stop_select(ErlDrvEvent fd, void* _)
     close((int)fd);
 }
 
-#if FDBLOCK
 
 static void
 fd_async(void *async_data)
@@ -1658,7 +1635,6 @@ void fd_ready_async(ErlDrvData drv_data,
     return; /* 0; */
 }
 
-#endif
 
 /* Forker driver */
 
diff --git a/erts/emulator/sys/unix/sys_float.c b/erts/emulator/sys/unix/sys_float.c
index 6435da086f..a82c15bd32 100644
--- a/erts/emulator/sys/unix/sys_float.c
+++ b/erts/emulator/sys/unix/sys_float.c
@@ -39,7 +39,6 @@ erts_sys_init_float(void)
 
 #else  /* !NO_FPE_SIGNALS */
 
-#ifdef ERTS_SMP
 static erts_tsd_key_t fpe_key;
 
 /* once-only initialisation early in the main thread (via erts_sys_init_float()) */
@@ -61,11 +60,6 @@ static ERTS_INLINE volatile unsigned long *erts_thread_get_fp_exception(void)
 {
     return (volatile unsigned long*)erts_tsd_get(fpe_key);
 }
-#else /* !SMP */
-#define erts_init_fp_exception()	/*empty*/
-static volatile unsigned long fp_exception;
-#define erts_thread_get_fp_exception()	(&fp_exception)
-#endif /* SMP */
 
 volatile unsigned long *erts_get_current_fp_exception(void)
 {
@@ -659,11 +653,9 @@ void erts_sys_init_float(void)
 
 void erts_thread_init_float(void)
 {
-#ifdef ERTS_SMP
     /* This allows Erlang schedulers to leave Erlang-process context
        and still have working FP exceptions. XXX: is this needed? */
     erts_thread_init_fp_exception();
-#endif
 
 #ifndef NO_FPE_SIGNALS
     /* NOTE:
diff --git a/erts/emulator/sys/win32/erl_poll.c b/erts/emulator/sys/win32/erl_poll.c
index 8743f83a50..41ff186c44 100644
--- a/erts/emulator/sys/win32/erl_poll.c
+++ b/erts/emulator/sys/win32/erl_poll.c
@@ -286,41 +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;
-#ifdef ERTS_SMP
     erts_smp_mtx_t mtx;
-#endif
     erts_atomic64_t timeout_time;
 };
 
-#ifdef ERTS_SMP
 
 #define ERTS_POLLSET_LOCK(PS) \
   erts_smp_mtx_lock(&(PS)->mtx)
 #define ERTS_POLLSET_UNLOCK(PS) \
   erts_smp_mtx_unlock(&(PS)->mtx)
 
-#else
-
-#define ERTS_POLLSET_LOCK(PS)
-#define ERTS_POLLSET_UNLOCK(PS)
-
-#endif
 
 /*
  * Communication with sys_interrupt
  */
 
-#ifdef ERTS_SMP
 extern erts_smp_atomic32_t erts_break_requested;
 #define ERTS_SET_BREAK_REQUESTED \
   erts_smp_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)
-#else
-extern volatile int erts_break_requested;
-#define ERTS_SET_BREAK_REQUESTED (erts_break_requested = 1)
-#define ERTS_UNSET_BREAK_REQUESTED (erts_break_requested = 0)
-#endif
 
 static erts_mtx_t break_waiter_lock;
 static HANDLE break_happened_event;
@@ -1193,14 +1178,10 @@ int erts_poll_wait(ErtsPollSet ps,
 
 	HARDDEBUGF(("Start waiting %d [%d]",num_h, (int) timeout));
 	ERTS_POLLSET_UNLOCK(ps);
-#ifdef ERTS_SMP
 	erts_thr_progress_prepare_wait(NULL);
-#endif
         ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_SLEEP);
 	WaitForMultipleObjects(num_h, harr, FALSE, timeout);
-#ifdef ERTS_SMP
 	erts_thr_progress_finalize_wait(NULL);
-#endif
         ERTS_MSACC_POP_STATE_M();
 	ERTS_POLLSET_LOCK(ps);
 	HARDDEBUGF(("Stop waiting %d [%d]",num_h, (int) timeout));
@@ -1359,9 +1340,7 @@ ErtsPollSet erts_poll_create_pollset(void)
     ps->restore_events = 0;
 
     erts_atomic32_init_nob(&ps->wakeup_state, ERTS_POLL_NOT_WOKEN);
-#ifdef ERTS_SMP
     erts_smp_mtx_init(&ps->mtx, "pollset", NIL, ERTS_LOCK_FLAGS_CATEGORY_IO);
-#endif
     init_timeout_time(ps);
 
     HARDTRACEF(("Out erts_poll_create_pollset"));
@@ -1391,9 +1370,7 @@ void erts_poll_destroy_pollset(ErtsPollSet ps)
     CloseHandle(ps->event_io_ready);
     CloseHandle(ps->standby_wait_event);
     ERTS_POLLSET_UNLOCK(ps);
-#ifdef ERTS_SMP
     erts_smp_mtx_destroy(&ps->mtx);
-#endif
     SEL_FREE(ERTS_ALC_T_POLLSET, (void *) ps);
     HARDTRACEF(("Out erts_poll_destroy_pollset"));
 }
diff --git a/erts/emulator/sys/win32/erl_win_sys.h b/erts/emulator/sys/win32/erl_win_sys.h
index 78005aada9..1f53452d17 100644
--- a/erts/emulator/sys/win32/erl_win_sys.h
+++ b/erts/emulator/sys/win32/erl_win_sys.h
@@ -311,10 +311,8 @@ typedef long ssize_t;
 #endif
 
 /* Threads */
-#ifdef USE_THREADS
 int init_async(int);
 int exit_async(void);
-#endif
 
 #define ERTS_HAVE_TRY_CATCH 1
 
diff --git a/erts/emulator/sys/win32/sys.c b/erts/emulator/sys/win32/sys.c
index 15c59109b1..7fddc9fa99 100644
--- a/erts/emulator/sys/win32/sys.c
+++ b/erts/emulator/sys/win32/sys.c
@@ -80,9 +80,7 @@ static int application_type(const wchar_t* originalName, wchar_t fullPath[MAX_PA
 
 HANDLE erts_service_event;
 
-#ifdef ERTS_SMP
 static erts_smp_tsd_key_t win32_errstr_key;
-#endif
 
 static erts_smp_atomic_t pipe_creation_counter;
 
@@ -94,10 +92,8 @@ static erts_smp_atomic_t pipe_creation_counter;
 
 static int driver_write(long, HANDLE, byte*, int);
 static int create_file_thread(struct async_io* aio, int mode);
-#ifdef ERTS_SMP
 static void close_active_handle(DriverData *, HANDLE handle);
 static DWORD WINAPI threaded_handle_closer(LPVOID param);
-#endif
 static DWORD WINAPI threaded_reader(LPVOID param);
 static DWORD WINAPI threaded_writer(LPVOID param);
 static DWORD WINAPI threaded_exiter(LPVOID param);
@@ -450,9 +446,7 @@ typedef struct async_io {
 				 * the console for Windows NT).
 				 */
   HANDLE fd;			/* Handle for file or pipe. */
-#ifdef ERTS_SMP
   int async_io_active;          /* if true, a close of the file will signal the event in ov */
-#endif
   OVERLAPPED ov;		/* Control structure for overlapped reading.
 				 * When overlapped reading is simulated with
 				 * a thread, the fields are used as follows:
@@ -691,7 +685,6 @@ buf_alloc_error:
 static void
 release_driver_data(DriverData* dp)
 {
-#ifdef ERTS_SMP
 #ifdef USE_CANCELIOEX
     if (fpCancelIoEx != NULL) {
 	if (dp->in.thread == (HANDLE) -1 && dp->in.fd != INVALID_HANDLE_VALUE) {
@@ -734,14 +727,6 @@ release_driver_data(DriverData* dp)
 	    DEBUGF(("...done\n"));
 	}
     }
-#else
-	if (dp->in.thread == (HANDLE) -1 && dp->in.fd != INVALID_HANDLE_VALUE) {
-	     CancelIo(dp->in.fd); 
-	}
-	if (dp->out.thread == (HANDLE) -1 && dp->out.fd != INVALID_HANDLE_VALUE) {
-	    CancelIo(dp->out.fd); 
-	}
-#endif
 
     if (dp->inbuf != NULL) {
 	ASSERT(erts_smp_atomic_read_nob(&sys_misc_mem_sz) >= dp->inBufSize);
@@ -777,7 +762,6 @@ release_driver_data(DriverData* dp)
     unrefer_driver_data(dp);
 }
 
-#ifdef ERTS_SMP
 
 struct handles_to_be_closed {
     HANDLE handles[MAXIMUM_WAIT_OBJECTS];
@@ -870,7 +854,6 @@ threaded_handle_closer(LPVOID param)
     DEBUGF(("threaded_handle_closer %p terminating\r\n", htbc));
     return 0;
 }
-#endif /* ERTS_SMP */
 
 /*
  * Stores input and output file descriptors in the DriverData structure,
@@ -946,9 +929,7 @@ init_async_io(DriverData *dp, AsyncIo* aio, int use_threads)
     aio->flushReplyEvent = NULL;
     aio->pendingError = 0;
     aio->bytesTransferred = 0;
-#ifdef ERTS_SMP
     aio->async_io_active = 0;
-#endif
     aio->ov.hEvent = CreateManualEvent(FALSE);
     if (aio->ov.hEvent == NULL)
 	return -1;
@@ -1029,9 +1010,7 @@ async_read_file(AsyncIo* aio, LPVOID buf, DWORD numToRead)
 	ResetEvent(aio->ov.hEvent);
 	SetEvent(aio->ioAllowed);
     } else {
-#ifdef ERTS_SMP
 	aio->async_io_active = 1; /* Will get 0 when the event actually happened */
-#endif
 	if (ReadFile(aio->fd, buf, numToRead,
 		     &aio->bytesTransferred, &aio->ov)) {
 	    DEBUGF(("async_read_file: ReadFile() suceeded: %d bytes\n",
@@ -1079,16 +1058,12 @@ async_write_file(AsyncIo* aio,		/* Pointer to async control block. */
 	ResetEvent(aio->ov.hEvent);
 	SetEvent(aio->ioAllowed);
     } else {
-#ifdef ERTS_SMP
 	aio->async_io_active = 1; /* Will get 0 when the event actually happened */
-#endif
 	if (WriteFile(aio->fd, buf, numToWrite,
 		      &aio->bytesTransferred, &aio->ov)) {
 	    DEBUGF(("async_write_file: WriteFile() suceeded: %d bytes\n",
 		    aio->bytesTransferred));
-#ifdef ERTS_SMP
 	    aio->async_io_active = 0; /* The event will not be signalled */
-#endif
 	    ResetEvent(aio->ov.hEvent);
 	    return TRUE;
 	} else {
@@ -2511,11 +2486,9 @@ ready_input(ErlDrvData drv_data, ErlDrvEvent ready_event)
     int pb;
 
     pb = dp->packet_bytes;
-#ifdef ERTS_SMP
     if(dp->in.thread == (HANDLE) -1) {
 	dp->in.async_io_active = 0;
     }
-#endif
     DEBUGF(("ready_input: dp %p, event 0x%x\n", dp, ready_event));
 
     /*
@@ -2680,11 +2653,9 @@ ready_output(ErlDrvData drv_data, ErlDrvEvent ready_event)
     DriverData *dp = (DriverData *) drv_data;
     int error;
 
-#ifdef ERTS_SMP
     if(dp->out.thread == (HANDLE) -1) {
 	dp->out.async_io_active = 0;
     }
-#endif
     DEBUGF(("ready_output(%p, 0x%x)\n", drv_data, ready_event));
     set_busy_port(dp->port_num, 0);
     if (!(dp->outbuf)) {
@@ -2743,7 +2714,6 @@ sys_init_io(void)
     max_files = 2*erts_ptab_max(&erts_port);
 }
 
-#ifdef ERTS_SMP
 void
 erts_sys_main_thread(void)
 {
@@ -2756,7 +2726,6 @@ erts_sys_main_thread(void)
 	WaitForSingleObject(dummy, INFINITE);
     }
 }
-#endif
 
 void erts_sys_alloc_init(void)
 {
@@ -2938,11 +2907,7 @@ sys_get_key(int fd)
 
 char* win32_errorstr(int error)
 {
-#ifdef SMP
   LPTSTR lpBufPtr = erts_smp_tsd_get(win32_errstr_key);
-#else
-  static LPTSTR lpBufPtr = NULL;
-#endif
   if (lpBufPtr) {
       LocalFree(lpBufPtr);
   }
@@ -2956,9 +2921,7 @@ char* win32_errorstr(int error)
 		0,
 		NULL);
   SetLastError(error);
-#ifdef ERTS_SMP
   erts_smp_tsd_set(win32_errstr_key,lpBufPtr);
-#endif
   return lpBufPtr;
 }
 
@@ -3131,7 +3094,6 @@ check_supported_os_version(void)
 #endif
 }
 
-#ifdef USE_THREADS
 
 typedef struct {
     int sched_bind_data;
@@ -3176,19 +3138,15 @@ thr_create_prepare_child(void *vtcdp)
     erts_sched_bind_atthrcreate_child(tcdp->sched_bind_data);
 }
 
-#endif /* USE_THREADS */
 
 void
 erts_sys_pre_init(void)
 {
-#ifdef USE_THREADS
     erts_thr_init_data_t eid = ERTS_THR_INIT_DATA_DEF_INITER;
-#endif
     int_os_version.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
     GetVersionEx(&int_os_version);
     check_supported_os_version();
 
-#ifdef USE_THREADS
     eid.thread_create_child_func = thr_create_prepare_child;
     /* Before creation in parent */
     eid.thread_create_prepare_func = thr_create_prepare;
@@ -3209,7 +3167,6 @@ erts_sys_pre_init(void)
     erts_lc_init();
 #endif
 
-#endif /* USE_THREADS */
 
     erts_init_sys_time_sup();
 
@@ -3233,10 +3190,8 @@ void erl_sys_init(void)
     noinherit_std_handle(STD_INPUT_HANDLE);
     noinherit_std_handle(STD_ERROR_HANDLE);
 
-#ifdef ERTS_SMP
     erts_smp_tsd_key_create(&win32_errstr_key,"win32_errstr_key");
     InitializeCriticalSection(&htbc_lock);
-#endif
     erts_smp_atomic_init_nob(&pipe_creation_counter,0);
     /*
      * Test if we have named pipes or not.
@@ -3299,13 +3254,11 @@ erts_sys_schedule_interrupt(int set)
     erts_check_io_interrupt(set);
 }
 
-#ifdef ERTS_SMP
 void
 erts_sys_schedule_interrupt_timed(int set, ErtsMonotonicTime timeout_time)
 {
     erts_check_io_interrupt_timed(set, timeout_time);
 }
-#endif
 
 /*
  * Called from schedule() when it runs out of runnable processes,
diff --git a/erts/emulator/sys/win32/sys_interrupt.c b/erts/emulator/sys/win32/sys_interrupt.c
index df838960eb..4632ab52b1 100644
--- a/erts/emulator/sys/win32/sys_interrupt.c
+++ b/erts/emulator/sys/win32/sys_interrupt.c
@@ -35,17 +35,11 @@
 #  define WIN_SYS_INLINE __forceinline
 #endif
 
-#ifdef ERTS_SMP
 erts_smp_atomic32_t erts_break_requested;
 #define ERTS_SET_BREAK_REQUESTED \
   erts_smp_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)
-#else
-volatile int erts_break_requested = 0;
-#define ERTS_SET_BREAK_REQUESTED (erts_break_requested = 1)
-#define ERTS_UNSET_BREAK_REQUESTED (erts_break_requested = 0)
-#endif
 
 extern int nohup;
 HANDLE erts_sys_break_event = NULL;