LCOV - code coverage report
Current view: top level - ports/unix - mpthreadport.c (source / functions) Hit Total Coverage
Test: unix_coverage_v1.19.1-740-gbf49a087b.info Lines: 122 131 93.1 %
Date: 2022-12-09 11:55:04 Functions: 14 14 100.0 %
Branches: 32 44 72.7 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * This file is part of the MicroPython project, http://micropython.org/
       3                 :            :  *
       4                 :            :  * The MIT License (MIT)
       5                 :            :  *
       6                 :            :  * Copyright (c) 2016 Damien P. George on behalf of Pycom Ltd
       7                 :            :  *
       8                 :            :  * Permission is hereby granted, free of charge, to any person obtaining a copy
       9                 :            :  * of this software and associated documentation files (the "Software"), to deal
      10                 :            :  * in the Software without restriction, including without limitation the rights
      11                 :            :  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
      12                 :            :  * copies of the Software, and to permit persons to whom the Software is
      13                 :            :  * furnished to do so, subject to the following conditions:
      14                 :            :  *
      15                 :            :  * The above copyright notice and this permission notice shall be included in
      16                 :            :  * all copies or substantial portions of the Software.
      17                 :            :  *
      18                 :            :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      19                 :            :  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      20                 :            :  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
      21                 :            :  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      22                 :            :  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
      23                 :            :  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
      24                 :            :  * THE SOFTWARE.
      25                 :            :  */
      26                 :            : 
      27                 :            : #include <stdio.h>
      28                 :            : #include <stdlib.h>
      29                 :            : #include <errno.h>
      30                 :            : 
      31                 :            : #include "py/runtime.h"
      32                 :            : #include "py/mpthread.h"
      33                 :            : #include "py/gc.h"
      34                 :            : 
      35                 :            : #if MICROPY_PY_THREAD
      36                 :            : 
      37                 :            : #include <fcntl.h>
      38                 :            : #include <signal.h>
      39                 :            : #include <sched.h>
      40                 :            : #include <semaphore.h>
      41                 :            : 
      42                 :            : #include "shared/runtime/gchelper.h"
      43                 :            : 
      44                 :            : // Some platforms don't have SIGRTMIN but if we do have it, use it to avoid
      45                 :            : // potential conflict with other uses of the more commonly used SIGUSR1.
      46                 :            : #ifdef SIGRTMIN
      47                 :            : #define MP_THREAD_GC_SIGNAL (SIGRTMIN + 5)
      48                 :            : #else
      49                 :            : #define MP_THREAD_GC_SIGNAL (SIGUSR1)
      50                 :            : #endif
      51                 :            : 
      52                 :            : // This value seems to be about right for both 32-bit and 64-bit builds.
      53                 :            : #define THREAD_STACK_OVERFLOW_MARGIN (8192)
      54                 :            : 
      55                 :            : // this structure forms a linked list, one node per active thread
      56                 :            : typedef struct _mp_thread_t {
      57                 :            :     pthread_t id;           // system id of thread
      58                 :            :     int ready;              // whether the thread is ready and running
      59                 :            :     void *arg;              // thread Python args, a GC root pointer
      60                 :            :     struct _mp_thread_t *next;
      61                 :            : } mp_thread_t;
      62                 :            : 
      63                 :            : STATIC pthread_key_t tls_key;
      64                 :            : 
      65                 :            : // The mutex is used for any code in this port that needs to be thread safe.
      66                 :            : // Specifically for thread management, access to the linked list is one example.
      67                 :            : // But also, e.g. scheduler state.
      68                 :            : STATIC pthread_mutex_t thread_mutex;
      69                 :            : STATIC mp_thread_t *thread;
      70                 :            : 
      71                 :            : // this is used to synchronise the signal handler of the thread
      72                 :            : // it's needed because we can't use any pthread calls in a signal handler
      73                 :            : #if defined(__APPLE__)
      74                 :            : STATIC char thread_signal_done_name[25];
      75                 :            : STATIC sem_t *thread_signal_done_p;
      76                 :            : #else
      77                 :            : STATIC sem_t thread_signal_done;
      78                 :            : #endif
      79                 :            : 
      80                 :      63268 : void mp_thread_unix_begin_atomic_section(void) {
      81                 :      63268 :     pthread_mutex_lock(&thread_mutex);
      82                 :      63297 : }
      83                 :            : 
      84                 :      63297 : void mp_thread_unix_end_atomic_section(void) {
      85                 :      63297 :     pthread_mutex_unlock(&thread_mutex);
      86                 :      63293 : }
      87                 :            : 
      88                 :            : // this signal handler is used to scan the regs and stack of a thread
      89                 :        120 : STATIC void mp_thread_gc(int signo, siginfo_t *info, void *context) {
      90                 :        120 :     (void)info; // unused
      91                 :        120 :     (void)context; // unused
      92         [ +  - ]:        120 :     if (signo == MP_THREAD_GC_SIGNAL) {
      93                 :        120 :         gc_helper_collect_regs_and_stack();
      94                 :            :         // We have access to the context (regs, stack) of the thread but it seems
      95                 :            :         // that we don't need the extra information, enough is captured by the
      96                 :            :         // gc_collect_regs_and_stack function above
      97                 :            :         // gc_collect_root((void**)context, sizeof(ucontext_t) / sizeof(uintptr_t));
      98                 :            :         #if MICROPY_ENABLE_PYSTACK
      99                 :            :         void **ptrs = (void **)(void *)MP_STATE_THREAD(pystack_start);
     100                 :            :         gc_collect_root(ptrs, (MP_STATE_THREAD(pystack_cur) - MP_STATE_THREAD(pystack_start)) / sizeof(void *));
     101                 :            :         #endif
     102                 :            :         #if defined(__APPLE__)
     103                 :            :         sem_post(thread_signal_done_p);
     104                 :            :         #else
     105                 :        120 :         sem_post(&thread_signal_done);
     106                 :            :         #endif
     107                 :            :     }
     108                 :        120 : }
     109                 :            : 
     110                 :       3206 : void mp_thread_init(void) {
     111                 :       3206 :     pthread_key_create(&tls_key, NULL);
     112                 :       3206 :     pthread_setspecific(tls_key, &mp_state_ctx.thread);
     113                 :            : 
     114                 :            :     // Needs to be a recursive mutex to emulate the behavior of
     115                 :            :     // BEGIN_ATOMIC_SECTION on bare metal.
     116                 :       3206 :     pthread_mutexattr_t thread_mutex_attr;
     117                 :       3206 :     pthread_mutexattr_init(&thread_mutex_attr);
     118                 :       3206 :     pthread_mutexattr_settype(&thread_mutex_attr, PTHREAD_MUTEX_RECURSIVE);
     119                 :       3206 :     pthread_mutex_init(&thread_mutex, &thread_mutex_attr);
     120                 :            : 
     121                 :            :     // create first entry in linked list of all threads
     122                 :       3206 :     thread = malloc(sizeof(mp_thread_t));
     123                 :       3206 :     thread->id = pthread_self();
     124                 :       3206 :     thread->ready = 1;
     125                 :       3206 :     thread->arg = NULL;
     126                 :       3206 :     thread->next = NULL;
     127                 :            : 
     128                 :            :     #if defined(__APPLE__)
     129                 :            :     snprintf(thread_signal_done_name, sizeof(thread_signal_done_name), "micropython_sem_%ld", (long)thread->id);
     130                 :            :     thread_signal_done_p = sem_open(thread_signal_done_name, O_CREAT | O_EXCL, 0666, 0);
     131                 :            :     #else
     132                 :       3206 :     sem_init(&thread_signal_done, 0, 0);
     133                 :            :     #endif
     134                 :            : 
     135                 :            :     // enable signal handler for garbage collection
     136                 :       3206 :     struct sigaction sa;
     137                 :       3206 :     sa.sa_flags = SA_SIGINFO;
     138                 :       3206 :     sa.sa_sigaction = mp_thread_gc;
     139                 :       3206 :     sigemptyset(&sa.sa_mask);
     140                 :       3206 :     sigaction(MP_THREAD_GC_SIGNAL, &sa, NULL);
     141                 :       3206 : }
     142                 :            : 
     143                 :       3202 : void mp_thread_deinit(void) {
     144                 :       3202 :     mp_thread_unix_begin_atomic_section();
     145         [ +  + ]:       3212 :     while (thread->next != NULL) {
     146                 :         10 :         mp_thread_t *th = thread;
     147                 :         10 :         thread = thread->next;
     148                 :         10 :         pthread_cancel(th->id);
     149                 :         10 :         free(th);
     150                 :            :     }
     151                 :       3202 :     mp_thread_unix_end_atomic_section();
     152                 :            :     #if defined(__APPLE__)
     153                 :            :     sem_close(thread_signal_done_p);
     154                 :            :     sem_unlink(thread_signal_done_name);
     155                 :            :     #endif
     156         [ -  + ]:       3202 :     assert(thread->id == pthread_self());
     157                 :       3202 :     free(thread);
     158                 :       3202 : }
     159                 :            : 
     160                 :            : // This function scans all pointers that are external to the current thread.
     161                 :            : // It does this by signalling all other threads and getting them to scan their
     162                 :            : // own registers and stack.  Note that there may still be some edge cases left
     163                 :            : // with race conditions and root-pointer scanning: a given thread may manipulate
     164                 :            : // the global root pointers (in mp_state_ctx) while another thread is doing a
     165                 :            : // garbage collection and tracing these pointers.
     166                 :      12709 : void mp_thread_gc_others(void) {
     167                 :      12709 :     mp_thread_unix_begin_atomic_section();
     168         [ +  + ]:      25594 :     for (mp_thread_t *th = thread; th != NULL; th = th->next) {
     169                 :      12885 :         gc_collect_root(&th->arg, 1);
     170         [ +  + ]:      12885 :         if (th->id == pthread_self()) {
     171                 :      12709 :             continue;
     172                 :            :         }
     173         [ +  + ]:        176 :         if (!th->ready) {
     174                 :         56 :             continue;
     175                 :            :         }
     176                 :        120 :         pthread_kill(th->id, MP_THREAD_GC_SIGNAL);
     177                 :            :         #if defined(__APPLE__)
     178                 :            :         sem_wait(thread_signal_done_p);
     179                 :            :         #else
     180                 :        120 :         sem_wait(&thread_signal_done);
     181                 :            :         #endif
     182                 :            :     }
     183                 :      12709 :     mp_thread_unix_end_atomic_section();
     184                 :      12709 : }
     185                 :            : 
     186                 :   75775347 : mp_state_thread_t *mp_thread_get_state(void) {
     187                 :   75775347 :     return (mp_state_thread_t *)pthread_getspecific(tls_key);
     188                 :            : }
     189                 :            : 
     190                 :        590 : void mp_thread_set_state(mp_state_thread_t *state) {
     191                 :        590 :     pthread_setspecific(tls_key, state);
     192                 :        590 : }
     193                 :            : 
     194                 :        590 : void mp_thread_start(void) {
     195                 :            :     // enable realtime priority if `-X realtime` command line parameter was set
     196                 :            :     #if defined(__APPLE__)
     197                 :            :     if (mp_thread_is_realtime_enabled) {
     198                 :            :         mp_thread_set_realtime();
     199                 :            :     }
     200                 :            :     #endif
     201                 :            : 
     202                 :        590 :     pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
     203                 :        590 :     mp_thread_unix_begin_atomic_section();
     204         [ +  - ]:      11214 :     for (mp_thread_t *th = thread; th != NULL; th = th->next) {
     205         [ +  + ]:      11214 :         if (th->id == pthread_self()) {
     206                 :        590 :             th->ready = 1;
     207                 :        590 :             break;
     208                 :            :         }
     209                 :            :     }
     210                 :        590 :     mp_thread_unix_end_atomic_section();
     211                 :        590 : }
     212                 :            : 
     213                 :        590 : void mp_thread_create(void *(*entry)(void *), void *arg, size_t *stack_size) {
     214                 :            :     // default stack size is 8k machine-words
     215         [ +  + ]:        590 :     if (*stack_size == 0) {
     216                 :        588 :         *stack_size = 8192 * sizeof(void *);
     217                 :            :     }
     218                 :            : 
     219                 :            :     // minimum stack size is set by pthreads
     220         [ +  + ]:        590 :     if (*stack_size < PTHREAD_STACK_MIN) {
     221                 :          2 :         *stack_size = PTHREAD_STACK_MIN;
     222                 :            :     }
     223                 :            : 
     224                 :            :     // ensure there is enough stack to include a stack-overflow margin
     225         [ -  + ]:        590 :     if (*stack_size < 2 * THREAD_STACK_OVERFLOW_MARGIN) {
     226                 :          0 :         *stack_size = 2 * THREAD_STACK_OVERFLOW_MARGIN;
     227                 :            :     }
     228                 :            : 
     229                 :            :     // set thread attributes
     230                 :        590 :     pthread_attr_t attr;
     231                 :        590 :     int ret = pthread_attr_init(&attr);
     232         [ -  + ]:        590 :     if (ret != 0) {
     233                 :          0 :         goto er;
     234                 :            :     }
     235                 :        590 :     ret = pthread_attr_setstacksize(&attr, *stack_size);
     236         [ -  + ]:        590 :     if (ret != 0) {
     237                 :          0 :         goto er;
     238                 :            :     }
     239                 :            : 
     240                 :        590 :     ret = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
     241         [ -  + ]:        590 :     if (ret != 0) {
     242                 :          0 :         goto er;
     243                 :            :     }
     244                 :            : 
     245                 :        590 :     mp_thread_unix_begin_atomic_section();
     246                 :            : 
     247                 :            :     // create thread
     248                 :        590 :     pthread_t id;
     249                 :        590 :     ret = pthread_create(&id, &attr, entry, arg);
     250         [ -  + ]:        590 :     if (ret != 0) {
     251                 :          0 :         mp_thread_unix_end_atomic_section();
     252                 :          0 :         goto er;
     253                 :            :     }
     254                 :            : 
     255                 :            :     // adjust stack_size to provide room to recover from hitting the limit
     256                 :        590 :     *stack_size -= THREAD_STACK_OVERFLOW_MARGIN;
     257                 :            : 
     258                 :            :     // add thread to linked list of all threads
     259                 :        590 :     mp_thread_t *th = malloc(sizeof(mp_thread_t));
     260                 :        590 :     th->id = id;
     261                 :        590 :     th->ready = 0;
     262                 :        590 :     th->arg = arg;
     263                 :        590 :     th->next = thread;
     264                 :        590 :     thread = th;
     265                 :            : 
     266                 :        590 :     mp_thread_unix_end_atomic_section();
     267                 :            : 
     268                 :        590 :     return;
     269                 :            : 
     270                 :          0 : er:
     271                 :          0 :     mp_raise_OSError(ret);
     272                 :            : }
     273                 :            : 
     274                 :        582 : void mp_thread_finish(void) {
     275                 :        582 :     mp_thread_unix_begin_atomic_section();
     276                 :        580 :     mp_thread_t *prev = NULL;
     277         [ +  - ]:      11764 :     for (mp_thread_t *th = thread; th != NULL; th = th->next) {
     278         [ +  + ]:      11764 :         if (th->id == pthread_self()) {
     279         [ +  + ]:        580 :             if (prev == NULL) {
     280                 :         49 :                 thread = th->next;
     281                 :            :             } else {
     282                 :        531 :                 prev->next = th->next;
     283                 :            :             }
     284                 :        580 :             free(th);
     285                 :        580 :             break;
     286                 :            :         }
     287                 :      11184 :         prev = th;
     288                 :            :     }
     289                 :        580 :     mp_thread_unix_end_atomic_section();
     290                 :        580 : }
     291                 :            : 
     292                 :      10525 : void mp_thread_mutex_init(mp_thread_mutex_t *mutex) {
     293                 :      10525 :     pthread_mutex_init(mutex, NULL);
     294                 :      10525 : }
     295                 :            : 
     296                 :    5015549 : int mp_thread_mutex_lock(mp_thread_mutex_t *mutex, int wait) {
     297                 :    5015549 :     int ret;
     298         [ +  + ]:    5015549 :     if (wait) {
     299                 :    5015548 :         ret = pthread_mutex_lock(mutex);
     300         [ -  + ]:    5018747 :         if (ret == 0) {
     301                 :            :             return 1;
     302                 :            :         }
     303                 :            :     } else {
     304                 :          1 :         ret = pthread_mutex_trylock(mutex);
     305         [ +  - ]:          1 :         if (ret == 0) {
     306                 :            :             return 1;
     307         [ -  + ]:          1 :         } else if (ret == EBUSY) {
     308                 :            :             return 0;
     309                 :            :         }
     310                 :            :     }
     311                 :          0 :     return -ret;
     312                 :            : }
     313                 :            : 
     314                 :    5018744 : void mp_thread_mutex_unlock(mp_thread_mutex_t *mutex) {
     315                 :    5018744 :     pthread_mutex_unlock(mutex);
     316                 :            :     // TODO check return value
     317                 :    5018523 : }
     318                 :            : 
     319                 :            : #endif // MICROPY_PY_THREAD
     320                 :            : 
     321                 :            : // this is used even when MICROPY_PY_THREAD is disabled
     322                 :            : 
     323                 :            : #if defined(__APPLE__)
     324                 :            : #include <mach/mach_error.h>
     325                 :            : #include <mach/mach_time.h>
     326                 :            : #include <mach/thread_act.h>
     327                 :            : #include <mach/thread_policy.h>
     328                 :            : 
     329                 :            : bool mp_thread_is_realtime_enabled;
     330                 :            : 
     331                 :            : // based on https://developer.apple.com/library/archive/technotes/tn2169/_index.html
     332                 :            : void mp_thread_set_realtime(void) {
     333                 :            :     mach_timebase_info_data_t timebase_info;
     334                 :            : 
     335                 :            :     mach_timebase_info(&timebase_info);
     336                 :            : 
     337                 :            :     const uint64_t NANOS_PER_MSEC = 1000000ULL;
     338                 :            :     double clock2abs = ((double)timebase_info.denom / (double)timebase_info.numer) * NANOS_PER_MSEC;
     339                 :            : 
     340                 :            :     thread_time_constraint_policy_data_t policy;
     341                 :            :     policy.period = 0;
     342                 :            :     policy.computation = (uint32_t)(5 * clock2abs); // 5 ms of work
     343                 :            :     policy.constraint = (uint32_t)(10 * clock2abs);
     344                 :            :     policy.preemptible = FALSE;
     345                 :            : 
     346                 :            :     int kr = thread_policy_set(pthread_mach_thread_np(pthread_self()),
     347                 :            :         THREAD_TIME_CONSTRAINT_POLICY,
     348                 :            :         (thread_policy_t)&policy,
     349                 :            :         THREAD_TIME_CONSTRAINT_POLICY_COUNT);
     350                 :            : 
     351                 :            :     if (kr != KERN_SUCCESS) {
     352                 :            :         mach_error("thread_policy_set:", kr);
     353                 :            :     }
     354                 :            : }
     355                 :            : #endif

Generated by: LCOV version 1.15-5-g462f71d