Changeset a5b5f17 in mainline for kernel/generic/src/sysinfo/stats.c

Timestamp:

2024-01-21T16:36:15Z (4 months ago)

Author:

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

Branches:

master

Children:

1a1e124

Parents:

ed7e057 (diff), d23712e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge scheduler refactoring to remove the need for thread structure lock

All necessary synchronization is already a product of other operations
that enforce ordering (that is, runqueue manipulation and thread_sleep()
/thread_wakeup()). Some fields formally become atomic, which is only
needed because they are read from other threads to print out statistics.
These atomic operations are limited to relaxed individual reads/writes
to native-sized fields, which should at least in theory be compiled
identically to regular volatile variable accesses, the only difference
being that concurrent accesses from different threads are not undefined
behavior by definition.

Additionally, it is now made possible to switch directly to new thread
context instead of going through a separate scheduler stack. A separate
context is only needed and used when no runnable threads is immediately
available, which means we optimize switching in the limiting case where
many threads are waiting for execution. Switching is also avoided
altogether when there's only one runnable thread and it is being
preempted. Originally, the scheduler would switch to a separate stack,
requeue the thread that was running, retrieve that same thread from
queue, and switch to it again, all that work is now avoided.

File:

• kernel/generic/src/sysinfo/stats.c (modified) (3 diffs)

kernel/generic/src/sysinfo/stats.c

@@ -299 +299 @@
 {
         assert(interrupts_disabled());
-        assert(irq_spinlock_locked(&thread->lock));
 
         stats_thread->thread_id = thread->tid;
         stats_thread->task_id = thread->task->taskid;
-        stats_thread->state = thread->state;
-        stats_thread->priority = thread->priority;
-        stats_thread->ucycles = thread->ucycles;
-        stats_thread->kcycles = thread->kcycles;
-
-        if (thread->cpu != NULL) {
+        stats_thread->state = atomic_get_unordered(&thread->state);
+        stats_thread->priority = atomic_get_unordered(&thread->priority);
+        stats_thread->ucycles = atomic_time_read(&thread->ucycles);
+        stats_thread->kcycles = atomic_time_read(&thread->kcycles);
+
+        cpu_t *cpu = atomic_get_unordered(&thread->cpu);
+
+        if (cpu != NULL) {
                 stats_thread->on_cpu = true;
-                stats_thread->cpu = thread->cpu->id;
+                stats_thread->cpu = cpu->id;
         } else
                 stats_thread->on_cpu = false;
@@ -361 +362 @@
         thread_t *thread = thread_first();
         while (thread != NULL) {
-                /* Interrupts are already disabled */
-                irq_spinlock_lock(&thread->lock, false);
-
                 /* Record the statistics and increment the index */
                 produce_stats_thread(thread, &stats_threads[i]);
                 i++;
-
-                irq_spinlock_unlock(&thread->lock, false);
 
                 thread = thread_next(thread);
@@ -624 +620 @@
                 ret.data.size = sizeof(stats_thread_t);
 
-                /*
-                 * Replaced hand-over-hand locking with regular nested sections
-                 * to avoid weak reference leak issues.
-                 */
-                irq_spinlock_lock(&thread->lock, false);
                 produce_stats_thread(thread, stats_thread);
-                irq_spinlock_unlock(&thread->lock, false);
 
                 irq_spinlock_unlock(&threads_lock, true);