Changeset 4760793 in mainline for kernel/generic/src

Timestamp:

2024-01-14T18:23:40Z (19 months ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

master

Children:

5663872, c7ceacf

Parents:

3b68542

Message:

Add CPU_LOCAL alongside CPU and segregate fields that are only used locally

This makes it more clear which fields can be used without synchronization
and which need more care.

Location:

kernel/generic/src

Files:

• cpu/cpu.c (modified) (2 diffs)
• interrupt/interrupt.c (modified) (1 diff)
• main/main.c (modified) (2 diffs)
• proc/scheduler.c (modified) (5 diffs)
• time/clock.c (modified) (3 diffs)
• time/timeout.c (modified) (1 diff)

kernel/generic/src/cpu/cpu.c

@@ -81 +81 @@
                                 panic("Cannot allocate CPU stack.");
 
-                        cpus[i].stack = (uint8_t *) PA2KA(stack_phys);
+                        cpus[i].local.stack = (uint8_t *) PA2KA(stack_phys);
                         cpus[i].id = i;
 
@@ -104 +104 @@
         CPU->tlb_active = true;
 
-        CPU->idle = false;
-        CPU->last_cycle = get_cycle();
+        CPU_LOCAL->idle = false;
+        CPU_LOCAL->last_cycle = get_cycle();
         CPU->idle_cycles = ATOMIC_TIME_INITIALIZER();
         CPU->busy_cycles = ATOMIC_TIME_INITIALIZER();

kernel/generic/src/interrupt/interrupt.c

@@ -121 +121 @@
 
         /* Account CPU usage if it woke up from sleep */
-        if (CPU && CPU->idle) {
+        if (CPU && CPU_LOCAL->idle) {
                 uint64_t now = get_cycle();
-                atomic_time_increment(&CPU->idle_cycles, now - CPU->last_cycle);
-                CPU->last_cycle = now;
-                CPU->idle = false;
+                atomic_time_increment(&CPU->idle_cycles, now - CPU_LOCAL->last_cycle);
+                CPU_LOCAL->last_cycle = now;
+                CPU_LOCAL->idle = false;
         }
 

kernel/generic/src/main/main.c

@@ -328 +328 @@
         ARCH_OP(post_cpu_init);
 
-        current_copy(CURRENT, (current_t *) CPU->stack);
+        current_copy(CURRENT, (current_t *) CPU_LOCAL->stack);
 
         /*
@@ -338 +338 @@
         context_save(&ctx);
         context_set(&ctx, FADDR(main_ap_separated_stack),
-            (uintptr_t) CPU->stack, STACK_SIZE);
+            (uintptr_t) CPU_LOCAL->stack, STACK_SIZE);
         context_restore(&ctx);
         /* not reached */

kernel/generic/src/proc/scheduler.c

@@ -216 +216 @@
 
                 /* This is safe because interrupts are disabled. */
-                CPU->preempt_deadline = CPU->current_clock_tick + us2ticks(time_to_run);
+                CPU_LOCAL->preempt_deadline =
+                    CPU_LOCAL->current_clock_tick + us2ticks(time_to_run);
 
                 /*
@@ -257 +258 @@
                  * This improves energy saving and hyperthreading.
                  */
-                CPU->idle = true;
+                CPU_LOCAL->idle = true;
 
                 /*
@@ -305 +306 @@
 static void relink_rq(int start)
 {
-        if (CPU->current_clock_tick < CPU->relink_deadline)
+        if (CPU_LOCAL->current_clock_tick < CPU_LOCAL->relink_deadline)
                 return;
 
-        CPU->relink_deadline = CPU->current_clock_tick + NEEDS_RELINK_MAX;
+        CPU_LOCAL->relink_deadline = CPU_LOCAL->current_clock_tick + NEEDS_RELINK_MAX;
 
         /* Temporary cache for lists we are moving. */
@@ -401 +402 @@
          *
          */
-        current_copy(CURRENT, (current_t *) CPU->stack);
+        current_copy(CURRENT, (current_t *) CPU_LOCAL->stack);
 
         /*
@@ -419 +420 @@
         context_save(&ctx);
         context_set(&ctx, FADDR(scheduler_separated_stack),
-            (uintptr_t) CPU->stack, STACK_SIZE);
+            (uintptr_t) CPU_LOCAL->stack, STACK_SIZE);
         context_restore(&ctx);
 

kernel/generic/src/time/clock.c

@@ -124 +124 @@
 {
         uint64_t now = get_cycle();
-        atomic_time_increment(&CPU->busy_cycles, now - CPU->last_cycle);
-        CPU->last_cycle = now;
+        atomic_time_increment(&CPU->busy_cycles, now - CPU_LOCAL->last_cycle);
+        CPU_LOCAL->last_cycle = now;
 }
 
@@ -137 +137 @@
 void clock(void)
 {
-        size_t missed_clock_ticks = CPU->missed_clock_ticks;
-        CPU->missed_clock_ticks = 0;
-
-        CPU->current_clock_tick += missed_clock_ticks + 1;
-        uint64_t current_clock_tick = CPU->current_clock_tick;
+        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);
 
@@ -186 +186 @@
 
         if (THREAD) {
-                if (current_clock_tick >= CPU->preempt_deadline && PREEMPTION_ENABLED) {
+                if (current_clock_tick >= CPU_LOCAL->preempt_deadline && PREEMPTION_ENABLED) {
                         scheduler();
 #ifdef CONFIG_UDEBUG

kernel/generic/src/time/timeout.c

@@ -77 +77 @@
                 return 0;
 
-        return CPU->current_clock_tick + us2ticks(usec);
+        return CPU_LOCAL->current_clock_tick + us2ticks(usec);
 }