Reworking the threading and multiprocessing modules.

Author: kdschlosser

ext_mod/threading/common/inc/multiprocessing.h

@@ -2,14 +2,14 @@
 #ifndef __MULTIPROCESSING_H__
     #define __MULTIPROCESSING_H__
 
-    uint8_t mp_get_current_process_core(void);
-    uint8_t mp_get_process_core(thread_t *thread);
-    uint8_t mp_get_cpu_count(void);
+    #include "thread_thread.h"
 
-    extern mp_obj_t *processes;
-    extern uint8_t process_count;
+    uint8_t mp_get_current_process_core(void); // needs to be defined in port
+    uint8_t mp_get_process_core(thread_t *thread); // needs to be defined in port
+    uint8_t mp_get_cpu_count(void); // needs to be defined in port
+    void multiprocessing_init(void); // needs to be defined in port
 
-    void multiprocessing_init(void);
-    extern mp_obj_t processes[2];
+    extern mp_obj_t *processes; // needs to be defined in port
+    extern uint8_t process_count; // needs to be defined in port
 
 #endif /* __MULTIPROCESSING_H__ */

ext_mod/threading/common/inc/thread_event.h

@@ -6,23 +6,20 @@
 #ifndef __THREAD_EVENT_H__
     #define __THREAD_EVENT_H__
 
-    typedef struct _thread_event_t thread_event_t;
+    typedef struct _thread_event_t thread_event_t; // needs to be defined in port
 
     typedef struct _mp_obj_thread_event_t {
         mp_obj_base_t base;
         thread_event_t event;
-
         bool is_set;
-
     } mp_obj_thread_event_t;
 
-
-    void threading_event_set(thread_event_t *event);
-    bool threading_event_isset(thread_event_t *event);
-    void threading_event_clear(thread_event_t *event);
-    void threading_event_wait(thread_event_t *event, int32_t wait_ms);
-    void threading_event_init(thread_event_t *event);
-    void threading_event_delete(thread_event_t *event);
+    void threading_event_set(thread_event_t *event); // needs to be defined in port
+    bool threading_event_isset(thread_event_t *event); // needs to be defined in port
+    void threading_event_clear(thread_event_t *event); // needs to be defined in port
+    void threading_event_wait(thread_event_t *event, int32_t wait_ms); // needs to be defined in port
+    void threading_event_init(thread_event_t *event); // needs to be defined in port
+    void threading_event_delete(thread_event_t *event); // needs to be defined in port
 
 #endif
 

ext_mod/threading/common/inc/thread_lock.h

@@ -6,19 +6,17 @@
 #ifndef __THREAD_LOCK_H__
     #define __THREAD_LOCK_H__
 
-    #include "threading_common.h"
-
-    typedef struct _thread_lock_t thread_lock_t;
+    typedef struct _thread_lock_t thread_lock_t; // needs to be defined in port
 
     typedef struct _mp_obj_lock_t {
         mp_obj_base_t base;
         thread_lock_t lock;
         volatile bool locked;
     } mp_obj_lock_t;
 
-    int threading_lock_acquire(thread_lock_t *lock, int32_t wait_ms);
-    void threading_lock_release(thread_lock_t *lock);
-    void threading_lock_init(thread_lock_t *lock);
-    void threading_lock_delete(thread_lock_t *lock);
+    int threading_lock_acquire(thread_lock_t *lock, int32_t wait_ms); // needs to be defined in port
+    void threading_lock_release(thread_lock_t *lock); // needs to be defined in port
+    void threading_lock_init(thread_lock_t *lock); // needs to be defined in port
+    void threading_lock_delete(thread_lock_t *lock); // needs to be defined in port
 
 #endif

ext_mod/threading/common/inc/thread_rlock.h

@@ -10,7 +10,7 @@
 #ifndef __THREAD_RLOCK_H__
     #define __THREAD_RLOCK_H__
 
-    typedef struct _thread_rlock_t thread_rlock_t;
+    typedef struct _thread_rlock_t thread_rlock_t; // needs to be defined in port
 
     typedef struct _mp_obj_rlock_t {
         mp_obj_base_t base;
@@ -19,9 +19,9 @@
         volatile int count;
     } mp_obj_rlock_t;
 
-    int threading_rlock_acquire(thread_rlock_t *rlock, int32_t wait_ms);
-    void threading_rlock_release(thread_rlock_t *rlock);
-    void threading_rlock_init(thread_rlock_t *rlock);
-    void threading_rlock_delete(thread_rlock_t *rlock);
+    int threading_rlock_acquire(thread_rlock_t *rlock, int32_t wait_ms); // needs to be defined in port
+    void threading_rlock_release(thread_rlock_t *rlock); // needs to be defined in port
+    void threading_rlock_init(thread_rlock_t *rlock); // needs to be defined in port
+    void threading_rlock_delete(thread_rlock_t *rlock); // needs to be defined in port
 
 #endif

ext_mod/threading/common/inc/thread_semaphore.h

@@ -8,21 +8,18 @@
 
     #include "threading_common.h"
 
-    typedef struct _thread_semphamore_t thread_semphamore_t;
+    typedef struct _thread_semphamore_t thread_semphamore_t; // needs to be defined in port
 
     typedef struct _mp_obj_thread_semaphore_t {
         mp_obj_base_t base;
         thread_semphamore_t sem;
         uint16_t start_value;
-        volatile uint16_t value;
-        volatile uint16_t waiting;
     } mp_obj_thread_semaphore_t;
 
-
-    uint16_t threading_semphamore_get_count(thread_semphamore_t *sem);
-    bool threading_semphamore_acquire(thread_semphamore_t *sem, int32_t wait_ms);
-    void threading_semphamore_release(thread_semphamore_t *sem);
-    void threading_semphamore_init(thread_event_t *mutex);
-    void threading_semphamore_delete(thread_event_t *mutex);
+    uint16_t threading_semphamore_get_count(thread_semphamore_t *sem); // needs to be defined in port
+    bool threading_semphamore_acquire(thread_semphamore_t *sem, int32_t wait_ms); // needs to be defined in port
+    void threading_semphamore_release(thread_semphamore_t *sem); // needs to be defined in port
+    void threading_semphamore_init(thread_semphamore_t *sem); // needs to be defined in port
+    void threading_semphamore_delete(thread_semphamore_t *sem); // needs to be defined in port
 
 #endif

ext_mod/threading/common/inc/thread_thread.h

@@ -2,12 +2,11 @@
 #include "py/obj.h"
 #include "py/runtime.h"
 
-#include "thread_common.h"
 
 #ifndef __THREAD_THREAD_H__
     #define __THREAD_THREAD_H__
 
-    typedef struct _thread_t thread_t;
+    typedef struct _thread_t thread_t; // needs to be defined in port
 
     typedef struct _thread_entry_args_t {
         mp_obj_dict_t *dict_locals;
@@ -38,7 +37,7 @@
 
     } mp_obj_thread_t;
 
-    mp_uint_t threading_create_thread(mp_obj_thread_t *self);
-    void threading_delete_thread(thread_t *thread);
+    mp_uint_t threading_create_thread(mp_obj_thread_t *self); // needs to be defined in port
+    void threading_delete_thread(thread_t *thread); // needs to be defined in port
 
 #endif

ext_mod/threading/common/inc/threading.h

@@ -5,28 +5,27 @@
 #ifndef __THREADING_H__
     #define __THREADING_H__
 
+    #define THREAD_UNUSED(x) ((void)x)
+
     #include "thread_thread.h"
     #include "thread_lock.h"
     #include "thread_rlock.h"
     #include "thread_semphamore.h"
     #include "thread_event.h"
 
-    #define THREAD_UNUSED(x) ((void)x)
-
-    void threading_init(void *stack, uint32_t stack_len)
-    void threading_deinit(void)
-    void threading_gc_others(void)
+    void threading_init(void *stack, uint32_t stack_len); // needs to be defined in port
+    void threading_deinit(void); // needs to be defined in port
+    void threading_gc_others(void); // needs to be defined in port
 
     typedef void *(*thread_entry_cb_t)(mp_obj_thread_t *self);
 
-    mp_obj_t mp_get_main_thread(void);
-    mp_obj_t mp_enumerate_threads(void);
-
-    uint32_t mp_get_current_thread_id(void)
+    mp_obj_t mp_get_main_thread(void); // needs to be defined in port
+    mp_obj_t mp_enumerate_threads(void); // needs to be defined in port
+    uint32_t mp_get_current_thread_id(void); // needs to be defined in port
 
-    extern size_t thread_stack_size;
-    extern mp_obj_thread_t *t_thread;
-    extern thread_lock_t t_mutex;
-    extern mp_obj_thread_t _main_thread;
+    extern size_t thread_stack_size; // needs to be defined in port
+    extern mp_obj_thread_t *t_thread; // needs to be defined in port
+    extern thread_lock_t t_mutex; // needs to be defined in port
+    extern mp_obj_thread_t _main_thread; // needs to be defined in port
 
 #endif /*__THREADING_H__ */

ext_mod/threading/esp32/thread_port.c

@@ -216,7 +216,8 @@ void *thread_entry_cb(mp_obj_thread_t *self)
 
 
 
-void threading_init(void *stack, uint32_t stack_len) {
+void threading_init(void *stack, uint32_t stack_len)
+{
     mp_thread_set_state(&mp_state_ctx.thread);
     // create the first entry in the linked list of all threads
     _main_thread.thread.handle = xTaskGetCurrentTaskHandle();
@@ -238,7 +239,8 @@ void threading_init(void *stack, uint32_t stack_len) {
 }
 
 
-void threading_deinit(void) {
+void threading_deinit(void)
+{
     for (;;) {
         // Find a task to delete
 
@@ -266,8 +268,8 @@ void threading_deinit(void) {
 }
 
 
-
-void threading_gc_others(void) {
+void threading_gc_others(void)
+{
     threading_lock_acquire(&t_mutex, 1);
 
     for (mp_obj_thread_t *th = t_thread; th != NULL; th = th->next) {
@@ -285,7 +287,8 @@ void threading_gc_others(void) {
 }
 
 
-static void freertos_entry(void *arg) {
+static void freertos_entry(void *arg)
+{
     if (ext_threading_thread_entry) {
         mp_obj_thread_t *self = (mp_obj_thread_t *)arg;
         ext_threading_thread_entry(self);
@@ -297,7 +300,8 @@ static void freertos_entry(void *arg) {
 }
 
 
-mp_uint_t thread_create_ex(mp_obj_thread_t *self, int priority, char *name) {
+mp_uint_t thread_create_ex(mp_obj_thread_t *self, int priority, char *name)
+{
     // store thread entry function into a global variable so we can access it
     ext_threading_thread_entry = thread_entry_cb;
 
@@ -335,7 +339,8 @@ mp_uint_t thread_create_ex(mp_obj_thread_t *self, int priority, char *name) {
 }
 
 
-mp_uint_t threading_create_thread(thread_t *self) {
+mp_uint_t threading_create_thread(thread_t *self)
+{
     return thread_create_ex(self, THREADING_PRIORITY, "mp_thread");
 }
 

ext_mod/threading/esp32/thread_port.h

@@ -7,15 +7,6 @@
 #ifndef __THREAD_PORT_H__
     #define __THREAD_PORT_H__
 
-    #include "threading.h"
-    #include "multiprocessing.h"
-
-    #include "thread_thread.h"
-    #include "thread_event.h"
-    #include "thread_semphamore.h"
-    #include "thread_lock.h"
-    #include "thread_rlock.h"
-
     struct _thread_lock_t {
         SemaphoreHandle_t handle;
         StaticSemaphore_t buffer;
@@ -40,4 +31,15 @@
         TaskHandle_t handle;
     }
 
+    void THREADING_FREERTOS_TASK_DELETE_HOOK(void *tcb);
+
+    #include "threading.h"
+    #include "multiprocessing.h"
+
+    #include "thread_thread.h"
+    #include "thread_event.h"
+    #include "thread_semphamore.h"
+    #include "thread_lock.h"
+    #include "thread_rlock.h"
+
 #endif /* __THREAD_PORT_H__ */