Changeset 6a0e568 in mainline for kernel/generic/src/proc/scheduler.c

Timestamp:

2024-01-19T16:56:48Z (4 months ago)

Author:

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

Branches:

master

Children:

286da52

Parents:

c1eaec4

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2023-02-22 18:04:40)

git-committer:

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

Message:

Allow fast-switch to another runnable thread

When a thread is available that can be switched to immediately
without having to block, do so without a detour through CPU
scheduler context. The new thread will handle whatever cannot
be done while the previous context is active on a CPU, such as
requeuing the thread or deallocation.

File:

• kernel/generic/src/proc/scheduler.c (modified) (3 diffs)

kernel/generic/src/proc/scheduler.c

@@ -425 +425 @@
                 halt();
 
+        /* Check if we have a thread to switch to. */
+
+        int rq_index;
+        thread_t *new_thread = try_find_thread(&rq_index);
+
+        if (new_thread == NULL && new_state == Running) {
+                /* No other thread to run, but we still have work to do here. */
+                interrupts_restore(ipl);
+                return;
+        }
+
         irq_spinlock_lock(&THREAD->lock, false);
         THREAD->state = new_state;
@@ -446 +457 @@
         CPU_LOCAL->exiting_state = new_state;
 
-        current_copy(CURRENT, (current_t *) CPU_LOCAL->stack);
-        context_swap(&THREAD->saved_context, &CPU_LOCAL->scheduler_context);
+        if (new_thread) {
+                thread_t *old_thread = THREAD;
+                CPU_LOCAL->prev_thread = old_thread;
+                THREAD = new_thread;
+                /* No waiting necessary, we can switch to the new thread directly. */
+                prepare_to_run_thread(rq_index);
+
+                current_copy(CURRENT, (current_t *) new_thread->kstack);
+                context_swap(&old_thread->saved_context, &new_thread->saved_context);
+        } else {
+                /*
+                 * A new thread isn't immediately available, switch to a separate
+                 * stack to sleep or do other idle stuff.
+                 */
+                current_copy(CURRENT, (current_t *) CPU_LOCAL->stack);
+                context_swap(&THREAD->saved_context, &CPU_LOCAL->scheduler_context);
+        }
 
         assert(CURRENT->mutex_locks == 0);
         assert(interrupts_disabled());
+
+        /* Check if we need to clean up after another thread. */
+        if (CPU_LOCAL->prev_thread) {
+                cleanup_after_thread(CPU_LOCAL->prev_thread, CPU_LOCAL->exiting_state);
+                CPU_LOCAL->prev_thread = NULL;
+        }
 
         interrupts_restore(ipl);
@@ -504 +536 @@
 
         halt();
+}
+
+/** Thread wrapper.
+ *
+ * This wrapper is provided to ensure that a starting thread properly handles
+ * everything it needs to do when first scheduled, and when it exits.
+ */
+void thread_main_func(void)
+{
+        assert(interrupts_disabled());
+
+        void (*f)(void *) = THREAD->thread_code;
+        void *arg = THREAD->thread_arg;
+
+        /* This is where each thread wakes up after its creation */
+
+        /* Check if we need to clean up after another thread. */
+        if (CPU_LOCAL->prev_thread) {
+                cleanup_after_thread(CPU_LOCAL->prev_thread, CPU_LOCAL->exiting_state);
+                CPU_LOCAL->prev_thread = NULL;
+        }
+
+        interrupts_enable();
+
+        f(arg);
+
+        thread_exit();
+
+        /* Not reached */
 }