extmod/zephyr_kernel,py: Refactor threading to match ports/zephyr pattern.

Major architectural change to align with proven ports/zephyr implementation:

1. Removed MICROPY_ZEPHYR_THREADING guards from py/modthread.c and py/runtime.h
2. Simplified zephyr_entry() to minimal wrapper (just calls entry function)
3. Removed heap allocation of mp_state_thread_t (now stack-allocated in thread_entry)
4. Changed from K_FOREVER to K_NO_WAIT for immediate thread start
5. Removed manual scheduler manipulation (z_mark_thread_as_not_sleeping, z_ready_thread)

This makes extmod/zephyr_kernel follow the same pattern as ports/zephyr, where
thread_entry() in py/modthread.c handles all state initialization with a local
mp_state_thread_t variable on the thread's stack.

Testing shows threads can execute loops and access globals correctly with this
cleaner architecture.

Signed-off-by: Andrew Leech <[email protected]>

Author: pi-anl

extmod/zephyr_kernel/kernel/mpthread_zephyr.c

@@ -73,7 +73,6 @@ typedef struct _mp_thread_t {
     void *arg;                      // Python args (GC root pointer)
     void *stack;                    // Stack pointer
     size_t stack_len;               // Stack size in words
-    mp_state_thread_t *thread_state;// Python thread state (GC root)
     struct _mp_thread_t *next;      // Next in linked list
 } mp_thread_t;
 
@@ -103,7 +102,6 @@ bool mp_thread_init(void *stack) {
     thread_entry0.arg = NULL;
     thread_entry0.stack = stack;
     thread_entry0.stack_len = 0;  // Bootstrap thread uses C runtime stack, size unknown
-    thread_entry0.thread_state = &mp_state_ctx.thread;  // Main thread uses global state
     thread_entry0.next = NULL;
 
     k_thread_name_set(thread_entry0.id, "mp_main");
@@ -190,7 +188,6 @@ void mp_thread_gc_others(void) {
 
         gc_collect_root((void **)&th, 1);
         gc_collect_root(&th->arg, 1);
-        gc_collect_root((void **)&th->thread_state, 1);  // Scan thread state
 
         if (th->id == k_current_get()) {
             continue;  // Don't scan current thread's stack (done separately)
@@ -239,59 +236,11 @@ void mp_thread_start(void) {
 static void zephyr_entry(void *arg1, void *arg2, void *arg3) {
     (void)arg3;
 
-    // Get the mp_thread_t structure for this thread (passed via arg3 actually stored in custom_data)
-    // Find our thread in the list
-    mp_thread_t *self = NULL;
-    k_tid_t current_tid = k_current_get();
-
-    mp_thread_mutex_lock(&thread_mutex, 1);
-    for (mp_thread_t *th = thread; th != NULL; th = th->next) {
-        if (th->id == current_tid) {
-            self = th;
-            break;
-        }
-    }
-    mp_thread_mutex_unlock(&thread_mutex);
-
-    if (self == NULL || self->thread_state == NULL) {
-        // Fatal error - thread state not set up
-        k_thread_abort(current_tid);
-        for (;;) { ; }
-    }
-
-    // Set up thread-local storage using pre-allocated state
-    mp_thread_set_state(self->thread_state);
-
-    // Initialize thread state fields
-    self->thread_state->gc_lock_depth = 0;
-    self->thread_state->nlr_top = NULL;
-    self->thread_state->nlr_jump_callback_top = NULL;
-    self->thread_state->mp_pending_exception = MP_OBJ_NULL;
-
-    // Inherit globals/locals from main thread
-    mp_locals_set(mp_state_ctx.thread.dict_locals);
-    mp_globals_set(mp_state_ctx.thread.dict_globals);
-
-    // Get stack info from current thread
-    struct k_thread *current = k_current_get();
-    void *stack_top = (void *)((uintptr_t)current->stack_info.start + current->stack_info.size);
-    size_t stack_limit = current->stack_info.size - 1024;  // Leave margin for Zephyr
-
-    // Set up stack bounds for Python stack checking
-    mp_stack_set_top(stack_top);
-    mp_stack_set_limit(stack_limit);
-
-    // Mark thread as started (updates status to READY)
-    mp_thread_start();
-
-    // Now safe to execute Python code
+    // arg1 contains the python thread entry point
     if (arg1) {
         void *(*entry)(void *) = arg1;
         entry(arg2);
     }
-
-    // Clean up when thread finishes
-    mp_thread_finish();
     k_thread_abort(k_current_get());
     for (;;) {
         ;  // Never reached
@@ -310,36 +259,32 @@ mp_uint_t mp_thread_create_ex(void *(*entry)(void *), void *arg, size_t *stack_s
     // Try to garbage collect old threads
     gc_collect();
 
-    // Allocate thread node and thread state (must be outside mutex lock for GC)
+    // Allocate thread node (must be outside mutex lock for GC)
     mp_thread_t *th = m_new_obj(mp_thread_t);
-    mp_state_thread_t *ts = m_new_obj(mp_state_thread_t);
-    memset(ts, 0, sizeof(mp_state_thread_t));
 
     mp_thread_mutex_lock(&thread_mutex, 1);
 
     // Find available stack slot
     int32_t _slot = mp_thread_find_stack_slot();
     if (_slot < 0) {
         mp_thread_mutex_unlock(&thread_mutex);
-        m_del_obj(mp_state_thread_t, ts);  // Clean up allocated memory
         m_del_obj(mp_thread_t, th);
         mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("maximum number of threads reached"));
     }
 
-    // Create Zephyr thread with K_FOREVER so it stays unscheduled initially
-    // We'll manually wake it and add to ready queue following official Zephyr pattern
+    // Create Zephyr thread with K_NO_WAIT to start immediately
+    // This matches the ports/zephyr pattern
     th->id = k_thread_create(
         &th->z_thread,
         mp_thread_stack_array[_slot],
         K_THREAD_STACK_SIZEOF(mp_thread_stack_array[_slot]),
         zephyr_entry,
         entry, arg, NULL,
-        priority, 0, K_FOREVER
+        priority, 0, K_NO_WAIT
         );
 
     if (th->id == NULL) {
         mp_thread_mutex_unlock(&thread_mutex);
-        m_del_obj(mp_state_thread_t, ts);  // Clean up allocated memory
         m_del_obj(mp_thread_t, th);
         mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("can't create thread"));
     }
@@ -353,7 +298,6 @@ mp_uint_t mp_thread_create_ex(void *(*entry)(void *), void *arg, size_t *stack_s
     th->arg = arg;
     th->stack = (void *)th->z_thread.stack_info.start;
     th->stack_len = th->z_thread.stack_info.size / sizeof(uintptr_t);
-    th->thread_state = ts;  // Store pre-allocated thread state
     th->next = thread;
     thread = th;
 
@@ -365,18 +309,7 @@ mp_uint_t mp_thread_create_ex(void *(*entry)(void *), void *arg, size_t *stack_s
 
     DEBUG_printf("Created thread %s (id=%p)\n", name, th->id);
 
-    // Mark thread as not sleeping, then UNLOCK MUTEX before adding to ready queue
-    // This follows official Zephyr's prepare_multithreading() pattern (init.c:467-468)
-    // CRITICAL: Must unlock BEFORE z_ready_thread() to allow context switch to occur
-    // Note: z_ready_thread() uses K_SPINLOCK internally for IRQ protection
-    z_mark_thread_as_not_sleeping(th->id);
     mp_thread_mutex_unlock(&thread_mutex);
-    z_ready_thread(th->id);
-
-    // Trigger context switch to give new thread a chance to run
-    // This just sets PendSV which will fire when we return to thread mode
-    extern void mp_zephyr_arch_yield(void);
-    mp_zephyr_arch_yield();
 
     return (mp_uint_t)th->id;
 }

py/modthread.c

@@ -158,9 +158,6 @@ static void *thread_entry(void *args_in) {
 
     thread_entry_args_t *args = (thread_entry_args_t *)args_in;
 
-    #if !MICROPY_ZEPHYR_THREADING
-    // For Zephyr threading, thread state is already initialized by zephyr_entry()
-    // using heap-allocated state. Do NOT reinitialize here with local variable.
     mp_state_thread_t ts;
     mp_thread_init_state(&ts, args->stack_size, args->dict_locals, args->dict_globals);
 
@@ -169,23 +166,15 @@ static void *thread_entry(void *args_in) {
     mp_obj_t mini_pystack[128];
     mp_pystack_init(mini_pystack, &mini_pystack[128]);
     #endif
-    #endif
 
     MP_THREAD_GIL_ENTER();
 
-    #if !MICROPY_ZEPHYR_THREADING
-    // For Zephyr threading, mp_thread_start() is already called by zephyr_entry()
     mp_thread_start();
-    #endif
 
     // TODO set more thread-specific state here:
     //  cur_exception (root pointer)
 
-    #if !MICROPY_ZEPHYR_THREADING
     DEBUG_printf("[thread] start ts=%p args=%p stack=%p\n", &ts, &args, MP_STATE_THREAD(stack_top));
-    #else
-    DEBUG_printf("[thread] start args=%p stack=%p\n", &args, MP_STATE_THREAD(stack_top));
-    #endif
 
     nlr_buf_t nlr;
     if (nlr_push(&nlr) == 0) {

py/runtime.h

@@ -159,14 +159,7 @@ void mp_call_function_1_from_nlr_jump_callback(void *ctx_in);
 static inline void mp_thread_init_state(mp_state_thread_t *ts, size_t stack_size, mp_obj_dict_t *locals, mp_obj_dict_t *globals) {
     mp_thread_set_state(ts);
 
-    #if !MICROPY_ZEPHYR_THREADING
-    // For Zephyr threading, C stack is already initialized by zephyr_entry()
-    // using actual Zephyr thread stack info. Do NOT reinitialize here.
     mp_cstack_init_with_top(ts + 1, stack_size); // need to include ts in root-pointer scan
-    #else
-    // Zephyr threading: stack_top/stack_limit already set correctly by zephyr_entry()
-    (void)stack_size;  // Suppress unused parameter warning
-    #endif
 
     // GC starts off unlocked
     ts->gc_lock_depth = 0;