File 8213-erts-configure-option-for-ensuring-monoton... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 8213-erts-configure-option-for-ensuring-monotonicity-of-O.patch of Package erlang (Revision b4f72044e1af8cfe32130ab849a401a1)

Currently displaying revision b4f72044e1af8cfe32130ab849a401a1 , Show latest

From 9ba3b326e5f3a25faa977f73314d1481fbdd7805 Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Tue, 26 Mar 2024 17:52:12 +0100
Subject: [PATCH 3/3] [erts] configure option for ensuring monotonicity of OS
 monotonic time

diff --git a/HOWTO/INSTALL.md b/HOWTO/INSTALL.md
index e7fb4ad27a..3c634f769a 100644
--- a/HOWTO/INSTALL.md
+++ b/HOWTO/INSTALL.md
@@ -420,6 +420,14 @@ Some of the available `configure` options are:
     time, and OS monotonic time with higher or lower resolution than chosen by
     default. Note that both alternatives may have a negative impact on the performance
     and scalability compared to the default clock sources chosen.
+*   `--enable-ensure-os-monotonic-time` - Enable functionality ensuring the
+    monotonicity of monotonic timestamps delivered by the OS. When a
+    non-monotonic timestamp is detected, it will be replaced by the last
+    delivered monotonic timestamp before being used by Erlang's time
+    functionality. Note that you do *not* want to enable this unless the OS
+    monotonic time source on the system fails to produce monotonic timestamps.
+    This since ensuring the monotonicity of OS monotonic timestamps will hurt
+    scalability and performance of the system.
 *   `--disable-saved-compile-time` - Disable saving of compile date and time
     in the emulator binary.
 *   `--enable-ei-dynamic-lib` - Make erl\_interface build a shared library in addition
diff --git a/erts/config.h.in b/erts/config.h.in
index 8295b90410..4e0cd90e60 100644
--- a/erts/config.h.in
+++ b/erts/config.h.in
@@ -51,6 +51,10 @@
 /* Define > 0 if big-endian < 0 if little-endian, or 0 if unknown */
 #undef ERTS_ENDIANNESS
 
+/* Define if ensurance of the monotonicity of OS monotonic timestamps should
+   be enabled */
+#undef ERTS_ENSURE_OS_MONOTONIC_TIME
+
 /* Define if OS monotonic clock is corrected */
 #undef ERTS_HAVE_CORRECTED_OS_MONOTONIC_TIME
 
diff --git a/erts/configure b/erts/configure
index 7da8d32a1b..312ed0b5a1 100755
--- a/erts/configure
+++ b/erts/configure
@@ -812,6 +812,7 @@ enable_vm_probes
 with_assumed_cache_line_size
 enable_systemd
 with_microstate_accounting
+enable_ensure_os_monotonic_time
 enable_static_nifs
 enable_static_drivers
 with_ets_write_concurrency_locks
@@ -1525,6 +1526,17 @@ Optional Features:
                           possible if --with-dynamic-trace is enabled, and
                           then default)
   --enable-systemd        enable systemd support in epmd
+  --enable-ensure-os-monotonic-time
+                          enable functionality ensuring the monotonicity of
+                          monotonic timestamps delivered by the OS. When a
+                          non-monotonic timestamp is detected, it will be
+                          replaced by the last delivered monotonic timestamp
+                          before being used by Erlang's time functionality.
+                          Note that you do *not* want to enable this unless
+                          the OS monotonic time source on the system fails to
+                          produce monotonic timestamps. This since ensuring
+                          the monotonicity of OS monotonic timestamps will
+                          hurt scalability and performance of the system.
   --disable-saved-compile-time
                           disable saved compile time
   --enable-static-nifs    link nifs statically. If yes then all nifs in all
@@ -4193,6 +4205,20 @@ $as_echo "#define ERTS_ENABLE_MSACC 2" >>confdefs.h
     *) ;;
 esac
 
+# Check whether --enable-ensure-os-monotonic-time was given.
+if test "${enable_ensure_os_monotonic_time+set}" = set; then :
+  enableval=$enable_ensure_os_monotonic_time;
+fi
+
+
+if test "$enable_ensure_os_monotonic_time" = "yes"; then :
+
+
+$as_echo "#define ERTS_ENSURE_OS_MONOTONIC_TIME 1" >>confdefs.h
+
+
+fi
+
 OTP_RELEASE=
 if test "${ERLANG_COMMERCIAL_BUILD}" != ""; then
 	OTP_EXTRA_FLAGS=-DOTP_RELEASE
diff --git a/erts/configure.in b/erts/configure.in
index beff4275f8..fecf9c901f 100644
--- a/erts/configure.in
+++ b/erts/configure.in
@@ -309,6 +309,15 @@ case "$with_microstate_accounting" in
     *) ;;
 esac
 
+AC_ARG_ENABLE(ensure-os-monotonic-time,
+AS_HELP_STRING([--enable-ensure-os-monotonic-time],
+               [enable functionality ensuring the monotonicity of monotonic timestamps delivered by the OS. When a non-monotonic timestamp is detected, it will be replaced by the last delivered monotonic timestamp before being used by Erlang's time functionality. Note that you do *not* want to enable this unless the OS monotonic time source on the system fails to produce monotonic timestamps. This since ensuring the monotonicity of OS monotonic timestamps will hurt scalability and performance of the system.]))
+
+AS_IF([test "$enable_ensure_os_monotonic_time" = "yes"], [
+   AC_DEFINE(ERTS_ENSURE_OS_MONOTONIC_TIME, [1],
+     [Define if ensurance of the monotonicity of OS monotonic timestamps should be enabled])
+  ])
+
 dnl Magic test for clearcase.
 OTP_RELEASE=
 if test "${ERLANG_COMMERCIAL_BUILD}" != ""; then
diff --git a/erts/emulator/beam/erl_lock_check.c b/erts/emulator/beam/erl_lock_check.c
index db1e6e0e66..c16748d7c5 100644
--- a/erts/emulator/beam/erl_lock_check.c
+++ b/erts/emulator/beam/erl_lock_check.c
@@ -163,7 +163,10 @@ static erts_lc_lock_order_t erts_lock_order[] = {
     {	"os_monotonic_time",			NULL			},
     {	"erts_alloc_hard_debug",		NULL			},
     {	"hard_dbg_mseg",		        NULL	                },
-    {	"erts_mmap",				NULL			}
+    {	"erts_mmap",				NULL			},
+#ifdef ERTS_ENSURE_OS_MONOTONIC_TIME
+    {   "ensure_os_monotonic_time",             NULL                    }
+#endif
 };
 
 #define ERTS_LOCK_ORDER_SIZE \
diff --git a/erts/emulator/beam/erl_time_sup.c b/erts/emulator/beam/erl_time_sup.c
index 5c5ab22172..2faf663157 100644
--- a/erts/emulator/beam/erl_time_sup.c
+++ b/erts/emulator/beam/erl_time_sup.c
@@ -36,7 +36,7 @@
 #include "erl_driver.h"
 #include "erl_nif.h"
 #include "erl_proc_sig_queue.h"
- 
+
 static erts_mtx_t erts_get_time_mtx;
 
  /* used by erts_runtime_elapsed_both */
@@ -173,6 +173,10 @@ struct time_sup_infrequently_changed__ {
 
 struct time_sup_frequently_changed__ {
     ErtsMonotonicTime last_not_corrected_time;
+#ifdef ERTS_ENSURE_OS_MONOTONIC_TIME
+    erts_mtx_t mtime_mtx;
+    ErtsMonotonicTime last_delivered_mtime;
+#endif
 };
 
 static struct {
@@ -210,6 +214,49 @@ get_time_offset(void)
     return (ErtsMonotonicTime) erts_atomic64_read_acqb(&time_sup.inf.c.offset);
 }
 
+#if !defined(ERTS_ENSURE_OS_MONOTONIC_TIME)
+
+static ERTS_INLINE ErtsMonotonicTime
+os_monotonic_time(void)
+{
+    return erts_os_monotonic_time();
+}
+
+static ERTS_INLINE void
+os_times(ErtsMonotonicTime *mtimep, ErtsSystemTime *stimep)
+{
+    erts_os_times(mtimep, stimep);
+}
+
+#else /* defined(ERTS_ENSURE_OS_MONOTONIC_TIME) */
+
+static ERTS_INLINE ErtsMonotonicTime
+verify_os_monotonic_time(ErtsMonotonicTime mtime)
+{
+    erts_mtx_lock(&time_sup.f.c.mtime_mtx);
+    if (mtime < time_sup.f.c.last_delivered_mtime)
+        mtime = time_sup.f.c.last_delivered_mtime;
+    else
+        time_sup.f.c.last_delivered_mtime = mtime;
+    erts_mtx_unlock(&time_sup.f.c.mtime_mtx);
+    return mtime;
+}
+
+static ERTS_INLINE ErtsMonotonicTime
+os_monotonic_time(void)
+{
+    return verify_os_monotonic_time(erts_os_monotonic_time());
+}
+
+static ERTS_INLINE void
+os_times(ErtsMonotonicTime *mtimep, ErtsSystemTime *stimep)
+{
+    erts_os_times(mtimep, stimep);
+    *mtimep = verify_os_monotonic_time(*mtimep);
+}
+
+#endif
+
 static ERTS_INLINE void
 update_last_mtime(ErtsSchedulerData *esdp, ErtsMonotonicTime mtime)
 {
@@ -250,7 +297,6 @@ check_os_monotonic_time(ErtsSchedulerData *esdp, ErtsMonotonicTime mtime)
 #endif
 }
 
-
 #ifdef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
 
 /*
@@ -319,7 +365,7 @@ read_corrected_time(int os_drift_corrected, ErtsSchedulerData *esdp)
 
     erts_rwmtx_rlock(&time_sup.inf.c.parmon.rwmtx);
 
-    os_mtime = erts_os_monotonic_time();
+    os_mtime = os_monotonic_time();
 
     if (os_mtime >= time_sup.inf.c.parmon.cdata.insts.curr.os_mtime)
 	ci = time_sup.inf.c.parmon.cdata.insts.curr;
@@ -415,7 +461,7 @@ check_time_correction(void *vesdp)
 
     erts_rwmtx_rlock(&time_sup.inf.c.parmon.rwmtx);
 
-    erts_os_times(&os_mtime, &os_stime);
+    os_times(&os_mtime, &os_stime);
 
     ci = time_sup.inf.c.parmon.cdata.insts.curr;
 
@@ -684,9 +730,11 @@ check_time_correction(void *vesdp)
 #endif
 
     if (set_new_correction) {
+        ErtsMonotonicTime cstart_os_mtime;
+
 	erts_rwmtx_rwlock(&time_sup.inf.c.parmon.rwmtx);
 
-	os_mtime = erts_os_monotonic_time();
+	os_mtime = os_monotonic_time();
 
 	/* Save previous correction instance */
 	time_sup.inf.c.parmon.cdata.insts.prev = ci;
@@ -695,21 +743,21 @@ check_time_correction(void *vesdp)
 	 * Current correction instance begin when
 	 * OS monotonic time has increased two units.
 	 */
-	os_mtime += 2;
+	cstart_os_mtime = os_mtime + 2;
 
 	/*
 	 * Erlang monotonic time corresponding to
 	 * next OS monotonic time using previous
 	 * correction.
 	 */
-	erl_mtime = calc_corrected_erl_mtime(os_mtime, &ci, NULL,
+	erl_mtime = calc_corrected_erl_mtime(cstart_os_mtime, &ci, NULL,
 					     os_drift_corrected);
 
 	/*
 	 * Save new current correction instance.
 	 */
 	time_sup.inf.c.parmon.cdata.insts.curr.erl_mtime = erl_mtime;
-	time_sup.inf.c.parmon.cdata.insts.curr.os_mtime = os_mtime;
+	time_sup.inf.c.parmon.cdata.insts.curr.os_mtime = cstart_os_mtime;
 	time_sup.inf.c.parmon.cdata.insts.curr.correction = new_correction;
 
 	erts_rwmtx_rwunlock(&time_sup.inf.c.parmon.rwmtx);
@@ -728,7 +776,7 @@ static ErtsMonotonicTime get_os_corrected_time(ErtsSchedulerData *esdp)
 {
     ErtsMonotonicTime os_mtime;
     ASSERT(time_sup.r.o.warp_mode == ERTS_MULTI_TIME_WARP_MODE);
-    os_mtime = erts_os_monotonic_time();
+    os_mtime = os_monotonic_time();
     check_os_monotonic_time(esdp, os_mtime);
     return os_mtime + time_sup.r.o.moffset;
 }
@@ -742,7 +790,7 @@ check_time_offset(void *vesdp)
 
     ASSERT(time_sup.r.o.warp_mode == ERTS_MULTI_TIME_WARP_MODE);
 
-    erts_os_times(&os_mtime, &os_stime);
+    os_times(&os_mtime, &os_stime);
 
     check_os_monotonic_time(esdp, os_mtime);
 
@@ -792,7 +840,7 @@ init_check_time_correction(void *vesdp)
     old_mtime = ddp->intervals[0].time.mon;
     old_stime = ddp->intervals[0].time.sys;
 
-    erts_os_times(&mtime, &stime);
+    os_times(&mtime, &stime);
 
     check_os_monotonic_time((!vesdp
                              ? erts_get_scheduler_data()
@@ -841,7 +889,7 @@ finalize_corrected_time_offset(ErtsSystemTime *stimep)
 
     erts_rwmtx_rlock(&time_sup.inf.c.parmon.rwmtx);
 
-    erts_os_times(&os_mtime, stimep);
+    os_times(&os_mtime, stimep);
 
     ci = time_sup.inf.c.parmon.cdata.insts.curr;
 
@@ -1015,6 +1063,17 @@ erts_init_time_sup(int time_correction, ErtsTimeWarpMode time_warp_mode)
     runtime_prev.data.user = 0;
     runtime_prev.data.sys = 0;
 
+#ifdef ERTS_ENSURE_OS_MONOTONIC_TIME
+    if (!time_sup.r.o.os_monotonic_time_disable) {
+        time_sup.r.o.os_corrected_monotonic_time = 0; /* we don't trust it... */
+        time_sup.r.o.os_monotonic_time_locked = !0;
+        erts_mtx_init(&time_sup.f.c.mtime_mtx, "ensure_os_monotonic_time",
+                      NIL, (ERTS_LOCK_FLAGS_PROPERTY_STATIC
+                            | ERTS_LOCK_FLAGS_CATEGORY_GENERIC));
+        time_sup.f.c.last_delivered_mtime = erts_os_monotonic_time();
+    }
+#endif
+
     time_sup.r.o.correction = time_correction;
     time_sup.r.o.warp_mode = time_warp_mode;
  
@@ -1167,7 +1226,7 @@ erts_init_time_sup(int time_correction, ErtsTimeWarpMode time_warp_mode)
 	ErtsMonotonicCorrectionData *cdatap;
 	erts_rwmtx_opt_t rwmtx_opts = ERTS_RWMTX_OPT_DEFAULT_INITER;
 	ErtsMonotonicTime offset;
-        erts_os_times(&time_sup.inf.c.minit, &time_sup.inf.c.sinit);
+        os_times(&time_sup.inf.c.minit, &time_sup.inf.c.sinit);
 	time_sup.r.o.moffset = -1*time_sup.inf.c.minit;
 	time_sup.r.o.moffset += ERTS_MONOTONIC_BEGIN;
 	offset = time_sup.inf.c.sinit;
@@ -2136,7 +2195,7 @@ erts_monotonic_time_source(struct process *c_p)
     Sint64 os_mtime = 0;
 #ifdef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
     if (!time_sup.r.o.os_monotonic_time_disable)
-	os_mtime = (Sint64) erts_os_monotonic_time();
+	os_mtime = (Sint64) os_monotonic_time();
 #endif
 
     bld_monotonic_time_source(NULL, &hsz, os_mtime);
diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h
index 1ffc7f5028..f9731f5396 100644
--- a/erts/emulator/beam/sys.h
+++ b/erts/emulator/beam/sys.h
@@ -720,6 +720,10 @@ extern char *erts_default_arg0;
 
 extern char os_type[];
 
+#if !defined(ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT)
+#  undef ERTS_ENSURE_OS_MONOTONIC_TIME
+#endif
+
 typedef struct {
     int have_os_monotonic_time;
     int have_corrected_os_monotonic_time;
diff --git a/make/configure b/make/configure
index c44049816c..c241dafa4e 100755
--- a/make/configure
+++ b/make/configure
@@ -767,6 +767,7 @@ enable_m64_build
 enable_m32_build
 enable_pie
 with_libatomic_ops
+enable_ensure_os_monotonic_time
 enable_sanitizers
 enable_silent_rules
 '
@@ -1473,6 +1474,17 @@ Optional Features:
   --enable-m32-build      build 32bit binaries using the -m32 flag to (g)cc
   --enable-pie            build position independent executables
   --disable-pie           do no build position independent executables
+  --enable-ensure-os-monotonic-time
+                          enable functionality ensuring the monotonicity of
+                          monotonic timestamps delivered by the OS. When a
+                          non-monotonic timestamp is detected, it will be
+                          replaced by the last delivered monotonic timestamp
+                          before being used by Erlang's time functionality.
+                          Note that you do *not* want to enable this unless
+                          the OS monotonic time source on the system fails to
+                          produce monotonic timestamps. This since ensuring
+                          the monotonicity of OS monotonic timestamps will
+                          hurt scalability and performance of the system.
   --enable-sanitizers[=comma-separated list of sanitizers]
                           Default=address,undefined
   --enable-silent-rules   less verbose build output (undo: "make V=1")
@@ -4650,6 +4662,12 @@ if test "${with_libatomic_ops+set}" = set; then :
 fi
 
 
+# Check whether --enable-ensure-os-monotonic-time was given.
+if test "${enable_ensure_os_monotonic_time+set}" = set; then :
+  enableval=$enable_ensure_os_monotonic_time;
+fi
+
+
 
 # Check whether --enable-sanitizers was given.
 if test "${enable_sanitizers+set}" = set; then :
diff --git a/make/configure.in b/make/configure.in
index 660c51e363..83a24f12b6 100644
--- a/make/configure.in
+++ b/make/configure.in
@@ -368,6 +368,10 @@ AC_ARG_WITH(libatomic_ops,
 	    AS_HELP_STRING([--with-libatomic_ops=PATH],
 			   [specify and prefer usage of libatomic_ops in the ethread library]))
 
+AC_ARG_ENABLE(ensure-os-monotonic-time,
+AS_HELP_STRING([--enable-ensure-os-monotonic-time],
+               [enable functionality ensuring the monotonicity of monotonic timestamps delivered by the OS. When a non-monotonic timestamp is detected, it will be replaced by the last delivered monotonic timestamp before being used by Erlang's time functionality. Note that you do *not* want to enable this unless the OS monotonic time source on the system fails to produce monotonic timestamps. This since ensuring the monotonicity of OS monotonic timestamps will hurt scalability and performance of the system.]))
+
 m4_define(DEFAULT_SANITIZERS, [address,undefined])
 AC_ARG_ENABLE(sanitizers,
     AS_HELP_STRING(
-- 
2.35.3

Places

File 8213-erts-configure-option-for-ensuring-monotonicity-of-O.patch of Package erlang (Revision b4f72044e1af8cfe32130ab849a401a1)

Places