Changeset 25939997 in mainline

Timestamp:

2024-01-19T16:21:20Z (10 months ago)

Author:

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

Branches:

master

Children:

c1eaec4

Parents:

1c1767f

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2023-04-16 19:36:25)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2024-01-19 16:21:20)

Message:

Make separate-stack-scheduler a loop with persistent context

We can see scheduler as a looping idle thread in which a thread
is repeatedly retrieved from a queue, prepared, switched to,
returned from, and cleaned up after.

IMO this is a more natural view of the process.

Location:

kernel/generic

Files:

• include/cpu.h (modified) (1 diff)
• src/main/main.c (modified) (3 diffs)
• src/proc/scheduler.c (modified) (10 diffs)
• src/proc/thread.c (modified) (1 diff)
• src/time/clock.c (modified) (1 diff)

kernel/generic/include/cpu.h

@@ -74 +74 @@
         bool idle;
         uint64_t last_cycle;
+
+        context_t scheduler_context;
 } cpu_local_t;
 

kernel/generic/src/main/main.c

@@ -287 +287 @@
          * starting the thread of kernel threads.
          */
-        scheduler_run();
+        current_copy(CURRENT, (current_t *) CPU_LOCAL->stack);
+        context_replace(scheduler_run, CPU_LOCAL->stack, STACK_SIZE);
         /* not reached */
 }
@@ -327 +328 @@
         ARCH_OP(post_cpu_init);
 
-        current_copy(CURRENT, (current_t *) CPU_LOCAL->stack);
-
         /*
          * If we woke kmp up before we left the kernel stack, we could
@@ -334 +333 @@
          * switch to this cpu's private stack prior to waking kmp up.
          */
+        current_copy(CURRENT, (current_t *) CPU_LOCAL->stack);
         context_replace(main_ap_separated_stack, CPU_LOCAL->stack, STACK_SIZE);
         /* not reached */

kernel/generic/src/proc/scheduler.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Jakub Jermar
+ * Copyright (c) 2023 Jiří Zárevúcky
  * All rights reserved.
  *
@@ -50 +51 @@
 #include <time/delay.h>
 #include <arch/asm.h>
-#include <arch/faddr.h>
 #include <arch/cycle.h>
 #include <atomic.h>
@@ -66 +66 @@
 #include <stacktrace.h>
 
-static void scheduler_separated_stack(void);
-
 atomic_size_t nrdy;  /**< Number of ready threads in the system. */
 
@@ -227 +225 @@
 static void relink_rq(int start)
 {
+        assert(interrupts_disabled());
+
         if (CPU_LOCAL->current_clock_tick < CPU_LOCAL->relink_deadline)
                 return;
@@ -302 +302 @@
 }
 
-void scheduler_run(void)
-{
-        assert(interrupts_disabled());
-        assert(THREAD == NULL);
-        assert(CPU != NULL);
-
-        current_copy(CURRENT, (current_t *) CPU_LOCAL->stack);
-        context_replace(scheduler_separated_stack, CPU_LOCAL->stack, STACK_SIZE);
-        unreachable();
-}
-
 /** Things to do before we switch to THREAD context.
  */
@@ -421 +410 @@
 }
 
-/** The scheduler
- *
- * The thread scheduling procedure.
- * Passes control directly to
- * scheduler_separated_stack().
- *
- */
+/** Switch to scheduler context to let other threads run. */
 void scheduler_enter(state_t new_state)
 {
@@ -436 +419 @@
 
         fpu_cleanup();
+
+        if (atomic_load(&haltstate))
+                halt();
 
         irq_spinlock_lock(&THREAD->lock, false);
@@ -460 +446 @@
          *
          */
+
         current_copy(CURRENT, (current_t *) CPU_LOCAL->stack);
-
-        /*
-         * We may not keep the old stack.
-         * Reason: If we kept the old stack and got blocked, for instance, in
-         * find_best_thread(), the old thread could get rescheduled by another
-         * CPU and overwrite the part of its own stack that was also used by
-         * the scheduler on this CPU.
-         *
-         * Moreover, we have to bypass the compiler-generated POP sequence
-         * which is fooled by SP being set to the very top of the stack.
-         * Therefore the scheduler() function continues in
-         * scheduler_separated_stack().
-         *
-         */
-        context_t ctx;
-        context_create(&ctx, scheduler_separated_stack,
-            CPU_LOCAL->stack, STACK_SIZE);
-
-        /* Switch to scheduler context and store current thread's context. */
-        context_swap(&THREAD->saved_context, &ctx);
-
-        /* Returned from scheduler. */
+        context_swap(&THREAD->saved_context, &CPU_LOCAL->scheduler_context);
 
         irq_spinlock_unlock(&THREAD->lock, false);
@@ -488 +454 @@
 }
 
-/** Scheduler stack switch wrapper
- *
- * Second part of the scheduler() function
- * using new stack. Handling the actual context
- * switch to a new thread.
- *
- */
-void scheduler_separated_stack(void)
-{
-        assert((!THREAD) || (irq_spinlock_locked(&THREAD->lock)));
+/** Enter main scheduler loop. Never returns.
+ *
+ * This function switches to a runnable thread as soon as one is available,
+ * after which it is only switched back to if a thread is stopping and there is
+ * no other thread to run in its place. We need a separate context for that
+ * because we're going to block the CPU, which means we need another context
+ * to clean up after the previous thread.
+ */
+void scheduler_run(void)
+{
+        assert(interrupts_disabled());
+
         assert(CPU != NULL);
+        assert(TASK == NULL);
+        assert(THREAD == NULL);
         assert(interrupts_disabled());
 
-        if (atomic_load(&haltstate))
-                halt();
-
-        if (THREAD) {
+        while (!atomic_load(&haltstate)) {
+                assert(CURRENT->mutex_locks == 0);
+
+                int rq_index;
+                THREAD = find_best_thread(&rq_index);
+
+                prepare_to_run_thread(rq_index);
+
+                /*
+                 * Copy the knowledge of CPU, TASK, THREAD and preemption counter to
+                 * thread's stack.
+                 */
+                current_copy(CURRENT, (current_t *) THREAD->kstack);
+
+                /* Switch to thread context. */
+                context_swap(&CPU_LOCAL->scheduler_context, &THREAD->saved_context);
+
+                /* Back from the thread. */
+
+                assert(CPU != NULL);
+                assert(THREAD != NULL);
+                assert(irq_spinlock_locked(&THREAD->lock));
+                assert(interrupts_disabled());
+
                 state_t state = THREAD->state;
                 irq_spinlock_unlock(&THREAD->lock, false);
@@ -510 +500 @@
                 cleanup_after_thread(THREAD, state);
 
+                /*
+                 * Necessary because we're allowing interrupts in find_best_thread(),
+                 * so we need to avoid other code referencing the thread we left.
+                 */
                 THREAD = NULL;
         }
 
-        int rq_index;
-        THREAD = find_best_thread(&rq_index);
-
-        prepare_to_run_thread(rq_index);
-
-        /*
-         * Copy the knowledge of CPU, TASK, THREAD and preemption counter to
-         * thread's stack.
-         */
-        current_copy(CURRENT, (current_t *) THREAD->kstack);
-
-        context_restore(&THREAD->saved_context);
-
-        /* Not reached */
+        halt();
 }
 

kernel/generic/src/proc/thread.c

@@ -246 +246 @@
 void thread_ready(thread_t *thread)
 {
+        // TODO: move this to scheduler.c
         irq_spinlock_lock(&thread->lock, true);
 

kernel/generic/src/time/clock.c

@@ -123 +123 @@
 static void cpu_update_accounting(void)
 {
+        // FIXME: get_cycle() is unimplemented on several platforms
         uint64_t now = get_cycle();
         atomic_time_increment(&CPU->busy_cycles, now - CPU_LOCAL->last_cycle);