Merge branch 'egil/timer-wheel-min-time/OTP-8990' into dev

* egil/timer-wheel-min-time/OTP-8990:
  Teach timer-wheel slots to use double linked lists
  Remove timer-thread implementation
  Refactor timer interface
  Teach timer-wheel to keep min time

15 files changed, 195 insertions, 559 deletions

diff --git a/erts/emulator/beam/break.c b/erts/emulator/beam/break.c
index fd2ec91e65..d255cf3558 100644
--- a/erts/emulator/beam/break.c
+++ b/erts/emulator/beam/break.c
@@ -558,7 +558,7 @@ do_break(void)
 #endif
 #ifdef DEBUG
 	case 't':
-	    p_slpq();
+	    erts_p_slpq();
 	    return;
 	case 'b':
 	    bin_check();
diff --git a/erts/emulator/beam/erl_bif_timer.c b/erts/emulator/beam/erl_bif_timer.c
index 4ae2f6ebf4..3508e8e0dc 100644
--- a/erts/emulator/beam/erl_bif_timer.c
+++ b/erts/emulator/beam/erl_bif_timer.c
@@ -478,7 +478,7 @@ setup_bif_timer(Uint32 xflags,
     tab_insert(btm);
     ASSERT(btm == tab_find(ref));
     btm->tm.active = 0; /* MUST be initalized */
-    erl_set_timer(&btm->tm,
+    erts_set_timer(&btm->tm,
 		  (ErlTimeoutProc) bif_timer_timeout,
 		  (ErlCancelProc) bif_timer_cleanup,
 		  (void *) btm,
@@ -550,7 +550,7 @@ BIF_RETTYPE cancel_timer_1(BIF_ALIST_1)
 	res = am_false;
     }
     else {
-	Uint left = time_left(&btm->tm);
+	Uint left = erts_time_left(&btm->tm);
 	if (!(btm->flags & BTM_FLG_BYNAME)) {
 	    erts_smp_proc_lock(btm->receiver.proc.ess, ERTS_PROC_LOCK_MSGQ);
 	    unlink_proc(btm);
@@ -558,7 +558,7 @@ BIF_RETTYPE cancel_timer_1(BIF_ALIST_1)
 	}
 	tab_remove(btm);
 	ASSERT(!tab_find(BIF_ARG_1));
-	erl_cancel_timer(&btm->tm);
+	erts_cancel_timer(&btm->tm);
 	erts_smp_btm_rwunlock();
 	res = erts_make_integer(left, BIF_P);
     }
@@ -587,7 +587,7 @@ BIF_RETTYPE read_timer_1(BIF_ALIST_1)
 	res = am_false;
     }
     else {
-	Uint left = time_left(&btm->tm);
+	Uint left = erts_time_left(&btm->tm);
 	res = erts_make_integer(left, BIF_P);
     }
 
@@ -613,7 +613,7 @@ erts_print_bif_timer_info(int to, void *to_arg)
 			      : btm->receiver.proc.ess->id);
 	    erts_print(to, to_arg, "=timer:%T\n", receiver);
 	    erts_print(to, to_arg, "Message: %T\n", btm->message);
-	    erts_print(to, to_arg, "Time left: %d ms\n", time_left(&btm->tm));
+	    erts_print(to, to_arg, "Time left: %d ms\n", erts_time_left(&btm->tm));
 	}
     }
 
@@ -640,7 +640,7 @@ erts_cancel_bif_timers(Process *p, ErtsProcLocks plocks)
 	tab_remove(btm);
 	tmp_btm = btm;
 	btm = btm->receiver.proc.next;
-	erl_cancel_timer(&tmp_btm->tm);
+	erts_cancel_timer(&tmp_btm->tm);
     }
 
     p->bif_timers = NULL;
diff --git a/erts/emulator/beam/erl_init.c b/erts/emulator/beam/erl_init.c
index f4e0717d30..0a57eb6d88 100644
--- a/erts/emulator/beam/erl_init.c
+++ b/erts/emulator/beam/erl_init.c
@@ -250,7 +250,7 @@ erl_init(int ncpu)
 
     erts_init_monitors();
     erts_init_gc();
-    init_time();
+    erts_init_time();
     erts_init_sys_common_misc();
     erts_init_process(ncpu);
     erts_init_scheduling(use_multi_run_queue,
@@ -289,7 +289,7 @@ erl_init(int ncpu)
     erts_delay_trap = erts_export_put(am_erlang, am_delay_trap, 2);
     erts_late_init_process();
 #if HAVE_ERTS_MSEG
-    erts_mseg_late_init(); /* Must be after timer (init_time()) and thread
+    erts_mseg_late_init(); /* Must be after timer (erts_init_time()) and thread
 			      initializations */
 #endif
 #ifdef HIPE
diff --git a/erts/emulator/beam/erl_process.c b/erts/emulator/beam/erl_process.c
index 09062ff2e8..ddfc27a93f 100644
--- a/erts/emulator/beam/erl_process.c
+++ b/erts/emulator/beam/erl_process.c
@@ -1119,8 +1119,8 @@ scheduler_wait(int *fcalls, ErtsSchedulerData *esdp, ErtsRunQueue *rq)
 
 	    erl_sys_schedule(1); /* Might give us something to do */
 
-	    dt = do_time_read_and_reset();
-	    if (dt) bump_timer(dt);
+	    dt = erts_do_time_read_and_reset();
+	    if (dt) erts_bump_timer(dt);
 
 	sys_aux_work:
 
@@ -1216,8 +1216,8 @@ scheduler_wait(int *fcalls, ErtsSchedulerData *esdp, ErtsRunQueue *rq)
 
 	    erl_sys_schedule(0);
 
-	    dt = do_time_read_and_reset();
-	    if (dt) bump_timer(dt);
+	    dt = erts_do_time_read_and_reset();
+	    if (dt) erts_bump_timer(dt);
 
 	    flgs = sched_prep_cont_spin_wait(ssi);
 	    if (flgs & ERTS_SSI_FLG_WAITING)
@@ -5207,10 +5207,10 @@ Process *schedule(Process *p, int calls)
 
 	ERTS_SMP_CHK_NO_PROC_LOCKS;
 
-	dt = do_time_read_and_reset();
+	dt = erts_do_time_read_and_reset();
 	if (dt) {
 	    erts_smp_runq_unlock(rq);
-	    bump_timer(dt);
+	    erts_bump_timer(dt);
 	    erts_smp_runq_lock(rq);
 	}
 	BM_STOP_TIMER(system);
@@ -5351,8 +5351,8 @@ Process *schedule(Process *p, int calls)
 #endif
 	    erts_smp_runq_unlock(rq);
 	    erl_sys_schedule(runnable);
-	    dt = do_time_read_and_reset();
-	    if (dt) bump_timer(dt);
+	    dt = erts_do_time_read_and_reset();
+	    if (dt) erts_bump_timer(dt);
 #ifdef ERTS_SMP
 	    erts_smp_runq_lock(rq);
 	    erts_smp_atomic32_set(&doing_sys_schedule, 0);
@@ -7613,7 +7613,7 @@ cancel_timer(Process* p)
 #ifdef ERTS_SMP
     erts_cancel_smp_ptimer(p->u.ptimer);
 #else
-    erl_cancel_timer(&p->u.tm);
+    erts_cancel_timer(&p->u.tm);
 #endif
 }
 
@@ -7639,7 +7639,7 @@ set_timer(Process* p, Uint timeout)
 			   (ErlTimeoutProc) timeout_proc,
 			   timeout);
 #else
-    erl_set_timer(&p->u.tm,
+    erts_set_timer(&p->u.tm,
 		  (ErlTimeoutProc) timeout_proc,
 		  NULL,
 		  (void*) p,
diff --git a/erts/emulator/beam/erl_time.h b/erts/emulator/beam/erl_time.h
index 6f6b971d34..93d8ea4cb4 100644
--- a/erts/emulator/beam/erl_time.h
+++ b/erts/emulator/beam/erl_time.h
@@ -20,11 +20,15 @@
 #ifndef ERL_TIME_H__
 #define ERL_TIME_H__
 
+extern erts_smp_atomic_t do_time;	/* set at clock interrupt */
+extern SysTimeval erts_first_emu_time;
+
 /*
 ** Timer entry:
 */
 typedef struct erl_timer {
     struct erl_timer* next;	/* next entry tiw slot or chain */
+    struct erl_timer* prev;	/* prev entry tiw slot or chain */
     Uint slot;			/* slot in timer wheel */
     Uint count;			/* number of loops remaining */
     int    active;		/* 1=activated, 0=deactivated */
@@ -39,7 +43,6 @@ typedef void (*ErlTimeoutProc)(void*);
 typedef void (*ErlCancelProc)(void*);
 
 #ifdef ERTS_SMP
-
 /*
  * Process and port timer
  */
@@ -61,7 +64,66 @@ void erts_create_smp_ptimer(ErtsSmpPTimer **timer_ref,
 			    ErlTimeoutProc timeout_func,
 			    Uint timeout);
 void erts_cancel_smp_ptimer(ErtsSmpPTimer *ptimer);
+#endif
+
+/* timer-wheel api */
 
+void erts_init_time(void);
+void erts_set_timer(ErlTimer*, ErlTimeoutProc, ErlCancelProc, void*, Uint);
+void erts_cancel_timer(ErlTimer*);
+void erts_bump_timer(erts_aint_t);
+Uint erts_timer_wheel_memory_size(void);
+Uint erts_time_left(ErlTimer *);
+erts_aint_t erts_next_time(void);
+
+#ifdef DEBUG
+void erts_p_slpq(void);
 #endif
 
+ERTS_GLB_INLINE erts_aint_t erts_do_time_read_and_reset(void);
+ERTS_GLB_INLINE void erts_do_time_add(long);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+ERTS_GLB_INLINE erts_aint_t erts_do_time_read_and_reset(void) { return erts_smp_atomic_xchg(&do_time, 0L); }
+ERTS_GLB_INLINE void erts_do_time_add(long elapsed) { erts_smp_atomic_add(&do_time, elapsed); }
+
+#endif /* #if ERTS_GLB_INLINE_INCL_FUNC_DEF */
+
+
+/* time_sup */
+
+#if (defined(HAVE_GETHRVTIME) || defined(HAVE_CLOCK_GETTIME))
+#  ifndef HAVE_ERTS_NOW_CPU
+#    define HAVE_ERTS_NOW_CPU
+#    ifdef HAVE_GETHRVTIME
+#      define erts_start_now_cpu() sys_start_hrvtime()
+#      define erts_stop_now_cpu()  sys_stop_hrvtime()
+#    endif
+#  endif
+void erts_get_now_cpu(Uint* megasec, Uint* sec, Uint* microsec);
 #endif
+
+void erts_get_timeval(SysTimeval *tv);
+long erts_get_time(void);
+void erts_get_emu_time(SysTimeval *);
+
+ERTS_GLB_INLINE int erts_cmp_timeval(SysTimeval *t1p, SysTimeval *t2p);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+ERTS_GLB_INLINE int
+erts_cmp_timeval(SysTimeval *t1p, SysTimeval *t2p)
+{
+    if (t1p->tv_sec == t2p->tv_sec) {
+	if (t1p->tv_usec < t2p->tv_usec)
+	    return -1;
+	else if (t1p->tv_usec > t2p->tv_usec)
+	    return 1;
+	return 0;
+    }
+    return t1p->tv_sec < t2p->tv_sec ? -1 : 1;
+}
+
+#endif /* #if ERTS_GLB_INLINE_INCL_FUNC_DEF */
+#endif /* ERL_TIME_H__ */
diff --git a/erts/emulator/beam/erl_time_sup.c b/erts/emulator/beam/erl_time_sup.c
index 7b8706ea13..ca4b54188e 100644
--- a/erts/emulator/beam/erl_time_sup.c
+++ b/erts/emulator/beam/erl_time_sup.c
@@ -358,10 +358,6 @@ static int clock_resolution;
 ** instead of something like select.
 */
 
-#if defined(ERTS_TIMER_THREAD)
-static ERTS_INLINE void init_erts_deliver_time(const SysTimeval *inittv) { }
-static ERTS_INLINE void do_erts_deliver_time(const SysTimeval *current) { }
-#else
 static SysTimeval last_delivered; 
 
 static void init_erts_deliver_time(const SysTimeval *inittv)
@@ -389,11 +385,10 @@ static void do_erts_deliver_time(const SysTimeval *current)
        this by simply pretend as if the time stood still. :) */
 
     if (elapsed > 0) {
-	do_time_add(elapsed);
+	erts_do_time_add(elapsed);
 	last_delivered = cur_time;
     }
 }
-#endif
 
 int 
 erts_init_time_sup(void)
@@ -786,7 +781,6 @@ get_sys_now(Uint* megasec, Uint* sec, Uint* microsec)
    to a struct timeval representing current time (to save
    a gettimeofday() where possible) or NULL */
 
-#if !defined(ERTS_TIMER_THREAD)
 void erts_deliver_time(void) {
     SysTimeval now;
     
@@ -797,7 +791,6 @@ void erts_deliver_time(void) {
     
     erts_smp_mtx_unlock(&erts_timeofday_mtx);
 }
-#endif
 
 /* get *real* time (not ticks) remaining until next timeout - if there
    isn't one, give a "long" time, that is guaranteed
@@ -806,14 +799,12 @@ void erts_deliver_time(void) {
 void erts_time_remaining(SysTimeval *rem_time)
 {
     int ticks;
-#if !defined(ERTS_TIMER_THREAD)
     SysTimeval cur_time;
-#endif
     long elapsed;
 
-    /* next_time() returns no of ticks to next timeout or -1 if none */
+    /* erts_next_time() returns no of ticks to next timeout or -1 if none */
 
-    if ((ticks = next_time()) == -1) {
+    if ((ticks = erts_next_time()) == -1) {
 	/* timer queue empty */
 	/* this will cause at most 100000000 ticks */
 	rem_time->tv_sec = 100000;
@@ -822,9 +813,6 @@ void erts_time_remaining(SysTimeval *rem_time)
 	/* next timeout after ticks ticks */
 	ticks *= CLOCK_RESOLUTION;
 	
-#if defined(ERTS_TIMER_THREAD)
-	elapsed = 0;
-#else
 	erts_smp_mtx_lock(&erts_timeofday_mtx);
 	
 	get_tolerant_timeofday(&cur_time);
@@ -839,7 +827,6 @@ void erts_time_remaining(SysTimeval *rem_time)
 	    rem_time->tv_sec = rem_time->tv_usec = 0;
 	    return;
 	}
-#endif
 	rem_time->tv_sec = (ticks - elapsed) / 1000;
 	rem_time->tv_usec = 1000 * ((ticks - elapsed) % 1000);
     }
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index c948af14ae..e8a9d5f32f 100644
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -1425,84 +1425,6 @@ void erl_drv_thr_init(void);
 
 /* time.c */
 
-ERTS_GLB_INLINE erts_aint_t do_time_read_and_reset(void);
-#ifdef ERTS_TIMER_THREAD
-ERTS_GLB_INLINE int next_time(void);
-ERTS_GLB_INLINE void bump_timer(erts_aint_t);
-#else
-erts_aint_t next_time(void);
-void bump_timer(erts_aint_t);
-extern erts_smp_atomic_t do_time;	/* set at clock interrupt */
-ERTS_GLB_INLINE void do_time_add(erts_aint_t);
-#endif
-
-#if ERTS_GLB_INLINE_INCL_FUNC_DEF
-
-#ifdef ERTS_TIMER_THREAD
-ERTS_GLB_INLINE erts_aint_t do_time_read_and_reset(void) { return 0; }
-ERTS_GLB_INLINE erts_aint_t next_time(void) { return -1; }
-ERTS_GLB_INLINE void bump_timer(erts_aint_t ignore) { }
-#else
-ERTS_GLB_INLINE erts_aint_t do_time_read_and_reset(void)
-{
-    return erts_smp_atomic_xchg(&do_time, 0L);
-}
-ERTS_GLB_INLINE void do_time_add(erts_aint_t elapsed)
-{
-    erts_smp_atomic_add(&do_time, elapsed);
-}
-#endif
-
-#endif /* #if ERTS_GLB_INLINE_INCL_FUNC_DEF */
-
-void init_time(void);
-void erl_set_timer(ErlTimer*, ErlTimeoutProc, ErlCancelProc, void*, Uint);
-void erl_cancel_timer(ErlTimer*);
-Uint time_left(ErlTimer *);
-
-Uint erts_timer_wheel_memory_size(void);
-
-#if (defined(HAVE_GETHRVTIME) || defined(HAVE_CLOCK_GETTIME))
-#  ifndef HAVE_ERTS_NOW_CPU
-#    define HAVE_ERTS_NOW_CPU
-#    ifdef HAVE_GETHRVTIME
-#      define erts_start_now_cpu() sys_start_hrvtime()
-#      define erts_stop_now_cpu()  sys_stop_hrvtime()
-#    endif
-#  endif
-void erts_get_now_cpu(Uint* megasec, Uint* sec, Uint* microsec);
-#endif
-
-void erts_get_timeval(SysTimeval *tv);
-long erts_get_time(void);
-
-extern SysTimeval erts_first_emu_time;
-
-void erts_get_emu_time(SysTimeval *);
-
-ERTS_GLB_INLINE int erts_cmp_timeval(SysTimeval *t1p, SysTimeval *t2p);
-
-#if ERTS_GLB_INLINE_INCL_FUNC_DEF
-
-ERTS_GLB_INLINE int
-erts_cmp_timeval(SysTimeval *t1p, SysTimeval *t2p)
-{
-    if (t1p->tv_sec == t2p->tv_sec) {
-	if (t1p->tv_usec < t2p->tv_usec)
-	    return -1;
-	else if (t1p->tv_usec > t2p->tv_usec)
-	    return 1;
-	return 0;
-    }
-    return t1p->tv_sec < t2p->tv_sec ? -1 : 1;
-}
-
-#endif
-
-#ifdef DEBUG
-void p_slpq(void);
-#endif
-
 /* utils.c */
 
 /*
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
index f6c6a01fb2..f21a96c754 100644
--- a/erts/emulator/beam/io.c
+++ b/erts/emulator/beam/io.c
@@ -670,7 +670,7 @@ erts_open_driver(erts_driver_t* driver,	/* Pointer to driver. */
 #ifdef ERTS_SMP
 	erts_cancel_smp_ptimer(port->ptimer);
 #else
-	erl_cancel_timer(&(port->tm));
+	erts_cancel_timer(&(port->tm));
 #endif
 	stopq(port);
 	kill_port(port);
@@ -1839,7 +1839,7 @@ terminate_port(Port *prt)
 #ifdef ERTS_SMP
     erts_cancel_smp_ptimer(prt->ptimer);
 #else
-    erl_cancel_timer(&prt->tm);
+    erts_cancel_timer(&prt->tm);
 #endif
 
     drv = prt->drv_ptr;
@@ -4068,7 +4068,7 @@ drv_cancel_timer(Port *prt)
 #ifdef ERTS_SMP
     erts_cancel_smp_ptimer(prt->ptimer);
 #else
-    erl_cancel_timer(&prt->tm);
+    erts_cancel_timer(&prt->tm);
 #endif
     if (erts_port_task_is_scheduled(&prt->timeout_task))
 	erts_port_task_abort(prt->id, &prt->timeout_task);
@@ -4092,7 +4092,7 @@ int driver_set_timer(ErlDrvPort ix, UWord t)
 			   (ErlTimeoutProc) schedule_port_timeout,
 			   t);
 #else
-    erl_set_timer(&prt->tm,
+    erts_set_timer(&prt->tm,
 		  (ErlTimeoutProc) schedule_port_timeout,
 		  NULL,
 		  prt,
@@ -4123,9 +4123,9 @@ driver_read_timer(ErlDrvPort ix, unsigned long* t)
 	return -1;
     ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
 #ifdef ERTS_SMP
-    *t = prt->ptimer ? time_left(&prt->ptimer->timer.tm) : 0;
+    *t = prt->ptimer ? erts_time_left(&prt->ptimer->timer.tm) : 0;
 #else
-    *t = time_left(&prt->tm);
+    *t = erts_time_left(&prt->tm);
 #endif
     return 0;
 }
diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h
index 5a4dad0a28..dff2dc37a2 100644
--- a/erts/emulator/beam/sys.h
+++ b/erts/emulator/beam/sys.h
@@ -39,13 +39,6 @@
 #define ENABLE_CHILD_WAITER_THREAD 1
 #endif
 
-/* The ERTS_TIMER_TREAD #define must be visible to the
-   erl_${OS}_sys.h #include files: it controls whether
-   certain optional facilities should be defined or not. */
-#if defined(ERTS_SMP) && 0
-#define ERTS_TIMER_THREAD
-#endif
-
 #if defined (__WIN32__)
 #  include "erl_win_sys.h"
 #elif defined (VXWORKS) 
@@ -562,11 +555,7 @@ extern char *erts_default_arg0;
 extern char os_type[];
 
 extern int sys_init_time(void);
-#if defined(ERTS_TIMER_THREAD)
-#define erts_deliver_time()
-#else
 extern void erts_deliver_time(void);
-#endif
 extern void erts_time_remaining(SysTimeval *);
 extern int erts_init_time_sup(void);
 extern void erts_sys_init_float(void);
diff --git a/erts/emulator/beam/time.c b/erts/emulator/beam/time.c
index 9cb6ea34ef..c65cc37fc6 100644
--- a/erts/emulator/beam/time.c
+++ b/erts/emulator/beam/time.c
@@ -99,76 +99,18 @@ static erts_smp_mtx_t tiw_lock;
 static ErlTimer** tiw;		/* the timing wheel, allocated in init_time() */
 static Uint tiw_pos;		/* current position in wheel */
 static Uint tiw_nto;		/* number of timeouts in wheel */
+static Uint tiw_min;
+static ErlTimer *tiw_min_ptr;
 
 /* END tiw_lock protected variables */
 
 /* Actual interval time chosen by sys_init_time() */
 static int itime; /* Constant after init */
 
-#if defined(ERTS_TIMER_THREAD)
-static SysTimeval time_start;	/* start of current time interval */
-static erts_aint_t ticks_end;		/* time_start+ticks_end == time_wakeup */
-static erts_aint_t ticks_latest;	/* delta from time_start at latest time update*/
-
-static ERTS_INLINE erts_aint_t time_gettimeofday(SysTimeval *now)
-{
-    erts_aint_t elapsed;
-
-    erts_get_timeval(now);
-    now->tv_usec = 1000 * (now->tv_usec / 1000); /* ms resolution */
-    elapsed = (1000 * (now->tv_sec - time_start.tv_sec) +
-	       (now->tv_usec - time_start.tv_usec) / 1000);
-    // elapsed /= CLOCK_RESOLUTION;
-    return elapsed;
-}
-
-static erts_aint_t do_time_update(void)
-{
-    SysTimeval now;
-    erts_aint_t elapsed;
-
-    elapsed = time_gettimeofday(&now);
-    ticks_latest = elapsed;
-    return elapsed;
-}
-
-static ERTS_INLINE erts_aint_t do_time_read(void)
-{
-    return ticks_latest;
-}
-
-static erts_aint_t do_time_reset(void)
-{
-    SysTimeval now;
-    erts_aint_t elapsed;
-
-    elapsed = time_gettimeofday(&now);
-    time_start = now;
-    ticks_end = LONG_MAX;
-    ticks_latest = 0;
-    return elapsed;
-}
-
-static ERTS_INLINE void do_time_init(void)
-{
-    (void)do_time_reset();
-}
-
-#else
 erts_smp_atomic_t do_time;	/* set at clock interrupt */
-static ERTS_INLINE erts_aint_t do_time_read(void)
-{
-    return erts_smp_atomic_read(&do_time);
-}
-static ERTS_INLINE erts_aint_t do_time_update(void)
-{
-    return do_time_read();
-}
-static ERTS_INLINE void do_time_init(void)
-{
-    erts_smp_atomic_init(&do_time, (erts_aint_t) 0);
-}
-#endif
+static ERTS_INLINE erts_aint_t do_time_read(void) { return erts_smp_atomic_read(&do_time); }
+static ERTS_INLINE erts_aint_t do_time_update(void) { return do_time_read(); }
+static ERTS_INLINE void do_time_init(void) { erts_smp_atomic_init(&do_time, 0L); }
 
 /* get the time (in units of itime) to the next timeout,
    or -1 if there are no timeouts                     */
@@ -182,6 +124,12 @@ static erts_aint_t next_time_internal(void) /* PRE: tiw_lock taken by caller */
   
     if (tiw_nto == 0)
 	return -1;	/* no timeouts in wheel */
+
+    if (tiw_min_ptr) {
+	min = tiw_min;
+	dt  = do_time_read();
+	return ((min >= dt) ? (min - dt) : 0);
+    }
   
     /* start going through wheel to find next timeout */
     tm = nto = 0;
@@ -194,11 +142,17 @@ static erts_aint_t next_time_internal(void) /* PRE: tiw_lock taken by caller */
 	    if (p->count == 0) {
 		/* found next timeout */
 		dt = do_time_read();
+		/* p->count is zero */
+		tiw_min_ptr = p;
+		tiw_min     = tm;
 		return ((tm >= dt) ? (tm - dt) : 0);
 	    } else {
 		/* keep shortest time in 'min' */
-		if (tm + p->count*TIW_SIZE < min)
+		if (tm + p->count*TIW_SIZE < min) {
 		    min = tm + p->count*TIW_SIZE;
+		    tiw_min_ptr = p;
+		    tiw_min     = min;
+		}
 	    }
 	    p = p->next;
 	}
@@ -211,9 +165,33 @@ static erts_aint_t next_time_internal(void) /* PRE: tiw_lock taken by caller */
     return ((min >= dt) ? (min - dt) : 0);
 }
 
-#if !defined(ERTS_TIMER_THREAD)
+static void remove_timer(ErlTimer *p) {
+    /* first */
+    if (!p->prev) {
+	tiw[p->slot] = p->next;
+	if(p->next)
+	    p->next->prev = NULL;
+    } else {
+	p->prev->next = p->next;
+    }
+
+    /* last */
+    if (!p->next) {
+	if (p->prev)
+	    p->prev->next = NULL;
+    } else {
+	p->next->prev = p->prev;
+    }
+
+    p->next = NULL;
+    p->prev = NULL;
+    /* Make sure cancel callback isn't called */
+    p->active = 0;
+    tiw_nto--;
+}
+
 /* Private export to erl_time_sup.c */
-erts_aint_t next_time(void)
+erts_aint_t erts_next_time(void)
 {
     erts_aint_t ret;
 
@@ -223,7 +201,6 @@ erts_aint_t next_time(void)
     erts_smp_mtx_unlock(&tiw_lock);
     return ret;
 }
-#endif
 
 static ERTS_INLINE void bump_timer_internal(erts_aint_t dt) /* PRE: tiw_lock is write-locked */
 {
@@ -251,12 +228,16 @@ static ERTS_INLINE void bump_timer_internal(erts_aint_t dt) /* PRE: tiw_lock is
 	if (tiw_pos == keep_pos) count--;
 	prev = &tiw[tiw_pos];
 	while ((p = *prev) != NULL) {
+	    ASSERT( p != p->next);
 	    if (p->count < count) {     /* we have a timeout */
-		*prev = p->next;	/* Remove from list */
-		tiw_nto--;
-		p->next = NULL;
-		p->active = 0;		/* Make sure cancel callback
-					   isn't called */
+		/* remove min time */
+		if (tiw_min_ptr == p) {
+		    tiw_min_ptr = NULL;
+		    tiw_min = 0;
+		}
+
+		/* Remove from list */
+		remove_timer(p);
 		*timeout_tail = p;	/* Insert in timeout queue */
 		timeout_tail = &p->next;
 	    }
@@ -270,6 +251,8 @@ static ERTS_INLINE void bump_timer_internal(erts_aint_t dt) /* PRE: tiw_lock is
 	dtime--;
     }
     tiw_pos = keep_pos;
+    if (tiw_min_ptr)
+	tiw_min -= dt;
     
     erts_smp_mtx_unlock(&tiw_lock);
     
@@ -284,24 +267,17 @@ static ERTS_INLINE void bump_timer_internal(erts_aint_t dt) /* PRE: tiw_lock is
 	 * callback is called.
 	 */
 	p->next = NULL;
+	p->prev = NULL;
 	p->slot = 0;
 	(*p->timeout)(p->arg);
     }
 }
 
-#if defined(ERTS_TIMER_THREAD)
-static void timer_thread_bump_timer(void)
-{
-    erts_smp_mtx_lock(&tiw_lock);
-    bump_timer_internal(do_time_reset());
-}
-#else
-void bump_timer(erts_aint_t dt) /* dt is value from do_time */
+void erts_bump_timer(erts_aint_t dt) /* dt is value from do_time */
 {
     erts_smp_mtx_lock(&tiw_lock);
     bump_timer_internal(dt);
 }
-#endif
 
 Uint
 erts_timer_wheel_memory_size(void)
@@ -309,82 +285,10 @@ erts_timer_wheel_memory_size(void)
     return (Uint) TIW_SIZE * sizeof(ErlTimer*);
 }
 
-#if defined(ERTS_TIMER_THREAD)
-static struct erts_iwait *timer_thread_iwait;
-
-static int timer_thread_setup_delay(SysTimeval *rem_time)
-{
-    erts_aint_t elapsed;
-    erts_aint_t ticks;
-
-    erts_smp_mtx_lock(&tiw_lock);
-    elapsed = do_time_update();
-    ticks = next_time_internal();
-    if (ticks == -1)	/* timer queue empty */
-	ticks = 100*1000*1000;
-    if (elapsed > ticks)
-	elapsed = ticks;
-    ticks -= elapsed;
-    //ticks *= CLOCK_RESOLUTION;
-    rem_time->tv_sec = ticks / 1000;
-    rem_time->tv_usec = 1000 * (ticks % 1000);
-    ticks_end = ticks;
-    erts_smp_mtx_unlock(&tiw_lock);
-    return ticks;
-}
-
-static void *timer_thread_start(void *ignore)
-{
-    SysTimeval delay;
-
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_set_thread_name("timer");
-#endif
-    erts_register_blockable_thread();
-
-    for(;;) {
-	if (timer_thread_setup_delay(&delay)) {
-	    erts_smp_activity_begin(ERTS_ACTIVITY_WAIT, NULL, NULL, NULL);
-	    ASSERT_NO_LOCKED_LOCKS;
-	    erts_iwait_wait(timer_thread_iwait, &delay);
-	    ASSERT_NO_LOCKED_LOCKS;
-	    erts_smp_activity_end(ERTS_ACTIVITY_WAIT, NULL, NULL, NULL);
-	}
-	else
-	    erts_smp_chk_system_block(NULL, NULL, NULL);
-	timer_thread_bump_timer();
-	ASSERT_NO_LOCKED_LOCKS;
-    }
-    /*NOTREACHED*/
-    return NULL;
-}
-
-static ERTS_INLINE void timer_thread_post_insert(Uint ticks)
-{
-    if ((Sint)ticks < ticks_end)
-	erts_iwait_interrupt(timer_thread_iwait);
-}
-
-static void timer_thread_init(void)
-{
-    erts_thr_opts_t opts = ERTS_THR_OPTS_DEFAULT_INITER;
-    erts_tid_t tid;
-
-    opts->detached = 1;
-
-    timer_thread_iwait = erts_iwait_init();
-    erts_thr_create(&tid, timer_thread_start, NULL, &opts);
-}
-
-#else
-static ERTS_INLINE void timer_thread_post_insert(Uint ticks) { }
-static ERTS_INLINE void timer_thread_init(void) { }
-#endif
-
 /* this routine links the time cells into a free list at the start
    and sets the time queue as empty */
 void
-init_time(void)
+erts_init_time(void)
 {
     int i;
 
@@ -400,10 +304,13 @@ init_time(void)
 	tiw[i] = NULL;
     do_time_init();
     tiw_pos = tiw_nto = 0;
-
-    timer_thread_init();
+    tiw_min_ptr = NULL;
+    tiw_min = 0;
 }
 
+
+
+
 /*
 ** Insert a process into the time queue, with a timeout 't'
 */
@@ -433,16 +340,31 @@ insert_timer(ErlTimer* p, Uint t)
   
     /* insert at head of list at slot */
     p->next = tiw[tm];
+    p->prev = NULL;
+    if (p->next != NULL)
+	p->next->prev = p;
     tiw[tm] = p;
-    tiw_nto++;
 
-    timer_thread_post_insert(ticks);
+
+    /* insert min time */
+    if ((tiw_nto == 0) || ((tiw_min_ptr != NULL) && (ticks < tiw_min))) {
+	tiw_min = ticks;
+	tiw_min_ptr = p;
+    }
+    if ((tiw_min_ptr == p) && (ticks > tiw_min)) {
+	/* some other timer might be 'min' now */
+	tiw_min = 0;
+	tiw_min_ptr = NULL;
+    }
+
+    tiw_nto++;
 }
 
 void
-erl_set_timer(ErlTimer* p, ErlTimeoutProc timeout, ErlCancelProc cancel,
+erts_set_timer(ErlTimer* p, ErlTimeoutProc timeout, ErlCancelProc cancel,
 	      void* arg, Uint t)
 {
+
     erts_deliver_time();
     erts_smp_mtx_lock(&tiw_lock);
     if (p->active) { /* XXX assert ? */
@@ -455,42 +377,34 @@ erl_set_timer(ErlTimer* p, ErlTimeoutProc timeout, ErlCancelProc cancel,
     p->active = 1;
     insert_timer(p, t);
     erts_smp_mtx_unlock(&tiw_lock);
-#if defined(ERTS_SMP) && !defined(ERTS_TIMER_THREAD)
+#if defined(ERTS_SMP)
     if (t <= (Uint) LONG_MAX)
 	erts_sys_schedule_interrupt_timed(1, (long) t);
 #endif
 }
 
 void
-erl_cancel_timer(ErlTimer* p)
+erts_cancel_timer(ErlTimer* p)
 {
-    ErlTimer *tp;
-    ErlTimer **prev;
-
     erts_smp_mtx_lock(&tiw_lock);
     if (!p->active) { /* allow repeated cancel (drivers) */
 	erts_smp_mtx_unlock(&tiw_lock);
 	return;
     }
-    /* find p in linked list at slot p->slot and remove it */
-    prev = &tiw[p->slot];
-    while ((tp = *prev) != NULL) {
-	if (tp == p) {
-	    *prev = p->next;	/* Remove from list */
-	    tiw_nto--;
-	    p->next = NULL;
-	    p->slot = p->count = 0;
-	    p->active = 0;
-	    if (p->cancel != NULL) {
-		erts_smp_mtx_unlock(&tiw_lock);
-		(*p->cancel)(p->arg);
-	    } else {
-		erts_smp_mtx_unlock(&tiw_lock);
-	    }
-	    return;
-	} else {
-	    prev = &tp->next;
-	}
+
+    /* is it the 'min' timer, remove min */
+    if (p == tiw_min_ptr) {
+	tiw_min_ptr = NULL;
+	tiw_min     = 0;
+    }
+
+    remove_timer(p);
+    p->slot = p->count = 0;
+
+    if (p->cancel != NULL) {
+	erts_smp_mtx_unlock(&tiw_lock);
+	(*p->cancel)(p->arg);
+	return;
     }
     erts_smp_mtx_unlock(&tiw_lock);
 }
@@ -502,7 +416,7 @@ erl_cancel_timer(ErlTimer* p)
   immediately if it hadn't been cancelled).
 */
 Uint
-time_left(ErlTimer *p)
+erts_time_left(ErlTimer *p)
 {
     Uint left;
     erts_aint_t dt;
@@ -530,8 +444,7 @@ time_left(ErlTimer *p)
 }
 
 #ifdef DEBUG
-
-void p_slpq()
+void erts_p_slpq()
 {
     int i;
     ErlTimer* p;
@@ -560,5 +473,4 @@ void p_slpq()
 
     erts_smp_mtx_unlock(&tiw_lock);
 }
-
 #endif /* DEBUG */
diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index 2bf283d9ec..1d60b54d21 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -59,13 +59,6 @@
 
 /* profile_scheduler mini message queue */
 
-#ifdef ERTS_TIMER_THREAD
-/* A timer thread is not welcomed with this lock violation work around.
- * - Bj�rn-Egil
- */
-#error Timer thread may not be enabled due to lock violation.
-#endif
-
 typedef struct {
     Uint scheduler_id;
     Uint no_schedulers;
@@ -3183,7 +3176,7 @@ erts_create_smp_ptimer(ErtsSmpPTimer **timer_ref,
 
     *timer_ref = res;
 
-    erl_set_timer(&res->timer.tm,
+    erts_set_timer(&res->timer.tm,
 		  (ErlTimeoutProc) ptimer_timeout,
 		  (ErlCancelProc) ptimer_cancelled,
 		  (void*) res,
@@ -3197,7 +3190,7 @@ erts_cancel_smp_ptimer(ErtsSmpPTimer *ptimer)
 	ASSERT(*ptimer->timer.timer_ref == ptimer);
 	*ptimer->timer.timer_ref = NULL;
 	ptimer->timer.flags |= ERTS_PTMR_FLG_CANCELLED;
-	erl_cancel_timer(&ptimer->timer.tm);
+	erts_cancel_timer(&ptimer->timer.tm);
     }
 }
 
diff --git a/erts/emulator/sys/common/erl_mseg.c b/erts/emulator/sys/common/erl_mseg.c
index b1ee165489..010d60eb63 100644
--- a/erts/emulator/sys/common/erl_mseg.c
+++ b/erts/emulator/sys/common/erl_mseg.c
@@ -35,6 +35,7 @@
 #include "global.h"
 #include "erl_threads.h"
 #include "erl_mtrace.h"
+#include "erl_time.h"
 #include "big.h"
 
 #if HAVE_ERTS_MSEG
@@ -271,7 +272,7 @@ schedule_cache_check(void)
 #endif
 	{
 	    cache_check_timer.active = 0;
-	    erl_set_timer(&cache_check_timer,
+	    erts_set_timer(&cache_check_timer,
 			  check_cache,
 			  NULL,
 			  NULL,
diff --git a/erts/emulator/sys/unix/erl_unix_sys.h b/erts/emulator/sys/unix/erl_unix_sys.h
index 2d5ef882f6..824678a0bb 100644
--- a/erts/emulator/sys/unix/erl_unix_sys.h
+++ b/erts/emulator/sys/unix/erl_unix_sys.h
@@ -329,11 +329,4 @@ extern int exit_async(void);
 
 #define ERTS_EXIT_AFTER_DUMP _exit
 
-#ifdef ERTS_TIMER_THREAD
-struct erts_iwait; /* opaque for clients */
-extern struct erts_iwait *erts_iwait_init(void);
-extern void erts_iwait_wait(struct erts_iwait *iwait, struct timeval *delay);
-extern void erts_iwait_interrupt(struct erts_iwait *iwait);
-#endif /* ERTS_TIMER_THREAD */
-
 #endif /* #ifndef _ERL_UNIX_SYS_H */
diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index d021baa6bf..bfc04faa45 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -3109,226 +3109,3 @@ erl_sys_args(int* argc, char** argv)
     }
     *argc = j;
 }
-
-#ifdef ERTS_TIMER_THREAD
-
-/*
- * Interruptible-wait facility: low-level synchronisation state
- * and methods that are implementation dependent.
- *
- * Constraint: Every implementation must define 'struct erts_iwait'
- * with a field 'erts_smp_atomic_t state;'.
- */
-
-/* values for struct erts_iwait's state field */
-#define IWAIT_WAITING	0
-#define IWAIT_AWAKE	1
-#define IWAIT_INTERRUPT	2
-
-#if 0	/* XXX: needs feature test in erts/configure.in */
-
-/*
- * This is an implementation of the interruptible wait facility on
- * top of Linux-specific futexes.
- */
-#include <asm/unistd.h>
-#define FUTEX_WAIT		0
-#define FUTEX_WAKE		1
-static int sys_futex(void *futex, int op, int val, const struct timespec *timeout)
-{
-    return syscall(__NR_futex, futex, op, val, timeout);
-}
-
-struct erts_iwait {
-    erts_smp_atomic_t state; /* &state.counter is our futex */
-};
-
-static void iwait_lowlevel_init(struct erts_iwait *iwait) { /* empty */ }
-
-static void iwait_lowlevel_wait(struct erts_iwait *iwait, struct timeval *delay)
-{
-    struct timespec timeout;
-    int res;
-
-    timeout.tv_sec = delay->tv_sec;
-    timeout.tv_nsec = delay->tv_usec * 1000;
-    res = sys_futex((void*)&iwait->state.counter, FUTEX_WAIT, IWAIT_WAITING, &timeout);
-    if (res < 0 && errno != ETIMEDOUT && errno != EWOULDBLOCK && errno != EINTR)
-	perror("FUTEX_WAIT");
-}
-
-static void iwait_lowlevel_interrupt(struct erts_iwait *iwait)
-{
-    int res = sys_futex((void*)&iwait->state.counter, FUTEX_WAKE, 1, NULL);
-    if (res < 0)
-	perror("FUTEX_WAKE");
-}
-
-#else	/* using poll() or select() */
-
-/*
- * This is an implementation of the interruptible wait facility on
- * top of pipe(), poll() or select(), read(), and write().
- */
-struct erts_iwait {
-    erts_smp_atomic_t state;
-    int read_fd;	/* wait polls and reads this fd */
-    int write_fd;	/* interrupt writes this fd */
-};
-
-static void iwait_lowlevel_init(struct erts_iwait *iwait)
-{
-    int fds[2];
-
-    if (pipe(fds) < 0) {
-	perror("pipe()");
-	exit(1);
-    }
-    iwait->read_fd = fds[0];
-    iwait->write_fd = fds[1];
-}
-
-#if defined(ERTS_USE_POLL)
-
-#include <sys/poll.h>
-#define PERROR_POLL "poll()"
-
-static int iwait_lowlevel_poll(int read_fd, struct timeval *delay)
-{
-    struct pollfd pollfd;
-    int timeout;
-
-    pollfd.fd = read_fd;
-    pollfd.events = POLLIN;
-    pollfd.revents = 0;
-    timeout = delay->tv_sec * 1000 + delay->tv_usec / 1000;
-    return poll(&pollfd, 1, timeout);
-}
-
-#else	/* !ERTS_USE_POLL */
-
-#include <sys/select.h>
-#define PERROR_POLL "select()"
-
-static int iwait_lowlevel_poll(int read_fd, struct timeval *delay)
-{
-    fd_set readfds;
-
-    FD_ZERO(&readfds);
-    FD_SET(read_fd, &readfds);
-    return select(read_fd + 1, &readfds, NULL, NULL, delay);
-}
-
-#endif	/* !ERTS_USE_POLL */
-
-static void iwait_lowlevel_wait(struct erts_iwait *iwait, struct timeval *delay)
-{
-    int res;
-    char buf[64];
-
-    res = iwait_lowlevel_poll(iwait->read_fd, delay);
-    if (res > 0)
-	(void)read(iwait->read_fd, buf, sizeof buf);
-    else if (res < 0 && errno != EINTR)
-	perror(PERROR_POLL);
-}
-
-static void iwait_lowlevel_interrupt(struct erts_iwait *iwait)
-{
-    int res = write(iwait->write_fd, "!", 1);
-    if (res < 0)
-	perror("write()");
-}
-
-#endif	/* using poll() or select() */
-
-#if 0	/* not using poll() or select() */
-/*
- * This is an implementation of the interruptible wait facility on
- * top of pthread_cond_timedwait(). This has two problems:
- * 1. pthread_cond_timedwait() requires an absolute time point,
- *    so the relative delay must be converted to absolute time.
- *    Worse, this breaks if the machine's time is adjusted while
- *    we're preparing to wait.
- * 2. Each cond operation requires additional mutex lock/unlock operations.
- *
- * Problem 2 is probably not too bad on Linux (they'll just become
- * relatively cheap futex operations), but problem 1 is the real killer.
- * Only use this implementation if no better alternatives are available!
- */
-struct erts_iwait {
-    erts_smp_atomic_t state;
-    pthread_cond_t cond;
-    pthread_mutex_t mutex;
-};
-
-static void iwait_lowlevel_init(struct erts_iwait *iwait)
-{
-    iwait->cond = (pthread_cond_t) PTHREAD_COND_INITIALIZER;
-    iwait->mutex = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
-}
-
-static void iwait_lowlevel_wait(struct erts_iwait *iwait, struct timeval *delay)
-{
-    struct timeval tmp;
-    struct timespec timeout;
-
-    /* Due to pthread_cond_timedwait()'s use of absolute
-       time, this must be the real gettimeofday(), _not_
-       the "smoothed" one beam/erl_time_sup.c implements. */
-    gettimeofday(&tmp, NULL);
-
-    tmp.tv_sec += delay->tv_sec;
-    tmp.tv_usec += delay->tv_usec;
-    if (tmp.tv_usec >= 1000*1000) {
-	tmp.tv_usec -= 1000*1000;
-	tmp.tv_sec += 1;
-    }
-    timeout.tv_sec = tmp.tv_sec;
-    timeout.tv_nsec = tmp.tv_usec * 1000;
-    pthread_mutex_lock(&iwait->mutex);
-    pthread_cond_timedwait(&iwait->cond, &iwait->mutex, &timeout);
-    pthread_mutex_unlock(&iwait->mutex);
-}
-
-static void iwait_lowlevel_interrupt(struct erts_iwait *iwait)
-{
-    pthread_mutex_lock(&iwait->mutex);
-    pthread_cond_signal(&iwait->cond);
-    pthread_mutex_unlock(&iwait->mutex);
-}
-
-#endif /* not using POLL */
-
-/*
- * Interruptible-wait facility. This is just a wrapper around the
- * low-level synchronisation code, where we maintain our logical
- * state in order to suppress some state transitions.
- */
-
-struct erts_iwait *erts_iwait_init(void)
-{
-    struct erts_iwait *iwait = malloc(sizeof *iwait);
-    if (!iwait) {
-	perror("malloc");
-	exit(1);
-    }
-    iwait_lowlevel_init(iwait);
-    erts_smp_atomic_init(&iwait->state, IWAIT_AWAKE);
-    return iwait;
-}
-
-void erts_iwait_wait(struct erts_iwait *iwait, struct timeval *delay)
-{
-    if (erts_smp_atomic_xchg(&iwait->state, IWAIT_WAITING) != IWAIT_INTERRUPT)
-	iwait_lowlevel_wait(iwait, delay);
-    erts_smp_atomic_set(&iwait->state, IWAIT_AWAKE);
-}
-
-void erts_iwait_interrupt(struct erts_iwait *iwait)
-{
-    if (erts_smp_atomic_xchg(&iwait->state, IWAIT_INTERRUPT) == IWAIT_WAITING)
-	iwait_lowlevel_interrupt(iwait);
-}
-
-#endif /* ERTS_TIMER_THREAD */
diff --git a/erts/emulator/sys/vxworks/sys.c b/erts/emulator/sys/vxworks/sys.c
index 411b4b37cf..c6e7b65f32 100644
--- a/erts/emulator/sys/vxworks/sys.c
+++ b/erts/emulator/sys/vxworks/sys.c
@@ -85,7 +85,7 @@ EXTERN_FUNCTION(void, erl_exit, (int n, char*, _DOTS_));
 EXTERN_FUNCTION(void, erl_error, (char*, va_list));
 EXTERN_FUNCTION(int, driver_interrupt, (int, int));
 EXTERN_FUNCTION(void, increment_time, (int));
-EXTERN_FUNCTION(int, next_time, (_VOID_));
+EXTERN_FUNCTION(int, erts_next_time, (_VOID_));
 EXTERN_FUNCTION(void, set_reclaim_free_function, (FreeFunction));
 EXTERN_FUNCTION(int, erl_mem_info_get, (MEM_PART_STATS *));
 EXTERN_FUNCTION(void, erl_crash_dump, (char* file, int line, char* fmt, ...));