Changeset 41bfc64 in mainline

Timestamp:

2024-01-20T17:24:56Z (11 months ago)

Author:

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

Branches:

master

Children:

7364e2d1

Parents:

3d84734

git-author:

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

git-committer:

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

Message:

Make thread→state weakly atomic so we don't need to hold thread lock

Location:

kernel/generic

Files:

• include/proc/thread.h (modified) (1 diff)
• src/proc/scheduler.c (modified) (7 diffs)
• src/proc/thread.c (modified) (8 diffs)
• src/sysinfo/stats.c (modified) (1 diff)

kernel/generic/include/proc/thread.h

@@ -135 +135 @@
 
         /** Thread state. */
-        state_t state;
+        atomic_int_fast32_t state;
 
         /** Thread CPU. */

kernel/generic/src/proc/scheduler.c

@@ -313 +313 @@
         assert(atomic_get_unordered(&THREAD->cpu) == CPU);
 
-        THREAD->state = Running;
+        atomic_set_unordered(&THREAD->state, Running);
         atomic_set_unordered(&THREAD->priority, rq_index);  /* Correct rq index */
 
@@ -386 +386 @@
         irq_spinlock_lock(&thread->lock, false);
 
-        assert(thread->state == Running);
+        assert(atomic_get_unordered(&thread->state) == Running);
         assert(atomic_get_unordered(&thread->cpu) == CPU);
 
@@ -396 +396 @@
         }
 
-        thread->state = Ready;
+        atomic_set_unordered(&thread->state, Ready);
 
         irq_spinlock_unlock(&thread->lock, false);
@@ -409 +409 @@
         irq_spinlock_lock(&thread->lock, false);
 
-        assert(thread->state == Sleeping || thread->state == Entering);
+        assert(atomic_get_unordered(&thread->state) == Sleeping || atomic_get_unordered(&thread->state) == Entering);
 
         atomic_set_unordered(&thread->priority, 0);
-        thread->state = Ready;
+        atomic_set_unordered(&thread->state, Ready);
 
         /* Prefer the CPU on which the thread ran last */
@@ -471 +471 @@
                  */
                 panic("tid%" PRIu64 ": unexpected state %s.",
-                    thread->tid, thread_states[thread->state]);
+                    thread->tid, thread_states[out_state]);
                 break;
         }
@@ -501 +501 @@
 
         irq_spinlock_lock(&THREAD->lock, false);
-        THREAD->state = new_state;
+
+        atomic_set_unordered(&THREAD->state, new_state);
 
         /* Update thread kernel accounting */
@@ -809 +810 @@
                             thread) {
                                 printf("%" PRIu64 "(%s) ", thread->tid,
-                                    thread_states[thread->state]);
+                                    thread_states[atomic_get_unordered(&thread->state)]);
                         }
                         printf("\n");

kernel/generic/src/proc/thread.c

@@ -209 +209 @@
 void thread_start(thread_t *thread)
 {
-        assert(thread->state == Entering);
+        assert(atomic_get_unordered(&thread->state) == Entering);
         thread_requeue_sleeping(thread_ref(thread));
 }
@@ -269 +269 @@
 
         thread->nomigrate = 0;
-        thread->state = Entering;
+        atomic_init(&thread->state, Entering);
 
         atomic_init(&thread->sleep_queue, NULL);
@@ -339 +339 @@
         irq_spinlock_unlock(&thread->task->lock, false);
 
-        assert((thread->state == Exiting) || (thread->state == Lingering));
+        assert((atomic_get_unordered(&thread->state) == Exiting) || (atomic_get_unordered(&thread->state) == Lingering));
 
         /* Clear cpu->fpu_owner if set to this thread. */
@@ -637 +637 @@
                 return EINVAL;
 
-        irq_spinlock_lock(&thread->lock, true);
-        state_t state = thread->state;
-        irq_spinlock_unlock(&thread->lock, true);
+        state_t state = atomic_get_unordered(&thread->state);
 
         errno_t rc = EOK;
@@ -686 +684 @@
         order_suffix(thread->ucycles, &ucycles, &usuffix);
         order_suffix(thread->kcycles, &kcycles, &ksuffix);
+
+        state_t state = atomic_get_unordered(&thread->state);
 
         char *name;
@@ -699 +699 @@
         else
                 printf("%-8" PRIu64 " %-14s %p %-8s %p %-5" PRIu32 "\n",
-                    thread->tid, name, thread, thread_states[thread->state],
+                    thread->tid, name, thread, thread_states[state],
                     thread->task, thread->task->container);
 
@@ -709 +709 @@
                         printf("none ");
 
-                if (thread->state == Sleeping) {
+                if (state == Sleeping) {
                         printf(" %p", thread->sleep_queue);
                 }
@@ -914 +914 @@
                 printf("Scheduling thread stack trace.\n");
                 thread->btrace = true;
-                if (thread->state == Sleeping)
+                if (atomic_get_unordered(&thread->state) == Sleeping)
                         sleeping = true;
         } else

kernel/generic/src/sysinfo/stats.c

@@ -303 +303 @@
         stats_thread->thread_id = thread->tid;
         stats_thread->task_id = thread->task->taskid;
-        stats_thread->state = thread->state;
+        stats_thread->state = atomic_get_unordered(&thread->state);
         stats_thread->priority = atomic_get_unordered(&thread->priority);
         stats_thread->ucycles = thread->ucycles;