Improve behavior of interval timers in setitimer (#19638)

Alarm firing can be delayed (i.e. occur after the time it was due).
When this happens the next timer is due 'interval' ms after the
previous scheduled time (which in case of delay is sooner then
'interval' ms after the time it actually fired).

These delays (seen when tests run under load) were causing flakiness
in test_itimer on bots; in particularly the test_sequence test.

There are 2 things that can still go wrong with test_itimer:

1) A single timer event can be delayed long enough to cause test_oneoff
to fail (this happens if the delay is > 100ms in the current version of the
test). I have seen this recently on the bots as well. This PR increases the
sleep time while waiting for the signal, but it could still fail under heavy
load.

2) If a delay in timer firing lasts longer than the interval itself, then
a timer event will be missed entirely. This could also cause the test to
fail.

Author: dschuff

system/lib/libc/musl/src/signal/setitimer.c

@@ -5,9 +5,10 @@
 #define IS32BIT(x) !((x)+0x80000000ULL>>32)
 
 #ifdef __EMSCRIPTEN__
+#include <emscripten/emscripten.h>
 #include <signal.h>
+#include <stdint.h>
 #include <stdio.h>
-#include <emscripten/emscripten.h>
 
 #include "emscripten_internal.h"
 
@@ -37,11 +38,25 @@ void _emscripten_timeout(int which, double now)
 		signum = SIGPROF;
 	else if (which == ITIMER_VIRTUAL)
 		signum = SIGVTALRM;
-	int next_timeout = current_intervals_ms[which];
-	if (next_timeout)
-		current_timeout_ms[which] = now + next_timeout;
-	else
+	double next_timeout = 0.0;
+	if (current_intervals_ms[which]) {
+		// If time went backwards, schedule the next timer as if it didn't.
+		now = __builtin_wasm_max_f64(now, current_timeout_ms[which]);
+		// The next alarm is due 'interval' ms after the previous one.
+		// If this alarm was delayed, that is sooner than 'interval' ms
+		// from now. The delay could even be so long that we missed the
+		// next alarm(s) entirely. Schedule the alarm for the next
+		// multiple of 'interval' ms from the original due time.
+		uint64_t intervals =
+			(uint64_t)(now - current_timeout_ms[which]) /
+			  (uint64_t)current_intervals_ms[which] +
+			1;
+		current_timeout_ms[which] +=
+			intervals * current_intervals_ms[which];
+		next_timeout = current_timeout_ms[which] - now;
+	} else {
 		current_timeout_ms[which] = 0;
+	}
 	_setitimer_js(which, next_timeout);
 	raise(signum);
 }

test/other/test_itimer.c

@@ -28,7 +28,7 @@ void vtalarm_handler(int dummy) {
 }
 
 void prof_handler(int dummy) {
-  printf("Received SIGVTALRM!\n");
+  printf("Received SIGPROF!\n");
   got_alarm[ITIMER_PROF]++;
 }
 
@@ -46,7 +46,7 @@ void test_oneoff(int which) {
 
   rtn = getitimer(which, &val);
   assert(rtn == 0);
-  printf("ms remainging: %d\n", val.it_value.tv_usec / 1000);
+  printf("ms remaining: %d\n", val.it_value.tv_usec / 1000);
   assert(val.it_value.tv_usec || val.it_value.tv_sec);
 
   // Wait 100ms
@@ -55,13 +55,13 @@ void test_oneoff(int which) {
   // Verify less time remains
   rtn = getitimer(which, &val);
   assert(rtn == 0);
-  printf("ms remainging: %d\n", val.it_value.tv_usec / 1000);
+  printf("ms remaining: %d\n", val.it_value.tv_usec / 1000);
   assert(val.it_value.tv_sec == 0);
   assert(val.it_value.tv_usec > 0);
 
-  // Wait 1s
+  // Wait 1.5s
   assert(!got_alarm[which]);
-  usleep(1000 * 1000);
+  usleep(1500 * 1000);
 
   // Verify that the time fired and is no longer active
   assert(got_alarm[which]);