Changeset 151c050 in mainline

Timestamp:

2024-01-15T14:33:03Z (4 months ago)

Author:

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

Branches:

master

Children:

c7ceacf

Parents:

8996582

git-author:

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

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2024-01-15 14:33:03)

Message:

Rethink scheduler entry points

Changes the way scheduler is entered, to eliminate some unnecessary
locking and interrupt disables.

Location:

kernel/generic

Files:

• include/proc/scheduler.h (modified) (2 diffs)
• include/proc/thread.h (modified) (2 diffs)
• src/main/main.c (modified) (2 diffs)
• src/proc/scheduler.c (modified) (4 diffs)
• src/proc/thread.c (modified) (4 diffs)
• src/time/clock.c (modified) (1 diff)

kernel/generic/include/proc/scheduler.h

@@ -41 +41 @@
 #include <atomic.h>
 #include <adt/list.h>
+#include <abi/proc/thread.h>
 
 #define RQ_COUNT          16
@@ -56 +57 @@
 
 extern void scheduler_fpu_lazy_request(void);
-extern void scheduler(void);
-extern void scheduler_locked(ipl_t);
 extern void kcpulb(void *arg);
 
 extern void sched_print_list(void);
+
+extern void scheduler_run(void) __attribute__((noreturn));
+extern void scheduler_enter(state_t);
 
 /*

kernel/generic/include/proc/thread.h

@@ -113 +113 @@
          */
         context_t saved_context;
-        ipl_t saved_ipl;
 
         /**
@@ -244 +243 @@
 extern errno_t thread_join_timeout(thread_t *, uint32_t, unsigned int);
 
+extern void thread_yield(void);
+
 extern void thread_print_list(bool);
 extern thread_t *thread_find_by_id(thread_id_t);

kernel/generic/src/main/main.c

@@ -285 +285 @@
 
         /*
-         * This call to scheduler() will return to kinit,
+         * This call to scheduler_run() will return to kinit,
          * starting the thread of kernel threads.
          */
-        scheduler();
+        scheduler_run();
         /* not reached */
 }
@@ -356 +356 @@
 
         semaphore_up(&ap_completion_semaphore);
-        scheduler();
+        scheduler_run();
         /* not reached */
 }

kernel/generic/src/proc/scheduler.c

@@ -302 +302 @@
 }
 
-void scheduler(void)
-{
-        ipl_t ipl = interrupts_disable();
-
-        if (atomic_load(&haltstate))
-                halt();
-
-        if (THREAD) {
-                irq_spinlock_lock(&THREAD->lock, false);
-        }
-
-        scheduler_locked(ipl);
+void scheduler_run(void)
+{
+        assert(interrupts_disabled());
+        assert(THREAD == NULL);
+        assert(CPU != NULL);
+
+        current_copy(CURRENT, (current_t *) CPU_LOCAL->stack);
+
+        context_t ctx;
+        context_save(&ctx);
+        context_set(&ctx, FADDR(scheduler_separated_stack),
+            (uintptr_t) CPU_LOCAL->stack, STACK_SIZE);
+        context_restore(&ctx);
+
+        unreachable();
 }
 
@@ -431 +434 @@
  *
  */
-void scheduler_locked(ipl_t ipl)
-{
+void scheduler_enter(state_t new_state)
+{
+        ipl_t ipl = interrupts_disable();
+
         assert(CPU != NULL);
-
-        if (THREAD) {
-                /* Update thread kernel accounting */
-                THREAD->kcycles += get_cycle() - THREAD->last_cycle;
-
-                fpu_cleanup();
-
-                if (!context_save(&THREAD->saved_context)) {
-                        /*
-                         * This is the place where threads leave scheduler();
-                         */
-
-                        irq_spinlock_unlock(&THREAD->lock, false);
-                        interrupts_restore(THREAD->saved_ipl);
-
-                        return;
-                }
-
-                /*
-                 * Interrupt priority level of preempted thread is recorded
-                 * here to facilitate scheduler() invocations from
-                 * interrupts_disable()'d code (e.g. waitq_sleep_timeout()).
-                 *
-                 */
-                THREAD->saved_ipl = ipl;
+        assert(THREAD != NULL);
+
+        fpu_cleanup();
+
+        irq_spinlock_lock(&THREAD->lock, false);
+        THREAD->state = new_state;
+
+        /* Update thread kernel accounting */
+        THREAD->kcycles += get_cycle() - THREAD->last_cycle;
+
+        if (!context_save(&THREAD->saved_context)) {
+                /*
+                 * This is the place where threads leave scheduler();
+                 */
+
+                irq_spinlock_unlock(&THREAD->lock, false);
+                interrupts_restore(ipl);
+                return;
         }
 
@@ -504 +502 @@
         assert(interrupts_disabled());
 
+        if (atomic_load(&haltstate))
+                halt();
+
         if (THREAD) {
                 after_thread_ran_arch();
@@ -678 +679 @@
                  *
                  */
-                scheduler();
+                thread_yield();
         } else {
                 /*

kernel/generic/src/proc/thread.c

@@ -314 +314 @@
         current_initialize((current_t *) thread->kstack);
 
-        ipl_t ipl = interrupts_disable();
-        thread->saved_ipl = interrupts_read();
-        interrupts_restore(ipl);
-
         str_cpy(thread->name, THREAD_NAME_BUFLEN, name);
 
@@ -518 +514 @@
         }
 
-        irq_spinlock_lock(&THREAD->lock, true);
-        THREAD->state = Exiting;
-        irq_spinlock_unlock(&THREAD->lock, true);
-
-        scheduler();
-
-        panic("should never be reached");
+        scheduler_enter(Exiting);
+        unreachable();
 }
 
@@ -623 +614 @@
         }
 
-        ipl_t ipl = interrupts_disable();
-        irq_spinlock_lock(&THREAD->lock, false);
-        THREAD->state = Sleeping;
-        scheduler_locked(ipl);
+        scheduler_enter(Sleeping);
 
         if (deadline != DEADLINE_NEVER && !timeout_unregister(&timeout)) {
@@ -736 +724 @@
 
         (void) waitq_sleep_timeout(&wq, usec);
+}
+
+/** Allow other threads to run. */
+void thread_yield(void)
+{
+        assert(THREAD != NULL);
+        scheduler_enter(Running);
 }
 

kernel/generic/src/time/clock.c

@@ -187 +187 @@
         if (THREAD) {
                 if (current_clock_tick >= CPU_LOCAL->preempt_deadline && PREEMPTION_ENABLED) {
-                        scheduler();
+                        thread_yield();
 #ifdef CONFIG_UDEBUG
                         /*