Scale frequency to suppress RCU CPU stall warning

Makefile

@@ -78,6 +78,8 @@ E :=
 S := $E $E
 
 SMP ?= 1
+CFLAGS += -D SEMU_SMP=$(SMP)
+CFLAGS += -D SEMU_BOOT_TARGET_TIME=10
 .PHONY: riscv-harts.dtsi
 riscv-harts.dtsi:
 	$(Q)python3 scripts/gen-hart-dts.py $@ $(SMP) $(CLOCK_FREQ)

riscv.c

@@ -382,6 +382,14 @@ static void op_sret(hart_t *vm)
     vm->s_mode = vm->sstatus_spp;
     vm->sstatus_sie = vm->sstatus_spie;
 
+    /* After the booting process is complete, initrd will be loaded. At this
+     * point, the sytstem will switch to U mode for the first time. Therefore,
+     * by checking whether the switch to U mode has already occurred, we can
+     * determine if the boot process has been completed.
+     */
+    if (!boot_complete && !vm->s_mode)
+        boot_complete = true;
+
     /* Reset stack */
     vm->sstatus_spp = false;
     vm->sstatus_spie = true;

utils.c

@@ -19,48 +19,156 @@
 #endif
 #endif
 
+#ifndef SEMU_SMP
+#define SEMU_SMP 1
+#endif
+
+#ifndef SEMU_BOOT_TARGET_TIME
+#define SEMU_BOOT_TARGET_TIME 10
+#endif
+
+bool boot_complete = false;
+static double scale_factor;
+
 /* Calculate "x * n / d" without unnecessary overflow or loss of precision.
  *
  * Reference:
  * https://elixir.bootlin.com/linux/v6.10.7/source/include/linux/math.h#L121
  */
-static inline uint64_t mult_frac(uint64_t x, uint64_t n, uint64_t d)
+static inline uint64_t mult_frac(uint64_t x, double n, uint64_t d)
 {
     const uint64_t q = x / d;
     const uint64_t r = x % d;
 
     return q * n + r * n / d;
 }
 
+/* Use timespec and frequency to calculate how many ticks to increment. For
+ * example, if the frequency is set to 65,000,000, then there are 65,000,000
+ * ticks per second. Respectively, if the time is set to 1 second, then there
+ * are 65,000,000 ticks.
+ *
+ * Thus, by seconds * frequency + nanoseconds * frequency / 1,000,000,000, we
+ * can get the number of ticks.
+ */
+static inline uint64_t get_ticks(struct timespec *ts, double freq)
+{
+    return ts->tv_sec * freq + mult_frac(ts->tv_nsec, freq, 1000000000ULL);
+}
+
+/* Measure how long it takes for the high resolution timer to update once, to
+ * scale real time in order to set the emulator time.
+ */
+static void measure_bogomips_ns(uint64_t target_loop)
+{
+    struct timespec start, end;
+    clock_gettime(CLOCKID, &start);
+
+    for (uint64_t loops = 0; loops < target_loop; loops++)
+        clock_gettime(CLOCKID, &end);
+
+    int64_t sec_diff = end.tv_sec - start.tv_sec;
+    int64_t nsec_diff = end.tv_nsec - start.tv_nsec;
+    double ns_per_call = (sec_diff * 1e9 + nsec_diff) / target_loop;
+
+    /* Based on simple statistics, 'semu_timer_clocksource' accounts for
+     * approximately 10% of the boot process execution time. Since the logic
+     * inside 'semu_timer_clocksource' is relatively simple, it can be assumed
+     * that its execution time is roughly equivalent to that of a
+     * 'clock_gettime' call.
+     *
+     * Similarly, based on statistics, 'semu_timer_clocksource' is called
+     * approximately 2*1e8 times. Therefore, we can roughly estimate that the
+     * boot process will take '(ns_per_call/1e9) * SEMU_SMP * 2 * 1e8 *
+     * (100%/10%)' seconds.
+     */
+    double predict_sec = ns_per_call * SEMU_SMP * 2;
+    scale_factor = SEMU_BOOT_TARGET_TIME / predict_sec;
+}
+
 void semu_timer_init(semu_timer_t *timer, uint64_t freq)
 {
+    measure_bogomips_ns(freq); /* Measure the time taken by 'clock_gettime' */
+
     timer->freq = freq;
     semu_timer_rebase(timer, 0);
 }
 
-static uint64_t semu_timer_clocksource(uint64_t freq)
+static uint64_t semu_timer_clocksource(semu_timer_t *timer)
 {
+    /* After boot process complete, the timer will switch to real time. Thus,
+     * there is an offset between the real time and the emulator time.
+     *
+     * After switching to real time, the correct way to update time is to
+     * calculate the increment of time. Then add it to the emulator time.
+     */
+    static int64_t offset = 0;
+    static bool first_switch = true;
+
 #if defined(HAVE_POSIX_TIMER)
-    struct timespec t;
-    clock_gettime(CLOCKID, &t);
-    return t.tv_sec * freq + mult_frac(t.tv_nsec, freq, 1e9);
+    struct timespec emulator_time;
+    clock_gettime(CLOCKID, &emulator_time);
+
+    if (!boot_complete)
+        return get_ticks(&emulator_time, timer->freq * scale_factor);
+
+    if (first_switch) {
+        first_switch = false;
+        uint64_t real_ticks = get_ticks(&emulator_time, timer->freq);
+        uint64_t scaled_ticks =
+            get_ticks(&emulator_time, timer->freq * scale_factor);
+
+        offset = (int64_t) (real_ticks - scaled_ticks);
+    }
+
+    uint64_t real_freq_ticks = get_ticks(&emulator_time, timer->freq);
+    return real_freq_ticks - offset;
 #elif defined(HAVE_MACH_TIMER)
-    static mach_timebase_info_data_t t;
-    if (t.denom == 0)
-        (void) mach_timebase_info(&t);
-    return mult_frac(mult_frac(mach_absolute_time(), t.numer, t.denom), freq,
-                     1e9);
+    static mach_timebase_info_data_t emulator_time;
+    if (emulator_time.denom == 0)
+        (void) mach_timebase_info(&emulator_time);
+
+    uint64_t now = mach_absolute_time();
+    uint64_t ns = mult_frac(now, emulator_time.numer, emulator_time.denom);
+    if (!boot_complete)
+        return mult_frac(ns, (uint64_t) (timer->freq * scale_factor),
+                         1000000000ULL);
+
+    if (first_switch) {
+        first_switch = false;
+        uint64_t real_ticks = mult_frac(ns, timer->freq, 1000000000ULL);
+        uint64_t scaled_ticks = mult_frac(
+            ns, (uint64_t) (timer->freq * scale_factor), 1000000000ULL);
+        offset = (int64_t) (real_ticks - scaled_ticks);
+    }
+
+    uint64_t real_freq_ticks = mult_frac(ns, timer->freq, 1000000000ULL);
+    return real_freq_ticks - offset;
 #else
-    return time(0) * freq;
+    time_t now_sec = time(0);
+
+    if (!boot_complete)
+        return ((uint64_t) now_sec) * (uint64_t) (timer->freq * scale_factor);
+
+    if (first_switch) {
+        first_switch = false;
+        uint64_t real_val = ((uint64_t) now_sec) * (uint64_t) (timer->freq);
+        uint64_t scaled_val =
+            ((uint64_t) now_sec) * (uint64_t) (timer->freq * scale_factor);
+        offset = (int64_t) real_val - (int64_t) scaled_val;
+    }
+
+    uint64_t real_freq_val = ((uint64_t) now_sec) * (uint64_t) (timer->freq);
+    return real_freq_val - offset;
 #endif
 }
 
 uint64_t semu_timer_get(semu_timer_t *timer)
 {
-    return semu_timer_clocksource(timer->freq) - timer->begin;
+    return semu_timer_clocksource(timer) - timer->begin;
 }
 
 void semu_timer_rebase(semu_timer_t *timer, uint64_t time)
 {
-    timer->begin = semu_timer_clocksource(timer->freq) - time;
+    timer->begin = semu_timer_clocksource(timer) - time;
 }

utils.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <stdbool.h>
 #include <stdint.h>
 
 /* TIMER */
@@ -8,6 +9,8 @@ typedef struct {
     uint64_t freq;
 } semu_timer_t;
 
+extern bool boot_complete; /* complete boot process and get in initrd */
+
 void semu_timer_init(semu_timer_t *timer, uint64_t freq);
 uint64_t semu_timer_get(semu_timer_t *timer);
-void semu_timer_rebase(semu_timer_t *timer, uint64_t time);
+void semu_timer_rebase(semu_timer_t *timer, uint64_t time);