Getting closer to being finished.

Adding in unix support and combining code into a common API to minimize the amount of duplicate code needed between ports.

Almost finished with the changes and then need to do the compile tests and fix any issues.

Author: kdschlosser

ext_mod/micropython.cmake

@@ -4,8 +4,6 @@ include(${CMAKE_CURRENT_LIST_DIR}/lcd_utils/micropython.cmake)
 
 set(MICROPY_MULTICORE_THREAD $ENV{MICROPY_MULTICORE_THREADING})
 
-# if(ESP_PLATFORM)
-#     if(MICROPY_MULTICORE_THREAD)
-#         include(${CMAKE_CURRENT_LIST_DIR}/threading/micropython.cmake)
-#     endif(MICROPY_MULTICORE_THREAD)
-# endif(ESP_PLATFORM)
+if(MICROPY_MULTICORE_THREAD)
+      include(${CMAKE_CURRENT_LIST_DIR}/threading/micropython.cmake)
+endif(MICROPY_MULTICORE_THREAD)

ext_mod/threading/common/inc/thread_event.h

@@ -21,6 +21,9 @@
     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
 
+    extern const mp_obj_type_t mp_type_threading_event_t;
+    extern const mp_obj_type_t mp_type_multiprocessing_event_t;
+
 #endif
 
 

ext_mod/threading/common/inc/thread_lock.h

@@ -19,4 +19,8 @@
     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
 
+    extern const mp_obj_type_t mp_type_threading_lock_t;
+    extern const mp_obj_type_t mp_type_multiprocessing_lock_t;
+
+
 #endif

ext_mod/threading/common/inc/thread_rlock.h

@@ -24,4 +24,7 @@
     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
 
+    extern const mp_obj_type_t mp_type_threading_rlock_t;
+    extern const mp_obj_type_t mp_type_multiprocessing_rlock_t;
+
 #endif

ext_mod/threading/common/inc/thread_semaphore.h

@@ -6,20 +6,21 @@
 #ifndef __THREAD_SEMAPHORE_H__
     #define __THREAD_SEMAPHORE_H__
 
-    #include "threading_common.h"
-
-    typedef struct _thread_semphamore_t thread_semphamore_t; // needs to be defined in port
+    typedef struct _thread_semaphore_t thread_semaphore_t; // needs to be defined in port
 
     typedef struct _mp_obj_thread_semaphore_t {
         mp_obj_base_t base;
-        thread_semphamore_t sem;
+        thread_semaphore_t sem;
         uint16_t start_value;
     } mp_obj_thread_semaphore_t;
 
-    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
+    uint16_t threading_semaphore_get_count(thread_semaphore_t *sem); // needs to be defined in port
+    bool threading_semaphore_acquire(thread_semaphore_t *sem, int32_t wait_ms); // needs to be defined in port
+    void threading_semaphore_release(thread_semaphore_t *sem); // needs to be defined in port
+    void threading_semaphore_init(thread_semaphore_t *sem); // needs to be defined in port
+    void threading_semaphore_delete(thread_semaphore_t *sem); // needs to be defined in port
+
+    extern const mp_obj_type_t mp_type_threading_semaphore_t;
+    extern const mp_obj_type_t mp_type_multiprocessing_semaphore_t;
 
 #endif

ext_mod/threading/common/inc/thread_thread.h

@@ -30,14 +30,16 @@
         int ready;              // whether the thread is ready and running
         int is_alive;
         uint8_t core_id;
-        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_t *next;
 
     } mp_obj_thread_t;
 
     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
+    void threading_delete_thread(mp_obj_thread_t *self); // needs to be defined in port
+
+    extern const mp_obj_type_t mp_type_threading_thread_t;
+    extern const mp_obj_type_t mp_type_multiprocessing_process_t;
 
 #endif

ext_mod/threading/common/inc/threading.h

@@ -10,7 +10,7 @@
     #include "thread_thread.h"
     #include "thread_lock.h"
     #include "thread_rlock.h"
-    #include "thread_semphamore.h"
+    #include "thread_semaphore.h"
     #include "thread_event.h"
 
     void threading_init(void *stack, uint32_t stack_len); // needs to be defined in port

ext_mod/threading/common/src/multiprocessing.c

@@ -1,9 +1,17 @@
-mp_obj_t processes[2];
 
+#include "multiprocessing.h"
+#include "threading.h"
+#include "thread_lock.h"
+#include "thread_port.h"
+
+
+mp_obj_t *processes;
 
 void multiprocessing_init(void)
 {
-    mp_obj_thread_thread_t * main_thread = (mp_obj_thread_thread_t *)MP_OBJ_TO_PTR(threading_main_thread());
+    processes = (mp_obj_t *)malloc(sizeof(mp_obj_t) * mp_get_cpu_count());
+
+    mp_obj_thread_t * main_thread = (mp_obj_thread_t *)MP_OBJ_TO_PTR(threading_main_thread());
     uint8_t curr_core_id = mp_get_process_core(&main_thread->thread);
     processes[curr_core_id] = MP_OBJ_FROM_PTR(main_thread);
 }
@@ -16,9 +24,9 @@ static mp_obj_t multiprocessing_active_children(void)
     uint8_t core_id = mp_get_current_process_core();
     uint8_t task_core_id;
 
-    threading_lock_acquire(&t_mutex, 1);
+    threading_lock_acquire((thread_lock_t *)(&t_mutex), 1);
 
-    for (mp_obj_thread_thread_t *th = t_thread; th != NULL; th = th->next) {
+    for (mp_obj_thread_t *th = t_thread; th != NULL; th = th->next) {
         if (!th->is_alive) {
             continue;
         }
@@ -29,7 +37,7 @@ static mp_obj_t multiprocessing_active_children(void)
         }
     }
 
-    threading_lock_release(&t_mutex);
+    threading_lock_release((thread_lock_t *)(&t_mutex));
     return list;
 }
 

ext_mod/threading/common/src/thread_event.c

@@ -108,7 +108,6 @@ static const mp_rom_map_elem_t event_locals_dict_table[] = {
 
 static MP_DEFINE_CONST_DICT(event_locals_dict, event_locals_dict_table);
 
-
 MP_DEFINE_CONST_OBJ_TYPE(
     mp_type_threading_event_t,
     MP_QSTR_Event,

ext_mod/threading/common/src/thread_semaphore.c

@@ -59,18 +59,18 @@ static mp_obj_t thread_semaphore_acquire(size_t n_args, const mp_obj_t *pos_args
     bool res;
 
     uint16_t
-    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);
+    bool threading_semaphore_acquire(thread_semaphore_t *sem, int32_t wait_ms);
+    void threading_semaphore_release(thread_semaphore_t *sem);
+    void threading_semaphore_init(thread_semaphore_t *sem);
+    void threading_semaphore_delete(thread_semaphore_t *sem);
 
-    uint16_t count = threading_semphamore_get_count(&self->sem);
+    uint16_t count = threading_semaphore_get_count(&self->sem);
 
     if (!blocking) {
         if (count >= self->start_value) {
             res = false;
         } else {
-            res =  threading_semphamore_acquire(&self->sem, 0);
+            res =  threading_semaphore_acquire(&self->sem, 0);
         }
     } else {
         float timeout_f;
@@ -87,7 +87,7 @@ static mp_obj_t thread_semaphore_acquire(size_t n_args, const mp_obj_t *pos_args
             self->waiting += 1;
         }
 
-        res = threading_semphamore_acquire(&self->sem, timeout);
+        res = threading_semaphore_acquire(&self->sem, timeout);
 
         if (res == true) {
             if (self->waiting > 0) {
@@ -140,7 +140,7 @@ static mp_obj_t thread_semaphore_release(size_t n_args, const mp_obj_t *pos_args
         if (self->value > 0) { 
             self->value -= 1;
         }
-        threading_semphamore_release(&self->sem);
+        threading_semaphore_release(&self->sem);
     }
     return mp_const_none;
 }
@@ -165,10 +165,10 @@ static mp_obj_t thread_semaphore__del__(mp_obj_t self_in)
     mp_obj_thread_semaphore_t *self = MP_OBJ_TO_PTR(self_in);
 
     for (uint16_t i=self->value;i<self->start_value;i++) {
-        threading_semphamore_release(&self->sem);
+        threading_semaphore_release(&self->sem);
     }
 
-    threading_semphamore_delete(&self->sem);
+    threading_semaphore_delete(&self->sem);
     return mp_const_none;
 }
 
@@ -204,7 +204,7 @@ static mp_obj_t threading_semaphore_make_new(const mp_obj_type_t *type, size_t n
         return mp_const_none;
     }
 
-    threading_semphamore_init(&self->sem, (uint16_t)start_value)
+    threading_semaphore_init(&self->sem, (uint16_t)start_value)
     self->start_value = (uint16_t)start_value;
 
     return MP_OBJ_FROM_PTR(self);
@@ -267,7 +267,7 @@ static mp_obj_t multiprocessing_semaphore_make_new(const mp_obj_type_t *type, si
         return mp_const_none;
     }
 
-    threading_semphamore_init(&self->sem, (uint16_t)start_value);
+    threading_semaphore_init(&self->sem, (uint16_t)start_value);
     self->start_value = (uint16_t)start_value;
 
     return MP_OBJ_FROM_PTR(self);