Changeset 286da52 in mainline for kernel/generic/src/proc/scheduler.c

Timestamp:

2024-01-20T15:56:45Z (4 months ago)

Author:

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

Branches:

master

Children:

efed95a3

Parents:

6a0e568

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2023-03-27 17:37:59)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2024-01-20 15:56:45)

Message:

Streamline requeuing threads

Split thread_ready() into different functions for different circumstances,
since they can be simplified after.

File:

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

kernel/generic/src/proc/scheduler.c

@@ -311 +311 @@
 
         irq_spinlock_lock(&THREAD->lock, false);
+        assert(THREAD->cpu == CPU);
+
         THREAD->state = Running;
-        THREAD->cpu = CPU;
         THREAD->priority = rq_index;  /* Correct rq index */
 
@@ -365 +366 @@
 }
 
+static void add_to_rq(thread_t *thread, cpu_t *cpu, int i)
+{
+        /* Add to the appropriate runqueue. */
+        runq_t *rq = &cpu->rq[i];
+
+        irq_spinlock_lock(&rq->lock, false);
+        list_append(&thread->rq_link, &rq->rq);
+        rq->n++;
+        irq_spinlock_unlock(&rq->lock, false);
+
+        atomic_inc(&nrdy);
+        atomic_inc(&cpu->nrdy);
+}
+
+/** Requeue a thread that was just preempted on this CPU.
+ */
+static void thread_requeue_preempted(thread_t *thread)
+{
+        irq_spinlock_lock(&thread->lock, false);
+
+        assert(thread->state == Running);
+        assert(thread->cpu == CPU);
+
+        int i = (thread->priority < RQ_COUNT - 1) ?
+            ++thread->priority : thread->priority;
+
+        thread->state = Ready;
+
+        irq_spinlock_unlock(&thread->lock, false);
+
+        add_to_rq(thread, CPU, i);
+}
+
+void thread_requeue_sleeping(thread_t *thread)
+{
+        ipl_t ipl = interrupts_disable();
+
+        irq_spinlock_lock(&thread->lock, false);
+
+        assert(thread->state == Sleeping || thread->state == Entering);
+
+        thread->priority = 0;
+        thread->state = Ready;
+
+        /* Prefer the CPU on which the thread ran last */
+        if (!thread->cpu)
+                thread->cpu = CPU;
+
+        cpu_t *cpu = thread->cpu;
+
+        irq_spinlock_unlock(&thread->lock, false);
+
+        add_to_rq(thread, cpu, 0);
+
+        interrupts_restore(ipl);
+}
+
 static void cleanup_after_thread(thread_t *thread, state_t out_state)
 {
@@ -374 +432 @@
         switch (out_state) {
         case Running:
-                thread_ready(thread);
+                thread_requeue_preempted(thread);
                 break;
 
@@ -398 +456 @@
                         assert(expected == SLEEP_WOKE);
                         /* The thread has already been woken up, requeue immediately. */
-                        thread_ready(thread);
+                        thread_requeue_sleeping(thread);
                 }
                 break;
@@ -447 +505 @@
          */
         after_thread_ran_arch();
-
-        if (new_state == Sleeping) {
-                /* Prefer the thread after it's woken up. */
-                THREAD->priority = -1;
-        }
 
         irq_spinlock_unlock(&THREAD->lock, false);