Changeset 286da52 in mainline

Timestamp:

2024-01-20T15:56:45Z (12 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.

Location:

kernel/generic

Files:

• include/proc/thread.h (modified) (1 diff)
• src/proc/scheduler.c (modified) (5 diffs)
• src/proc/thread.c (modified) (3 diffs)

kernel/generic/include/proc/thread.h

@@ -186 +186 @@
 extern void thread_attach(thread_t *, task_t *);
 extern void thread_start(thread_t *);
-extern void thread_ready(thread_t *);
+extern void thread_requeue_sleeping(thread_t *);
 extern void thread_exit(void) __attribute__((noreturn));
 extern void thread_interrupt(thread_t *);

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);

kernel/generic/src/proc/thread.c

@@ -210 +210 @@
 {
         assert(thread->state == Entering);
-        thread_ready(thread_ref(thread));
-}
-
-/** Make thread ready
- *
- * Switch thread to the ready state. Consumes reference passed by the caller.
- *
- * @param thread Thread to make ready.
- *
- */
-void thread_ready(thread_t *thread)
-{
-        // TODO: move this to scheduler.c
-        irq_spinlock_lock(&thread->lock, true);
-
-        assert(thread->state != Ready);
-
-        int i = (thread->priority < RQ_COUNT - 1) ?
-            ++thread->priority : thread->priority;
-
-        /* Prefer the CPU on which the thread ran last */
-        cpu_t *cpu = thread->cpu ? thread->cpu : CPU;
-
-        thread->state = Ready;
-
-        irq_spinlock_pass(&thread->lock, &(cpu->rq[i].lock));
-
-        /*
-         * Append thread to respective ready queue
-         * on respective processor.
-         */
-
-        list_append(&thread->rq_link, &cpu->rq[i].rq);
-        cpu->rq[i].n++;
-        irq_spinlock_unlock(&(cpu->rq[i].lock), true);
-
-        atomic_inc(&nrdy);
-        atomic_inc(&cpu->nrdy);
+        thread_requeue_sleeping(thread_ref(thread));
 }
 
@@ -613 +576 @@
                  * the waking thread by the sleeper in thread_wait_finish().
                  */
-                thread_ready(thread);
+                thread_requeue_sleeping(thread);
         }
 }
@@ -1064 +1027 @@
                 thread_attach(thread, TASK);
 #endif
-                thread_ready(thread);
+                thread_start(thread);
+                thread_put(thread);
 
                 return 0;