Changes in kernel/generic/src/time/clock.c [6f7071b:25939997] in mainline

File:

• kernel/generic/src/time/clock.c (modified) (8 diffs)

kernel/generic/src/time/clock.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2001-2004 Jakub Jermar
+ * Copyright (c) 2022 Jiří Zárevúcky
  * All rights reserved.
  *
@@ -58 +59 @@
 #include <ddi/ddi.h>
 #include <arch/cycle.h>
+#include <preemption.h>
 
 /* Pointer to variable with uptime */
@@ -64 +66 @@
 /** Physical memory area of the real time clock */
 static parea_t clock_parea;
-
-/** Fragment of second
- *
- * For updating  seconds correctly.
- *
- */
-static sysarg_t secfrag = 0;
 
 /** Initialize realtime clock counter
@@ -109 +104 @@
  *
  * Update it only on first processor
- * TODO: Do we really need so many write barriers?
- *
- */
-static void clock_update_counters(void)
+ */
+static void clock_update_counters(uint64_t current_tick)
 {
         if (CPU->id == 0) {
-                secfrag += 1000000 / HZ;
-                if (secfrag >= 1000000) {
-                        secfrag -= 1000000;
-                        uptime->seconds1++;
-                        write_barrier();
-                        uptime->useconds = secfrag;
-                        write_barrier();
-                        uptime->seconds2 = uptime->seconds1;
-                } else
-                        uptime->useconds += 1000000 / HZ;
+                uint64_t usec = (1000000 / HZ) * current_tick;
+
+                sysarg_t secs = usec / 1000000;
+                sysarg_t usecs = usec % 1000000;
+
+                uptime->seconds1 = secs;
+                write_barrier();
+                uptime->useconds = usecs;
+                write_barrier();
+                uptime->seconds2 = secs;
         }
 }
@@ -130 +123 @@
 static void cpu_update_accounting(void)
 {
-        irq_spinlock_lock(&CPU->lock, false);
+        // FIXME: get_cycle() is unimplemented on several platforms
         uint64_t now = get_cycle();
-        CPU->busy_cycles += now - CPU->last_cycle;
-        CPU->last_cycle = now;
-        irq_spinlock_unlock(&CPU->lock, false);
+        atomic_time_increment(&CPU->busy_cycles, now - CPU_LOCAL->last_cycle);
+        CPU_LOCAL->last_cycle = now;
 }
 
@@ -146 +138 @@
 void clock(void)
 {
-        size_t missed_clock_ticks = CPU->missed_clock_ticks;
+        size_t missed_clock_ticks = CPU_LOCAL->missed_clock_ticks;
+        CPU_LOCAL->missed_clock_ticks = 0;
+
+        CPU_LOCAL->current_clock_tick += missed_clock_ticks + 1;
+        uint64_t current_clock_tick = CPU_LOCAL->current_clock_tick;
+        clock_update_counters(current_clock_tick);
 
         /* Account CPU usage */
@@ -156 +153 @@
          *
          */
-        size_t i;
-        for (i = 0; i <= missed_clock_ticks; i++) {
-                /* Update counters and accounting */
-                clock_update_counters();
-                cpu_update_accounting();
+
+        irq_spinlock_lock(&CPU->timeoutlock, false);
+
+        link_t *cur;
+        while ((cur = list_first(&CPU->timeout_active_list)) != NULL) {
+                timeout_t *timeout = list_get_instance(cur, timeout_t, link);
+
+                if (current_clock_tick <= timeout->deadline) {
+                        break;
+                }
+
+                list_remove(cur);
+                timeout_handler_t handler = timeout->handler;
+                void *arg = timeout->arg;
+                atomic_bool *finished = &timeout->finished;
+
+                irq_spinlock_unlock(&CPU->timeoutlock, false);
+
+                handler(arg);
+
+                /* Signal that the handler is finished. */
+                atomic_store_explicit(finished, true, memory_order_release);
 
                 irq_spinlock_lock(&CPU->timeoutlock, false);
-
-                link_t *cur;
-                while ((cur = list_first(&CPU->timeout_active_list)) != NULL) {
-                        timeout_t *timeout = list_get_instance(cur, timeout_t,
-                            link);
-
-                        irq_spinlock_lock(&timeout->lock, false);
-                        if (timeout->ticks-- != 0) {
-                                irq_spinlock_unlock(&timeout->lock, false);
-                                break;
-                        }
-
-                        list_remove(cur);
-                        timeout_handler_t handler = timeout->handler;
-                        void *arg = timeout->arg;
-                        timeout_reinitialize(timeout);
-
-                        irq_spinlock_unlock(&timeout->lock, false);
-                        irq_spinlock_unlock(&CPU->timeoutlock, false);
-
-                        handler(arg);
-
-                        irq_spinlock_lock(&CPU->timeoutlock, false);
-                }
-
-                irq_spinlock_unlock(&CPU->timeoutlock, false);
         }
-        CPU->missed_clock_ticks = 0;
+
+        irq_spinlock_unlock(&CPU->timeoutlock, false);
 
         /*
@@ -198 +187 @@
 
         if (THREAD) {
-                uint64_t ticks;
-
-                irq_spinlock_lock(&CPU->lock, false);
-                CPU->needs_relink += 1 + missed_clock_ticks;
-                irq_spinlock_unlock(&CPU->lock, false);
-
-                irq_spinlock_lock(&THREAD->lock, false);
-                if ((ticks = THREAD->ticks)) {
-                        if (ticks >= 1 + missed_clock_ticks)
-                                THREAD->ticks -= 1 + missed_clock_ticks;
-                        else
-                                THREAD->ticks = 0;
-                }
-                irq_spinlock_unlock(&THREAD->lock, false);
-
-                if (ticks == 0 && PREEMPTION_ENABLED) {
-                        scheduler();
+                if (current_clock_tick >= CPU_LOCAL->preempt_deadline && PREEMPTION_ENABLED) {
+                        thread_yield();
 #ifdef CONFIG_UDEBUG
                         /*