scheduler: avoid redundant scheduler wake on process handoff

If SMP is enabled, instead of waking the polling scheduler, grab the first
ready process immediately if any.

Also simplify scheduler_make_ready a little bit to reduce the number of locks.

Signed-off-by: Paul Guyot <pguyot@kallisys.net>

Author: pguyot

CHANGELOG.md

@@ -43,6 +43,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   longer lines return `{error, {parser, {line_too_long, Prefix}}}` with the first 128 bytes of
   the offending line. Callers whose upstream servers emit unusually large headers must account
   for this limit
+- Improved performance of SMP scheduler
 
 ### Removed
 - Removed `ahttp_client` support for obsolete line folding (RFC 9112 §5.2); folded header and

src/libAtomVM/scheduler.c

@@ -152,6 +152,32 @@ static void scheduler_process_native_signal_messages(Context *ctx)
     }
 }
 
+static Context *scheduler_first_runnable_ready(GlobalContext *global)
+{
+    Context *result = NULL;
+    SMP_SPINLOCK_LOCK(&global->processes_spinlock);
+    // Pick first ready which is not running.
+    struct ListHead *next_ready = list_first(&global->ready_processes);
+    while (next_ready != &global->ready_processes) {
+        result = GET_LIST_ENTRY(next_ready, Context, processes_list_head);
+        if (!(result->flags & Running)) {
+            list_remove(next_ready);
+            context_update_flags(result, ~Ready, Running);
+            if (result->native_handler) {
+                // Native handlers are marked as waiting
+                list_append(&global->waiting_processes, next_ready);
+            } else {
+                list_append(&global->running_processes, next_ready);
+            }
+            break;
+        }
+        next_ready = next_ready->next;
+        result = NULL;
+    }
+    SMP_SPINLOCK_UNLOCK(&global->processes_spinlock);
+    return result;
+}
+
 static Context *scheduler_run0(GlobalContext *global)
 {
     // This function should return a new process to run.
@@ -209,6 +235,13 @@ static Context *scheduler_run0(GlobalContext *global)
                 return NULL;
             }
             if (!is_waiting) {
+                // If a process is ready, process it instead of waking up
+                // the poller scheduler
+                result = scheduler_first_runnable_ready(global);
+                if (result != NULL) {
+                    break;
+                }
+
                 // Before entering the condition variable, signal the poll events
                 // so the thread polling on events can check the ready queue.
                 sys_signal(global);
@@ -232,41 +265,35 @@ static Context *scheduler_run0(GlobalContext *global)
         int32_t wait_timeout = update_timer_list(global);
         SMP_SPINLOCK_UNLOCK(&global->timer_spinlock);
 
-        SMP_SPINLOCK_LOCK(&global->processes_spinlock);
-        // Pick first ready which is not running.
-        struct ListHead *next_ready = list_first(&global->ready_processes);
-        while (next_ready != &global->ready_processes) {
-            result = GET_LIST_ENTRY(next_ready, Context, processes_list_head);
-            if (!(result->flags & Running)) {
-                list_remove(next_ready);
-                context_update_flags(result, ~Ready, Running);
-                if (result->native_handler) {
-                    // Native handlers are marked as waiting
-                    list_append(&global->waiting_processes, next_ready);
-                } else {
-                    list_append(&global->running_processes, next_ready);
-                }
-                break;
-            }
-            next_ready = next_ready->next;
-            result = NULL;
+        if (result == NULL) {
+            result = scheduler_first_runnable_ready(global);
         }
-        SMP_SPINLOCK_UNLOCK(&global->processes_spinlock);
 
-        if (result == NULL && !global->scheduler_stop_all) {
-            sys_poll_events(global, wait_timeout);
-        } else {
-            sys_poll_events(global, SYS_POLL_EVENTS_DO_NOT_WAIT);
+        // Only the poller scheduler drives the event loop.
+#ifndef AVM_NO_SMP
+        if (is_waiting) {
+#endif
+            if (result == NULL && !global->scheduler_stop_all) {
+                // The poller may block waiting for events.
+                sys_poll_events(global, wait_timeout);
+            } else {
+                sys_poll_events(global, SYS_POLL_EVENTS_DO_NOT_WAIT);
+            }
+#ifndef AVM_NO_SMP
         }
+#endif
 #ifdef AVM_TASK_DRIVER_ENABLED
         globalcontext_process_task_driver_queues(global);
 #endif
         SMP_MUTEX_LOCK(global->schedulers_mutex);
     } while (result == NULL);
 
 #ifndef AVM_NO_SMP
-    global->waiting_scheduler = false;
-    smp_condvar_signal(global->schedulers_cv);
+    // Only the polling scheduler relinquishes the poller role.
+    if (is_waiting) {
+        global->waiting_scheduler = false;
+        smp_condvar_signal(global->schedulers_cv);
+    }
     SMP_MUTEX_UNLOCK(global->schedulers_mutex);
 #endif
 
@@ -356,6 +383,12 @@ static void scheduler_make_ready(Context *ctx)
         return;
     }
     list_remove(&ctx->processes_list_head);
+    // Move to ready queue (from waiting or running)
+    // The process may be running (it would be signaled), so mark it
+    // as ready
+    context_update_flags(ctx, ~NoFlags, Ready);
+    list_append(&global->ready_processes, &ctx->processes_list_head);
+    SMP_SPINLOCK_UNLOCK(&global->processes_spinlock);
 #ifndef AVM_NO_SMP
     if (SMP_MUTEX_TRYLOCK(global->schedulers_mutex)) {
         // Start a new scheduler if none are going to take this process.
@@ -366,17 +399,6 @@ static void scheduler_make_ready(Context *ctx)
             global->running_schedulers++;
             smp_scheduler_start(global);
         }
-        SMP_MUTEX_UNLOCK(global->schedulers_mutex);
-    }
-#endif
-    // Move to ready queue (from waiting or running)
-    // The process may be running (it would be signaled), so mark it
-    // as ready
-    context_update_flags(ctx, ~NoFlags, Ready);
-    list_append(&global->ready_processes, &ctx->processes_list_head);
-    SMP_SPINLOCK_UNLOCK(&global->processes_spinlock);
-#ifndef AVM_NO_SMP
-    if (SMP_MUTEX_TRYLOCK(global->schedulers_mutex)) {
         if (global->waiting_scheduler) {
             sys_signal(global);
         }