Changes in kernel/generic/src/time/clock.c [25939997:6f7071b] 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.
  *
@@ -59 +58 @@
 #include <ddi/ddi.h>
 #include <arch/cycle.h>
-#include <preemption.h>
 
 /* Pointer to variable with uptime */
@@ -66 +64 @@
 /** 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
@@ -104 +109 @@
  *
  * Update it only on first processor
- */
-static void clock_update_counters(uint64_t current_tick)
+ * TODO: Do we really need so many write barriers?
+ *
+ */
+static void clock_update_counters(void)
 {
         if (CPU->id == 0) {
-                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;
+                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;
         }
 }
@@ -123 +130 @@
 static void cpu_update_accounting(void)
 {
-        // FIXME: get_cycle() is unimplemented on several platforms
+        irq_spinlock_lock(&CPU->lock, false);
         uint64_t now = get_cycle();
-        atomic_time_increment(&CPU->busy_cycles, now - CPU_LOCAL->last_cycle);
-        CPU_LOCAL->last_cycle = now;
+        CPU->busy_cycles += now - CPU->last_cycle;
+        CPU->last_cycle = now;
+        irq_spinlock_unlock(&CPU->lock, false);
 }
 
@@ -138 +146 @@
 void clock(void)
 {
-        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);
+        size_t missed_clock_ticks = CPU->missed_clock_ticks;
 
         /* Account CPU usage */
@@ -153 +156 @@
          *
          */
-
-        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;
+        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);
+
+                        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);
                 }
 
-                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);
         }
-
-        irq_spinlock_unlock(&CPU->timeoutlock, false);
+        CPU->missed_clock_ticks = 0;
 
         /*
@@ -187 +198 @@
 
         if (THREAD) {
-                if (current_clock_tick >= CPU_LOCAL->preempt_deadline && PREEMPTION_ENABLED) {
-                        thread_yield();
+                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();
 #ifdef CONFIG_UDEBUG
                         /*