Reworking the threading and multiprocessing modules.

Author: kdschlosser

ext_mod/threading/common/inc/multiprocessing.h

@@ -0,0 +1,15 @@
+
+#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);
+
+    extern mp_obj_t *processes;
+    extern uint8_t process_count;
+
+    void multiprocessing_init(void);
+    extern mp_obj_t processes[2];
+
+#endif /* __MULTIPROCESSING_H__ */

ext_mod/threading/common/inc/thread_event.h

@@ -0,0 +1,40 @@
+// micropython includes
+#include "py/obj.h"
+#include "py/runtime.h"
+
+
+#ifndef __THREAD_EVENT_H__
+    #define __THREAD_EVENT_H__
+
+    typedef struct _thread_event_t thread_event_t;
+
+    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);
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+

ext_mod/threading/common/inc/thread_lock.h

@@ -0,0 +1,24 @@
+// micropython includes
+#include "py/obj.h"
+#include "py/runtime.h"
+
+
+#ifndef __THREAD_LOCK_H__
+    #define __THREAD_LOCK_H__
+
+    #include "threading_common.h"
+
+    typedef struct _thread_lock_t thread_lock_t;
+
+    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);
+
+#endif

ext_mod/threading/common/inc/thread_rlock.h

@@ -0,0 +1,27 @@
+// micropython includes
+#include "py/obj.h"
+#include "py/runtime.h"
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+
+#include "thread_common.h"
+
+#ifndef __THREAD_RLOCK_H__
+    #define __THREAD_RLOCK_H__
+
+    typedef struct _thread_rlock_t thread_rlock_t;
+
+    typedef struct _mp_obj_rlock_t {
+        mp_obj_base_t base;
+        thread_rlock_t rlock;
+        volatile bool locked;
+        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);
+
+#endif

ext_mod/threading/common/inc/thread_semaphore.h

@@ -0,0 +1,28 @@
+// micropython includes
+#include "py/obj.h"
+#include "py/runtime.h"
+
+
+#ifndef __THREAD_SEMAPHORE_H__
+    #define __THREAD_SEMAPHORE_H__
+
+    #include "threading_common.h"
+
+    typedef struct _thread_semphamore_t thread_semphamore_t;
+
+    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);
+
+#endif

ext_mod/threading/esp32/common/inc/thread_thread.h renamed to ext_mod/threading/common/inc/thread_thread.h

@@ -2,15 +2,13 @@
 #include "py/obj.h"
 #include "py/runtime.h"
 
-#include "freertos/idf_additions.h"
-#include "freertos/task.h"
-#include "freertos/semphr.h"
-
 #include "thread_common.h"
 
 #ifndef __THREAD_THREAD_H__
     #define __THREAD_THREAD_H__
 
+    typedef struct _thread_t thread_t;
+
     typedef struct _thread_entry_args_t {
         mp_obj_dict_t *dict_locals;
         mp_obj_dict_t *dict_globals;
@@ -21,9 +19,9 @@
         mp_obj_t args[];
     } thread_entry_args_t;
 
-    typedef struct _mp_obj_thread_thread_t {
+    typedef struct _mp_obj_thread_t {
         mp_obj_base_t base;
-        TaskHandle_t id;
+        thread_t thread;
         mp_obj_t ident;
 
         mp_obj_t name;
@@ -36,15 +34,11 @@
         void *arg;              // thread Python args, a GC root pointer
         void *stack;            // pointer to the stack
         size_t stack_len;       // number of words in the stack
-        struct _mp_obj_thread_thread_t *next;
-
-    } mp_obj_thread_thread_t;
-
+        struct _mp_obj_thread_t *next;
 
-    extern const mp_obj_fun_builtin_fixed_t thread_start_obj;
-    extern const mp_obj_fun_builtin_fixed_t thread_is_alive_obj;
+    } mp_obj_thread_t;
 
-    void *thread_entry_cb(mp_obj_thread_thread_t *th);
-    void thread_attr_func(mp_obj_t self_in, qstr attr, mp_obj_t *dest);
+    mp_uint_t threading_create_thread(mp_obj_thread_t *self);
+    void threading_delete_thread(thread_t *thread);
 
 #endif

ext_mod/threading/common/inc/threading.h

@@ -0,0 +1,32 @@
+// micropython includes
+#include "py/obj.h"
+#include "py/runtime.h"
+
+#ifndef __THREADING_H__
+    #define __THREADING_H__
+
+    #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)
+
+    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)
+
+    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;
+
+#endif /*__THREADING_H__ */

ext_mod/threading/esp32/multiprocessing/src/multiprocessing.c renamed to ext_mod/threading/common/src/multiprocessing.c

@@ -1,29 +1,10 @@
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "freertos/semphr.h"
-#include "freertos/queue.h"
-
-
-#include "thread_common.h"
-#include "thread_thread.h"
-
-#include "threading.h"
-
-#include "multiprocessing.h"
-#include "multiprocessing_event.h"
-#include "multiprocessing_lock.h"
-#include "multiprocessing_process.h"
-#include "multiprocessing_rlock.h"
-#include "multiprocessing_semaphore.h"
-
-
 mp_obj_t processes[2];
 
 
 void multiprocessing_init(void)
 {
     mp_obj_thread_thread_t * main_thread = (mp_obj_thread_thread_t *)MP_OBJ_TO_PTR(threading_main_thread());
-    uint16_t curr_core_id = (uint16_t)xTaskGetCoreID(main_thread->id);
+    uint8_t curr_core_id = mp_get_process_core(&main_thread->thread);
     processes[curr_core_id] = MP_OBJ_FROM_PTR(main_thread);
 }
 
@@ -32,23 +13,23 @@ static mp_obj_t multiprocessing_active_children(void)
 {
     mp_obj_t list = mp_obj_new_list(0, NULL);
 
-    uint16_t core_id = (uint16_t)xTaskGetCoreID(xTaskGetCurrentTaskHandle());
-    uint16_t task_core_id;
+    uint8_t core_id = mp_get_current_process_core();
+    uint8_t task_core_id;
 
-    lock_acquire(&t_mutex, 1);
+    threading_lock_acquire(&t_mutex, 1);
 
     for (mp_obj_thread_thread_t *th = t_thread; th != NULL; th = th->next) {
         if (!th->is_alive) {
             continue;
         }
-        task_core_id = (uint16_t)xTaskGetCoreID(th->id);
+        task_core_id = mp_get_process_core(&th->thread);
 
         if (task_core_id == core_id) {
             mp_obj_list_append(list, MP_OBJ_FROM_PTR(th));
         }
     }
 
-    lock_release(&t_mutex);
+    threading_lock_release(&t_mutex);
     return list;
 }
 
@@ -57,15 +38,15 @@ static MP_DEFINE_CONST_FUN_OBJ_0(multiprocessing_active_children_obj, multiproce
 
 static mp_obj_t multiprocessing_cpu_count(void)
 {
-    return mp_obj_new_int(2);
+    return mp_obj_new_int_truncated(mp_get_cpu_count());
 }
 
 static MP_DEFINE_CONST_FUN_OBJ_0(multiprocessing_cpu_count_obj, multiprocessing_cpu_count);
 
 
 static mp_obj_t multiprocessing_current_process(void)
 {
-    uint16_t core_id = (uint16_t)xTaskGetCoreID(xTaskGetCurrentTaskHandle());
+    uint8_t core_id = mp_get_current_process_core();
     return processes[core_id];
 }
 
@@ -75,13 +56,9 @@ static MP_DEFINE_CONST_FUN_OBJ_0(multiprocessing_current_process_obj, multiproce
 static mp_obj_t multiprocessing_parent_process(void)
 {
     mp_obj_t main_thread = threading_main_thread();
-    uint16_t core_id = (uint16_t)xTaskGetCoreID(xTaskGetCurrentTaskHandle());
+    uint8_t core_id = mp_get_current_process_core();
 
-    if (processes[core_id] == main_thread) {
-        return mp_const_none;
-    } else {
-        return main_thread;
-    }
+    return processes[core_id];
 }
 
 static MP_DEFINE_CONST_FUN_OBJ_0(multiprocessing_parent_process_obj, multiprocessing_parent_process);
@@ -108,6 +85,4 @@ const mp_obj_module_t mp_module_multiprocessing = {
     .globals = (mp_obj_dict_t *)&mp_module_multiprocessing_globals,
 };
 
-MP_REGISTER_MODULE(MP_QSTR_multiprocessing, mp_module_multiprocessing);
-
-
+MP_REGISTER_MODULE(MP_QSTR_multiprocessing, mp_module_multiprocessing);