Introduce time management in native APIs

11 files changed, 585 insertions, 112 deletions

diff --git a/erts/emulator/beam/erl_driver.h b/erts/emulator/beam/erl_driver.h
index dbb4d719c1..7ab58e336b 100644
--- a/erts/emulator/beam/erl_driver.h
+++ b/erts/emulator/beam/erl_driver.h
@@ -37,47 +37,6 @@
 #  endif
 #endif
 
-#ifdef SIZEOF_CHAR
-#  define SIZEOF_CHAR_SAVED__ SIZEOF_CHAR
-#  undef SIZEOF_CHAR
-#endif
-#ifdef SIZEOF_SHORT
-#  define SIZEOF_SHORT_SAVED__ SIZEOF_SHORT
-#  undef SIZEOF_SHORT
-#endif
-#ifdef SIZEOF_INT
-#  define SIZEOF_INT_SAVED__ SIZEOF_INT
-#  undef SIZEOF_INT
-#endif
-#ifdef SIZEOF_LONG
-#  define SIZEOF_LONG_SAVED__ SIZEOF_LONG
-#  undef SIZEOF_LONG
-#endif
-#ifdef SIZEOF_LONG_LONG
-#  define SIZEOF_LONG_LONG_SAVED__ SIZEOF_LONG_LONG
-#  undef SIZEOF_LONG_LONG
-#endif
-#ifdef HALFWORD_HEAP_EMULATOR
-#  define HALFWORD_HEAP_EMULATOR_SAVED__ HALFWORD_HEAP_EMULATOR
-#  undef HALFWORD_HEAP_EMULATOR
-#endif
-#include "erl_int_sizes_config.h"
-#if defined(SIZEOF_CHAR_SAVED__) && SIZEOF_CHAR_SAVED__ != SIZEOF_CHAR
-#  error SIZEOF_CHAR mismatch
-#endif
-#if defined(SIZEOF_SHORT_SAVED__) && SIZEOF_SHORT_SAVED__ != SIZEOF_SHORT
-#  error SIZEOF_SHORT mismatch
-#endif
-#if defined(SIZEOF_INT_SAVED__) && SIZEOF_INT_SAVED__ != SIZEOF_INT
-#  error SIZEOF_INT mismatch
-#endif
-#if defined(SIZEOF_LONG_SAVED__) && SIZEOF_LONG_SAVED__ != SIZEOF_LONG
-#  error SIZEOF_LONG mismatch
-#endif
-#if defined(SIZEOF_LONG_LONG_SAVED__) && SIZEOF_LONG_LONG_SAVED__ != SIZEOF_LONG_LONG
-#  error SIZEOF_LONG_LONG mismatch
-#endif
-
 /* This is OK to override by the NIF/driver implementor */
 #if defined(HALFWORD_HEAP_EMULATOR_SAVED__) && !defined(HALFWORD_HEAP_EMULATOR)
 #define HALFWORD_HEAP_EMULATOR HALFWORD_HEAP_EMULATOR_SAVED__
@@ -134,7 +93,7 @@ typedef struct {
 
 #define ERL_DRV_EXTENDED_MARKER		(0xfeeeeeed)
 #define ERL_DRV_EXTENDED_MAJOR_VERSION	3
-#define ERL_DRV_EXTENDED_MINOR_VERSION	2
+#define ERL_DRV_EXTENDED_MINOR_VERSION	3
 
 /*
  * The emulator will refuse to load a driver with a major version
@@ -176,28 +135,12 @@ typedef struct {
 /*
  * Integer types
  */
-#if  defined(__WIN32__) && (SIZEOF_VOID_P == 8)
-typedef unsigned __int64 ErlDrvTermData;
-typedef unsigned __int64 ErlDrvUInt;
-typedef signed __int64 ErlDrvSInt;
-#else
-typedef unsigned long ErlDrvTermData;
-typedef unsigned long ErlDrvUInt;
-typedef signed long ErlDrvSInt;
-#endif
 
-#if defined(__WIN32__)
-typedef unsigned __int64 ErlDrvUInt64;
-typedef __int64 ErlDrvSInt64;
-#elif SIZEOF_LONG == 8
-typedef unsigned long ErlDrvUInt64;
-typedef long ErlDrvSInt64;
-#elif SIZEOF_LONG_LONG == 8
-typedef unsigned long long ErlDrvUInt64;
-typedef long long ErlDrvSInt64;
-#else
-#error No 64-bit integer type
-#endif
+typedef ErlNapiUInt64 ErlDrvUInt64;
+typedef ErlNapiSInt64 ErlDrvSInt64;
+typedef ErlNapiUInt ErlDrvUInt;
+typedef ErlNapiSInt ErlDrvSInt;
+typedef ErlNapiUInt ErlDrvTermData;
 
 #if defined(__WIN32__) || defined(_WIN32)
 typedef ErlDrvUInt ErlDrvSizeT;
@@ -250,6 +193,17 @@ typedef struct {
     unsigned long microsecs;
 } ErlDrvNowData;
 
+typedef ErlDrvSInt64 ErlDrvTime;
+
+#define ERL_DRV_TIME_ERROR ((ErlDrvSInt64) ERTS_NAPI_TIME_ERROR__)
+
+typedef enum {
+    ERL_DRV_SEC = ERTS_NAPI_SEC__,
+    ERL_DRV_MSEC = ERTS_NAPI_MSEC__,
+    ERL_DRV_USEC = ERTS_NAPI_USEC__,
+    ERL_DRV_NSEC = ERTS_NAPI_NSEC__
+} ErlDrvTimeUnit;
+
 /*
  * Error codes that can be return from driver.
  */
@@ -685,8 +639,16 @@ EXTERN long driver_async(ErlDrvPort ix,
 EXTERN int driver_lock_driver(ErlDrvPort ix);
 
 /* Get the current 'now' timestamp (analogue to erlang:now()) */
-EXTERN int driver_get_now(ErlDrvNowData *now);
-
+EXTERN int driver_get_now(ErlDrvNowData *now) ERL_DRV_DEPRECATED_FUNC;
+
+/* Erlang Monotonic Time */
+EXTERN ErlDrvTime erl_drv_monotonic_time(ErlDrvTimeUnit time_unit);
+/* Time offset between Erlang Monotonic Time and Erlang System Time */
+EXTERN ErlDrvTime erl_drv_time_offset(ErlDrvTimeUnit time_unit);
+/* Time unit conversion */
+EXTERN ErlDrvTime erl_drv_convert_time_unit(ErlDrvTime val,
+					    ErlDrvTimeUnit from,
+					    ErlDrvTimeUnit to);
 
 /* These were removed from the ANSI version, now they're back. */
 
diff --git a/erts/emulator/beam/erl_drv_nif.h b/erts/emulator/beam/erl_drv_nif.h
index e2385f63f4..f6b946ae82 100644
--- a/erts/emulator/beam/erl_drv_nif.h
+++ b/erts/emulator/beam/erl_drv_nif.h
@@ -50,6 +50,90 @@ typedef enum {
 } ErlDrvDirtyJobFlags;
 #endif
 
+#ifdef SIZEOF_CHAR
+#  define SIZEOF_CHAR_SAVED__ SIZEOF_CHAR
+#  undef SIZEOF_CHAR
+#endif
+#ifdef SIZEOF_SHORT
+#  define SIZEOF_SHORT_SAVED__ SIZEOF_SHORT
+#  undef SIZEOF_SHORT
+#endif
+#ifdef SIZEOF_INT
+#  define SIZEOF_INT_SAVED__ SIZEOF_INT
+#  undef SIZEOF_INT
+#endif
+#ifdef SIZEOF_LONG
+#  define SIZEOF_LONG_SAVED__ SIZEOF_LONG
+#  undef SIZEOF_LONG
+#endif
+#ifdef SIZEOF_LONG_LONG
+#  define SIZEOF_LONG_LONG_SAVED__ SIZEOF_LONG_LONG
+#  undef SIZEOF_LONG_LONG
+#endif
+#ifdef HALFWORD_HEAP_EMULATOR
+#  define HALFWORD_HEAP_EMULATOR_SAVED__ HALFWORD_HEAP_EMULATOR
+#  undef HALFWORD_HEAP_EMULATOR
+#endif
+#include "erl_int_sizes_config.h"
+#if defined(SIZEOF_CHAR_SAVED__) && SIZEOF_CHAR_SAVED__ != SIZEOF_CHAR
+#  error SIZEOF_CHAR mismatch
+#endif
+#if defined(SIZEOF_SHORT_SAVED__) && SIZEOF_SHORT_SAVED__ != SIZEOF_SHORT
+#  error SIZEOF_SHORT mismatch
+#endif
+#if defined(SIZEOF_INT_SAVED__) && SIZEOF_INT_SAVED__ != SIZEOF_INT
+#  error SIZEOF_INT mismatch
+#endif
+#if defined(SIZEOF_LONG_SAVED__) && SIZEOF_LONG_SAVED__ != SIZEOF_LONG
+#  error SIZEOF_LONG mismatch
+#endif
+#if defined(SIZEOF_LONG_LONG_SAVED__) && SIZEOF_LONG_LONG_SAVED__ != SIZEOF_LONG_LONG
+#  error SIZEOF_LONG_LONG mismatch
+#endif
+
+#if !defined(__GNUC__) && (defined(__WIN32__) || defined(_WIN32) || defined(_WIN32_))
+typedef unsigned __int64 ErlNapiUInt64;
+typedef signed __int64 ErlNapiSInt64;
+#define ERL_NAPI_SINT64_MAX__ 9223372036854775807i64
+#define ERL_NAPI_SINT64_MIN__ (-ERL_NAPI_SINT64_MAX__ - 1i64)
+#elif SIZEOF_LONG == 8
+typedef unsigned long ErlNapiUInt64;
+typedef signed long ErlNapiSInt64;
+#define ERL_NAPI_SINT64_MAX__ 9223372036854775807L
+#define ERL_NAPI_SINT64_MIN__ (-ERL_NAPI_SINT64_MAX__ - 1L)
+#elif SIZEOF_LONG_LONG == 8
+typedef unsigned long long ErlNapiUInt64;
+typedef signed long long ErlNapiSInt64;
+#define ERL_NAPI_SINT64_MAX__ 9223372036854775807LL
+#define ERL_NAPI_SINT64_MIN__ (-ERL_NAPI_SINT64_MAX__ - 1LL)
+#else
+#  error No 64-bit integer type
+#endif
+
+#if SIZEOF_VOID_P == 8
+typedef ErlNapiUInt64 ErlNapiUInt;
+typedef ErlNapiSInt64 ErlNapiSInt;
+#elif SIZEOF_VOID_P == 4
+#  if SIZEOF_LONG == SIZEOF_VOID_P
+typedef unsigned long ErlNapiUInt;
+typedef signed long ErlNapiSInt;
+#  elif SIZEOF_INT == SIZEOF_VOID_P
+typedef unsigned int ErlNapiUInt;
+typedef signed int ErlNapiSInt;
+#  else
+#    error No 32-bit integer type
+#  endif
+#else
+#  error Not support arch
+#endif
+
+#define ERTS_NAPI_TIME_ERROR__ ERL_NAPI_SINT64_MIN__
+
+#define ERTS_NAPI_SEC__		0
+#define ERTS_NAPI_MSEC__	1
+#define ERTS_NAPI_USEC__	2
+#define ERTS_NAPI_NSEC__	3
+
 #endif  /* __ERL_DRV_NIF_H__ */
 
 
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index d7a2076d85..3141b05e2b 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -1175,6 +1175,26 @@ void enif_thread_exit(void *resp) { erl_drv_thread_exit(resp); }
 int enif_thread_join(ErlNifTid tid, void **respp) { return erl_drv_thread_join(tid,respp); }
 int enif_getenv(const char *key, char *value, size_t *value_size) { return erl_drv_getenv(key, value, value_size); }
 
+ErlNifTime enif_monotonic_time(ErlNifTimeUnit time_unit)
+{
+    return (ErlNifTime) erts_napi_monotonic_time((int) time_unit);
+}
+
+ErlNifTime enif_time_offset(ErlNifTimeUnit time_unit)
+{
+    return (ErlNifTime) erts_napi_time_offset((int) time_unit);
+}
+
+ErlNifTime
+enif_convert_time_unit(ErlNifTime val,
+		       ErlNifTimeUnit from,
+		       ErlNifTimeUnit to)
+{
+    return (ErlNifTime) erts_napi_convert_time_unit((ErtsMonotonicTime) val,
+						    (int) from,
+						    (int) to);
+}
+
 int enif_fprintf(void* filep, const char* format, ...) 
 { 
     int ret;
diff --git a/erts/emulator/beam/erl_nif.h b/erts/emulator/beam/erl_nif.h
index 5e39343e9b..75070ad901 100644
--- a/erts/emulator/beam/erl_nif.h
+++ b/erts/emulator/beam/erl_nif.h
@@ -49,9 +49,10 @@
 **           add ErlNifFunc flags
 ** 2.8: 18.0 add enif_has_pending_exception
 ** 2.9: 18.2 enif_getenv
+** 2.10: Time API
 */
 #define ERL_NIF_MAJOR_VERSION 2
-#define ERL_NIF_MINOR_VERSION 9
+#define ERL_NIF_MINOR_VERSION 10
 
 /*
  * The emulator will refuse to load a nif-lib with a major version
@@ -67,63 +68,36 @@
 
 #include <stdlib.h>
 
-#ifdef SIZEOF_CHAR
-#  define SIZEOF_CHAR_SAVED__ SIZEOF_CHAR
-#  undef SIZEOF_CHAR
-#endif
-#ifdef SIZEOF_SHORT
-#  define SIZEOF_SHORT_SAVED__ SIZEOF_SHORT
-#  undef SIZEOF_SHORT
-#endif
-#ifdef SIZEOF_INT
-#  define SIZEOF_INT_SAVED__ SIZEOF_INT
-#  undef SIZEOF_INT
-#endif
-#ifdef SIZEOF_LONG
-#  define SIZEOF_LONG_SAVED__ SIZEOF_LONG
-#  undef SIZEOF_LONG
-#endif
-#ifdef SIZEOF_LONG_LONG
-#  define SIZEOF_LONG_LONG_SAVED__ SIZEOF_LONG_LONG
-#  undef SIZEOF_LONG_LONG
-#endif
-#ifdef HALFWORD_HEAP_EMULATOR
-#  define HALFWORD_HEAP_EMULATOR_SAVED__ HALFWORD_HEAP_EMULATOR
-#  undef HALFWORD_HEAP_EMULATOR
-#endif
-#include "erl_int_sizes_config.h"
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#if (defined(__WIN32__) || defined(_WIN32) || defined(_WIN32_))
-typedef unsigned __int64 ErlNifUInt64;
-typedef __int64 ErlNifSInt64;
-#elif SIZEOF_LONG == 8
-typedef unsigned long ErlNifUInt64;
-typedef long ErlNifSInt64;
-#elif SIZEOF_LONG_LONG == 8
-typedef unsigned long long ErlNifUInt64;
-typedef long long ErlNifSInt64;
-#else
-#error No 64-bit integer type
-#endif
+typedef ErlNapiUInt64 ErlNifUInt64;
+typedef ErlNapiSInt64 ErlNifSInt64;
+typedef ErlNapiUInt ErlNifUInt;
+typedef ErlNapiSInt ErlNifSInt;
 
 #ifdef HALFWORD_HEAP_EMULATOR
 #  define ERL_NIF_VM_VARIANT "beam.halfword" 
 typedef unsigned int ERL_NIF_TERM;
 #else
 #  define ERL_NIF_VM_VARIANT "beam.vanilla" 
-#  if SIZEOF_LONG == SIZEOF_VOID_P
-typedef unsigned long ERL_NIF_TERM;
-#  elif SIZEOF_LONG_LONG == SIZEOF_VOID_P
-typedef unsigned long long ERL_NIF_TERM;
-#  endif
+typedef ErlNifUInt ERL_NIF_TERM;
 #endif
 
 typedef ERL_NIF_TERM ERL_NIF_UINT;
 
+typedef ErlNifSInt64 ErlNifTime;
+
+#define ERL_NIF_TIME_ERROR ((ErlNifSInt64) ERTS_NAPI_TIME_ERROR__)
+
+typedef enum {
+    ERL_NIF_SEC = ERTS_NAPI_SEC__,
+    ERL_NIF_MSEC = ERTS_NAPI_MSEC__,
+    ERL_NIF_USEC = ERTS_NAPI_USEC__,
+    ERL_NIF_NSEC = ERTS_NAPI_NSEC__
+} ErlNifTimeUnit;
+
 struct enif_environment_t;
 typedef struct enif_environment_t ErlNifEnv;
 
diff --git a/erts/emulator/beam/erl_nif_api_funcs.h b/erts/emulator/beam/erl_nif_api_funcs.h
index 08b9afc6af..1448a508a2 100644
--- a/erts/emulator/beam/erl_nif_api_funcs.h
+++ b/erts/emulator/beam/erl_nif_api_funcs.h
@@ -160,6 +160,9 @@ ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_schedule_nif,(ErlNifEnv*,const char*,int
 ERL_NIF_API_FUNC_DECL(int, enif_has_pending_exception, (ErlNifEnv *env, ERL_NIF_TERM* reason));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM, enif_raise_exception, (ErlNifEnv *env, ERL_NIF_TERM reason));
 ERL_NIF_API_FUNC_DECL(int,enif_getenv,(const char* key, char* value, size_t* value_size));
+ERL_NIF_API_FUNC_DECL(ErlNifTime, enif_monotonic_time, (ErlNifTimeUnit));
+ERL_NIF_API_FUNC_DECL(ErlNifTime, enif_time_offset, (ErlNifTimeUnit));
+ERL_NIF_API_FUNC_DECL(ErlNifTime, enif_convert_time_unit, (ErlNifTime, ErlNifTimeUnit, ErlNifTimeUnit));
 
 /*
 ** ADD NEW ENTRIES HERE (before this comment) !!!
@@ -312,6 +315,9 @@ ERL_NIF_API_FUNC_DECL(int,enif_is_on_dirty_scheduler,(ErlNifEnv*));
 #  define enif_has_pending_exception ERL_NIF_API_FUNC_MACRO(enif_has_pending_exception)
 #  define enif_raise_exception ERL_NIF_API_FUNC_MACRO(enif_raise_exception)
 #  define enif_getenv ERL_NIF_API_FUNC_MACRO(enif_getenv)
+#  define enif_monotonic_time ERL_NIF_API_FUNC_MACRO(enif_monotonic_time)
+#  define enif_time_offset ERL_NIF_API_FUNC_MACRO(enif_time_offset)
+#  define enif_convert_time_unit ERL_NIF_API_FUNC_MACRO(enif_convert_time_unit)
 
 /*
 ** ADD NEW ENTRIES HERE (before this comment)
diff --git a/erts/emulator/beam/erl_time.h b/erts/emulator/beam/erl_time.h
index 43e543e035..93a0d556bf 100644
--- a/erts/emulator/beam/erl_time.h
+++ b/erts/emulator/beam/erl_time.h
@@ -133,6 +133,10 @@ typedef struct {
 
 extern ErtsTimeSupData erts_time_sup__;
 
+ErtsMonotonicTime erts_napi_monotonic_time(int time_unit);
+ErtsMonotonicTime erts_napi_time_offset(int time_unit);
+ErtsMonotonicTime erts_napi_convert_time_unit(ErtsMonotonicTime val, int from, int to);
+
 ERTS_GLB_INLINE Uint64
 erts_time_unit_conversion(Uint64 value,
 			  Uint32 from_time_unit,
diff --git a/erts/emulator/beam/erl_time_sup.c b/erts/emulator/beam/erl_time_sup.c
index 2c87b8e81c..5f12c7809a 100644
--- a/erts/emulator/beam/erl_time_sup.c
+++ b/erts/emulator/beam/erl_time_sup.c
@@ -33,6 +33,8 @@
 #include "global.h"
 #define ERTS_WANT_TIMER_WHEEL_API
 #include "erl_time.h"
+#include "erl_driver.h"
+#include "erl_nif.h"
  
 static erts_smp_mtx_t erts_timeofday_mtx;
 static erts_smp_mtx_t erts_get_time_mtx;
@@ -57,6 +59,7 @@ static int time_sup_initialized = 0;
 #define ERTS_MONOTONIC_TIME_TERA \
     (ERTS_MONOTONIC_TIME_GIGA*ERTS_MONOTONIC_TIME_KILO)
 
+static void init_time_napi(void);
 static void
 schedule_send_time_offset_changed_notifications(ErtsMonotonicTime new_offset);
 
@@ -948,6 +951,8 @@ erts_init_time_sup(int time_correction, ErtsTimeWarpMode time_warp_mode)
     ErtsMonotonicTime abs_native_offset, native_offset;
 #endif
 
+    init_time_napi();
+
     erts_hl_timer_init();
 
     ASSERT(ERTS_MONOTONIC_TIME_MIN < ERTS_MONOTONIC_TIME_MAX);
@@ -2197,6 +2202,146 @@ time_unit_conversion(Process *c_p, Eterm term, ErtsMonotonicTime val, ErtsMonoto
     return ret;
 }
 
+
+/*
+ * Time Native API (drivers and NIFs)
+ */
+
+#define ERTS_NAPI_TIME_ERROR ((ErtsMonotonicTime) ERTS_NAPI_TIME_ERROR__)
+
+static void
+init_time_napi(void)
+{
+    /* Verify that time native api constants are as expected... */
+
+    ASSERT(sizeof(ErtsMonotonicTime) == sizeof(ErlDrvTime));
+    ASSERT(ERL_DRV_TIME_ERROR == (ErlDrvTime) ERTS_NAPI_TIME_ERROR);
+    ASSERT(ERL_DRV_TIME_ERROR < (ErlDrvTime) 0);
+    ASSERT(ERTS_NAPI_SEC__ == (int) ERL_DRV_SEC);
+    ASSERT(ERTS_NAPI_MSEC__ == (int) ERL_DRV_MSEC);
+    ASSERT(ERTS_NAPI_USEC__ == (int) ERL_DRV_USEC);
+    ASSERT(ERTS_NAPI_NSEC__ == (int) ERL_DRV_NSEC);
+
+    ASSERT(sizeof(ErtsMonotonicTime) == sizeof(ErlNifTime));
+    ASSERT(ERL_NIF_TIME_ERROR == (ErlNifTime) ERTS_NAPI_TIME_ERROR);
+    ASSERT(ERL_NIF_TIME_ERROR < (ErlNifTime) 0);
+    ASSERT(ERTS_NAPI_SEC__ == (int) ERL_NIF_SEC);
+    ASSERT(ERTS_NAPI_MSEC__ == (int) ERL_NIF_MSEC);
+    ASSERT(ERTS_NAPI_USEC__ == (int) ERL_NIF_USEC);
+    ASSERT(ERTS_NAPI_NSEC__ == (int) ERL_NIF_NSEC);
+}
+
+ErtsMonotonicTime
+erts_napi_monotonic_time(int time_unit)
+{
+    ErtsSchedulerData *esdp;
+    ErtsMonotonicTime mtime;
+
+    /* At least for now only allow schedulers to do this... */
+    esdp = erts_get_scheduler_data();
+    if (!esdp)
+	return ERTS_NAPI_TIME_ERROR;
+
+    mtime = time_sup.r.o.get_time();
+    update_last_mtime(esdp, mtime);
+
+    switch (time_unit) {
+    case ERTS_NAPI_SEC__:
+	mtime = ERTS_MONOTONIC_TO_SEC(mtime);
+	mtime += ERTS_MONOTONIC_OFFSET_SEC;
+	break;
+    case ERTS_NAPI_MSEC__:
+	mtime = ERTS_MONOTONIC_TO_MSEC(mtime);
+	mtime += ERTS_MONOTONIC_OFFSET_MSEC;
+	break;
+    case ERTS_NAPI_USEC__:
+	mtime = ERTS_MONOTONIC_TO_USEC(mtime);
+	mtime += ERTS_MONOTONIC_OFFSET_USEC;
+	break;
+    case ERTS_NAPI_NSEC__:
+	mtime = ERTS_MONOTONIC_TO_NSEC(mtime);
+	mtime += ERTS_MONOTONIC_OFFSET_NSEC;
+	break;
+    default:
+	return ERTS_NAPI_TIME_ERROR;
+    }
+
+    return mtime;
+}
+
+ErtsMonotonicTime
+erts_napi_time_offset(int time_unit)
+{
+    ErtsSchedulerData *esdp;
+    ErtsSystemTime offs;
+
+    /* At least for now only allow schedulers to do this... */
+    esdp = erts_get_scheduler_data();
+    if (!esdp)
+	return ERTS_NAPI_TIME_ERROR;
+
+    offs = get_time_offset();
+    switch (time_unit) {
+    case ERTS_NAPI_SEC__:
+	offs = ERTS_MONOTONIC_TO_SEC(offs);
+	offs -= ERTS_MONOTONIC_OFFSET_SEC;
+	break;
+    case ERTS_NAPI_MSEC__:
+	offs = ERTS_MONOTONIC_TO_MSEC(offs);
+	offs -= ERTS_MONOTONIC_OFFSET_MSEC;
+	break;
+    case ERTS_NAPI_USEC__:
+	offs = ERTS_MONOTONIC_TO_USEC(offs);
+	offs -= ERTS_MONOTONIC_OFFSET_USEC;
+	break;
+    case ERTS_NAPI_NSEC__:
+	offs = ERTS_MONOTONIC_TO_NSEC(offs);
+	offs -= ERTS_MONOTONIC_OFFSET_NSEC;
+	break;
+    default:
+	return ERTS_NAPI_TIME_ERROR;
+    }
+    return offs;
+}
+
+ErtsMonotonicTime
+erts_napi_convert_time_unit(ErtsMonotonicTime val, int from, int to)
+{
+    ErtsMonotonicTime ffreq, tfreq, denom;
+    /*
+     * Convertion between time units using floor function.
+     *
+     * Note that this needs to work also for negative
+     * values. Ordinary integer division on a negative
+     * value will give ceiling...
+     */
+
+    switch ((int) from) {
+    case ERTS_NAPI_SEC__: ffreq = 1; break;
+    case ERTS_NAPI_MSEC__: ffreq = 1000; break;
+    case ERTS_NAPI_USEC__: ffreq = 1000*1000; break;
+    case ERTS_NAPI_NSEC__: ffreq = 1000*1000*1000; break;
+    default: return ERTS_NAPI_TIME_ERROR;
+    }
+
+    switch ((int) to) {
+    case ERTS_NAPI_SEC__: tfreq = 1; break;
+    case ERTS_NAPI_MSEC__: tfreq = 1000; break;
+    case ERTS_NAPI_USEC__: tfreq = 1000*1000; break;
+    case ERTS_NAPI_NSEC__: tfreq = 1000*1000*1000; break;
+    default: return ERTS_NAPI_TIME_ERROR;
+    }
+
+    if (tfreq >= ffreq)
+	return val * (tfreq / ffreq);
+
+    denom = ffreq / tfreq;
+    if (val >= 0)
+	return val / denom;
+
+    return (val - (denom - 1)) / denom;
+}
+
 /* Built in functions */
 
 BIF_RETTYPE monotonic_time_0(BIF_ALIST_0)
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
index c64c8802b9..2bd31ee97e 100644
--- a/erts/emulator/beam/io.c
+++ b/erts/emulator/beam/io.c
@@ -50,6 +50,7 @@
 #include "erl_map.h"
 #include "erl_bif_unique.h"
 #include "erl_hl_timer.h"
+#include "erl_time.h"
 
 extern ErlDrvEntry fd_driver_entry;
 #ifndef __OSE__
@@ -6762,6 +6763,28 @@ driver_get_now(ErlDrvNowData *now_data)
     return 0;
 }
 
+ErlDrvTime
+erl_drv_monotonic_time(ErlDrvTimeUnit time_unit)
+{
+    return (ErlDrvTime) erts_napi_monotonic_time((int) time_unit);
+}
+
+ErlDrvTime
+erl_drv_time_offset(ErlDrvTimeUnit time_unit)
+{
+    return (ErlDrvTime) erts_napi_time_offset((int) time_unit);
+}
+
+ErlDrvTime
+erl_drv_convert_time_unit(ErlDrvTime val,
+			  ErlDrvTimeUnit from,
+			  ErlDrvTimeUnit to)
+{
+    return (ErlDrvTime) erts_napi_convert_time_unit((ErtsMonotonicTime) val,
+						    (int) from,
+						    (int) to);
+}
+
 static void ref_to_driver_monitor(Eterm ref, ErlDrvMonitor *mon)
 {
     RefThing *refp;
diff --git a/erts/emulator/sys/win32/erl_win_dyn_driver.h b/erts/emulator/sys/win32/erl_win_dyn_driver.h
index baac7c903e..9c699fdba0 100644
--- a/erts/emulator/sys/win32/erl_win_dyn_driver.h
+++ b/erts/emulator/sys/win32/erl_win_dyn_driver.h
@@ -103,6 +103,11 @@ WDD_TYPEDEF(ErlDrvSInt, driver_pdl_inc_refc, (ErlDrvPDL));
 WDD_TYPEDEF(ErlDrvSInt, driver_pdl_dec_refc, (ErlDrvPDL));
 WDD_TYPEDEF(void, driver_system_info, (ErlDrvSysInfo *, size_t));
 WDD_TYPEDEF(int, driver_get_now, (ErlDrvNowData *));
+WDD_TYPEDEF(ErlDrvTime, erl_drv_monotonic_time, (ErlDrvTimeUnit));
+WDD_TYPEDEF(ErlDrvTime, erl_drv_time_offset, (ErlDrvTimeUnit));
+WDD_TYPEDEF(ErlDrvTime, erl_drv_convert_time_unit, (ErlDrvTime,
+						    ErlDrvTimeUnit,
+						    ErlDrvTimeUnit));
 WDD_TYPEDEF(int, driver_monitor_process, (ErlDrvPort port, 
 					  ErlDrvTermData process, 
 					  ErlDrvMonitor *monitor));
@@ -217,6 +222,9 @@ typedef struct {
     WDD_FTYPE(driver_pdl_dec_refc) *driver_pdl_dec_refc;
     WDD_FTYPE(driver_system_info) *driver_system_info;
     WDD_FTYPE(driver_get_now) *driver_get_now;
+    WDD_FTYPE(erl_drv_monotonic_time) *erl_drv_monotonic_time;
+    WDD_FTYPE(erl_drv_time_offset) *erl_drv_time_offset;
+    WDD_FTYPE(erl_drv_convert_time_unit) *erl_drv_convert_time_unit;
     WDD_FTYPE(driver_monitor_process) *driver_monitor_process;
     WDD_FTYPE(driver_demonitor_process) *driver_demonitor_process;
     WDD_FTYPE(driver_get_monitored_process) *driver_get_monitored_process;
@@ -328,6 +336,9 @@ extern TWinDynDriverCallbacks WinDynDriverCallbacks;
 #define driver_pdl_dec_refc (WinDynDriverCallbacks.driver_pdl_dec_refc)
 #define driver_system_info (WinDynDriverCallbacks.driver_system_info)
 #define driver_get_now (WinDynDriverCallbacks.driver_get_now)
+#define erl_drv_monotonic_time (WinDynDriverCallbacks.erl_drv_monotonic_time)
+#define erl_drv_time_offset (WinDynDriverCallbacks.erl_drv_time_offset)
+#define erl_drv_convert_time_unit (WinDynDriverCallbacks.erl_drv_convert_time_unit)
 #define driver_monitor_process \
 (WinDynDriverCallbacks.driver_monitor_process)
 #define driver_demonitor_process \
@@ -463,6 +474,9 @@ do {				                        \
 ((W).driver_pdl_dec_refc) = driver_pdl_dec_refc;	\
 ((W).driver_system_info) = driver_system_info;		\
 ((W).driver_get_now) = driver_get_now;		        \
+((W).erl_drv_monotonic_time) = erl_drv_monotonic_time;	\
+((W).erl_drv_time_offset) = erl_drv_time_offset;	\
+((W).erl_drv_convert_time_unit) = erl_drv_convert_time_unit; \
 ((W).driver_monitor_process) = driver_monitor_process;    \
 ((W).driver_demonitor_process) = driver_demonitor_process;  \
 ((W).driver_get_monitored_process) = driver_get_monitored_process;      \
diff --git a/erts/emulator/test/nif_SUITE.erl b/erts/emulator/test/nif_SUITE.erl
index af2b955184..3d478654b1 100644
--- a/erts/emulator/test/nif_SUITE.erl
+++ b/erts/emulator/test/nif_SUITE.erl
@@ -42,7 +42,8 @@
 	 otp_9668/1, consume_timeslice/1, dirty_nif/1, dirty_nif_send/1,
 	 dirty_nif_exception/1, call_dirty_nif_exception/1, nif_schedule/1,
 	 nif_exception/1, call_nif_exception/1,
-	 nif_nan_and_inf/1, nif_atom_too_long/1
+	 nif_nan_and_inf/1, nif_atom_too_long/1,
+	 nif_monotonic_time/1, nif_time_offset/1, nif_convert_time_unit/1
 	]).
 
 -export([many_args_100/100]).
@@ -72,7 +73,8 @@ all() ->
      otp_9828,
      otp_9668, consume_timeslice,
      nif_schedule, dirty_nif, dirty_nif_send, dirty_nif_exception,
-     nif_exception, nif_nan_and_inf, nif_atom_too_long
+     nif_exception, nif_nan_and_inf, nif_atom_too_long,
+     nif_monotonic_time, nif_time_offset, nif_convert_time_unit
     ].
 
 groups() -> 
@@ -1783,6 +1785,148 @@ nif_raise_exceptions(NifFunc) ->
 			end
 		end, ok, ExcTerms).
 
+-define(ERL_NIF_TIME_ERROR, -9223372036854775808).
+-define(TIME_UNITS, [seconds, milli_seconds, micro_seconds, nano_seconds]).
+
+nif_monotonic_time(Config) ->
+    ?ERL_NIF_TIME_ERROR = monotonic_time(invalid_time_unit),
+    mtime_loop(1000000).
+
+mtime_loop(0) ->
+    ok;
+mtime_loop(N) ->
+    chk_mtime(?TIME_UNITS),
+    mtime_loop(N-1).
+
+chk_mtime([]) ->
+    ok;
+chk_mtime([TU|TUs]) ->
+    A = erlang:monotonic_time(TU),
+    B = monotonic_time(TU),
+    C = erlang:monotonic_time(TU),
+    try
+	true = A =< B,
+	true = B =< C
+    catch
+	_ : _ ->
+	    ?t:fail({monotonic_time_missmatch, TU, A, B, C})
+    end,
+    chk_mtime(TUs).
+
+nif_time_offset(Config) ->
+    ?ERL_NIF_TIME_ERROR = time_offset(invalid_time_unit),
+    toffs_loop(1000000).
+
+toffs_loop(0) ->
+    ok;
+toffs_loop(N) ->
+    chk_toffs(?TIME_UNITS),
+    toffs_loop(N-1).
+
+chk_toffs([]) ->
+    ok;
+chk_toffs([TU|TUs]) ->
+    TO = erlang:time_offset(TU),
+    NifTO = time_offset(TU),
+    case TO =:= NifTO of
+	true ->
+	    ok;
+	false ->
+	    case erlang:system_info(time_warp_mode) of
+		no_time_warp ->
+		    ?t:fail({time_offset_mismatch, TU, TO, NifTO});
+		_ ->
+		    %% Most frequent time offset change
+		    %% is currently only every 15:th
+		    %% second so this should currently
+		    %% work...
+		    NTO = erlang:time_offset(TU),
+		    case NifTO =:= NTO of
+			true ->
+			    ok;
+			false ->
+			    ?t:fail({time_offset_mismatch, TU, TO, NifTO, NTO})
+		    end
+	    end
+    end,
+    chk_toffs(TUs).
+
+nif_convert_time_unit(Config) ->
+    ?ERL_NIF_TIME_ERROR = convert_time_unit(0, seconds, invalid_time_unit),
+    ?ERL_NIF_TIME_ERROR = convert_time_unit(0, invalid_time_unit, seconds),
+    ?ERL_NIF_TIME_ERROR = convert_time_unit(0, invalid_time_unit, invalid_time_unit),
+    lists:foreach(fun (Offset) ->
+			  lists:foreach(fun (Diff) ->
+						chk_ctu(Diff+(Offset*1000*1000*1000))
+					end,
+					[999999999999,
+					 99999999999,
+					 9999999999,
+					 999999999,
+					 99999999,
+					 9999999,
+					 999999,
+					 99999,
+					 999,
+					 99,
+					 9,
+					 1,
+					 11,
+					 101,
+					 1001,
+					 10001,
+					 100001,
+					 1000001,
+					 10000001,
+					 100000001,
+					 1000000001,
+					 100000000001,
+					 1000000000001,
+					 5,
+					 50,
+					 500,
+					 5000,
+					 50000,
+					 500000,
+					 5000000,
+					 50000000,
+					 500000000,
+					 5000000000,
+					 50000000000,
+					 500000000000])
+		  end,
+		  [-4711, -1000, -475, -5, -4, -3, -2, -1, 0,
+		   1, 2, 3, 4, 5, 475, 1000, 4711]),
+    ctu_loop(1000000).
+
+ctu_loop(0) ->
+    ok;
+ctu_loop(N) ->
+    chk_ctu(erlang:monotonic_time(nano_seconds)),
+    ctu_loop(N-1).
+
+chk_ctu(Time) ->
+    chk_ctu(Time, ?TIME_UNITS).
+
+chk_ctu(_Time, []) ->
+    ok;
+chk_ctu(Time, [FromTU|FromTUs]) ->
+    chk_ctu(Time, FromTU, ?TIME_UNITS),
+    chk_ctu(Time, FromTUs).
+
+chk_ctu(_Time, _FromTU, []) ->
+    ok;
+chk_ctu(Time, FromTU, [ToTU|ToTUs]) ->
+    T = erlang:convert_time_unit(Time, nano_seconds, FromTU),
+    TE = erlang:convert_time_unit(T, FromTU, ToTU),
+    TN = convert_time_unit(T, FromTU, ToTU),
+    case TE =:= TN of
+	false ->
+	    ?t:fail({conversion_mismatch, FromTU, T, ToTU, TE, TN});
+	true ->
+	    chk_ctu(Time, FromTU, ToTUs)
+    end.
+
 %% The NIFs:
 lib_version() -> undefined.
 call_history() -> ?nif_stub.
@@ -1852,6 +1996,11 @@ make_map_remove_nif(_,_) -> ?nif_stub.
 maps_from_list_nif(_) -> ?nif_stub.
 sorted_list_from_maps_nif(_) -> ?nif_stub.
 
+%% Time
+monotonic_time(_) -> ?nif_stub.
+time_offset(_) -> ?nif_stub.
+convert_time_unit(_,_,_) -> ?nif_stub.
+    
 
 nif_stub_error(Line) ->
     exit({nif_not_loaded,module,?MODULE,line,Line}).
diff --git a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
index 98e1efe18f..8ebce4fef4 100644
--- a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
+++ b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
@@ -34,6 +34,10 @@ static ERL_NIF_TERM atom_self;
 static ERL_NIF_TERM atom_ok;
 static ERL_NIF_TERM atom_join;
 static ERL_NIF_TERM atom_binary_resource_type;
+static ERL_NIF_TERM atom_seconds;
+static ERL_NIF_TERM atom_milli_seconds;
+static ERL_NIF_TERM atom_micro_seconds;
+static ERL_NIF_TERM atom_nano_seconds;
 
 
 typedef struct
@@ -138,6 +142,10 @@ static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
     atom_ok = enif_make_atom(env,"ok");
     atom_join = enif_make_atom(env,"join");
     atom_binary_resource_type = enif_make_atom(env,"binary_resource_type");
+    atom_seconds = enif_make_atom(env,"seconds");
+    atom_milli_seconds = enif_make_atom(env,"milli_seconds");
+    atom_micro_seconds = enif_make_atom(env,"micro_seconds");
+    atom_nano_seconds = enif_make_atom(env,"nano_seconds");
 
     *priv_data = data;
     return 0;
@@ -1885,6 +1893,87 @@ static ERL_NIF_TERM sorted_list_from_maps_nif(ErlNifEnv* env, int argc, const ER
     return enif_make_tuple2(env, list_f, list_b);
 }
 
+
+static ERL_NIF_TERM monotonic_time(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifTimeUnit time_unit;
+
+    if (argc != 1)
+	return atom_false;
+
+    if (enif_compare(argv[0], atom_seconds) == 0)
+	time_unit = ERL_NIF_SEC;
+    else if (enif_compare(argv[0], atom_milli_seconds) == 0)
+	time_unit = ERL_NIF_MSEC;
+    else if (enif_compare(argv[0], atom_micro_seconds) == 0)
+	time_unit = ERL_NIF_USEC;
+    else if (enif_compare(argv[0], atom_nano_seconds) == 0)
+	time_unit = ERL_NIF_NSEC;
+    else
+	time_unit = 4711; /* invalid time unit */
+
+    return enif_make_int64(env, enif_monotonic_time(time_unit));
+}
+
+static ERL_NIF_TERM time_offset(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifTimeUnit time_unit;
+
+    if (argc != 1)
+	return atom_false;
+
+    if (enif_compare(argv[0], atom_seconds) == 0)
+	time_unit = ERL_NIF_SEC;
+    else if (enif_compare(argv[0], atom_milli_seconds) == 0)
+	time_unit = ERL_NIF_MSEC;
+    else if (enif_compare(argv[0], atom_micro_seconds) == 0)
+	time_unit = ERL_NIF_USEC;
+    else if (enif_compare(argv[0], atom_nano_seconds) == 0)
+	time_unit = ERL_NIF_NSEC;
+    else
+	time_unit = 4711; /* invalid time unit */
+    return enif_make_int64(env, enif_time_offset(time_unit));
+}
+
+static ERL_NIF_TERM convert_time_unit(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifSInt64 i64;
+    ErlNifTime val;
+    ErlNifTimeUnit from, to;
+
+    if (argc != 3)
+	return atom_false;
+
+    if (!enif_get_int64(env, argv[0], &i64))
+	return enif_make_badarg(env);
+
+    val = (ErlNifTime) i64;
+
+    if (enif_compare(argv[1], atom_seconds) == 0)
+	from = ERL_NIF_SEC;
+    else if (enif_compare(argv[1], atom_milli_seconds) == 0)
+	from = ERL_NIF_MSEC;
+    else if (enif_compare(argv[1], atom_micro_seconds) == 0)
+	from = ERL_NIF_USEC;
+    else if (enif_compare(argv[1], atom_nano_seconds) == 0)
+	from = ERL_NIF_NSEC;
+    else
+	from = 4711; /* invalid time unit */
+
+    if (enif_compare(argv[2], atom_seconds) == 0)
+	to = ERL_NIF_SEC;
+    else if (enif_compare(argv[2], atom_milli_seconds) == 0)
+	to = ERL_NIF_MSEC;
+    else if (enif_compare(argv[2], atom_micro_seconds) == 0)
+	to = ERL_NIF_USEC;
+    else if (enif_compare(argv[2], atom_nano_seconds) == 0)
+	to = ERL_NIF_NSEC;
+    else
+	to = 4711; /* invalid time unit */
+
+    return enif_make_int64(env, enif_convert_time_unit(val, from, to));
+}
+
 static ErlNifFunc nif_funcs[] =
 {
     {"lib_version", 0, lib_version},
@@ -1954,7 +2043,10 @@ static ErlNifFunc nif_funcs[] =
     {"make_map_update_nif", 3, make_map_update_nif},
     {"make_map_remove_nif", 2, make_map_remove_nif},
     {"maps_from_list_nif", 1, maps_from_list_nif},
-    {"sorted_list_from_maps_nif", 1, sorted_list_from_maps_nif}
+    {"sorted_list_from_maps_nif", 1, sorted_list_from_maps_nif},
+    {"monotonic_time", 1, monotonic_time},
+    {"time_offset", 1, time_offset},
+    {"convert_time_unit", 3, convert_time_unit}
 };
 
 ERL_NIF_INIT(nif_SUITE,nif_funcs,load,reload,upgrade,unload)