FreeRTOS threads improvement (#1092)

Author: johnboiles

lib/Simulator/native.cpp

@@ -312,16 +312,6 @@ auto main(int argc, char *argv[]) -> int {
     // Pre-initialize PreferencesStore to point to simprefs.ini
     prefs.begin("simprefs.ini");
 
-    // The FreeRTOS tick handler happens via SIGALRM, and it also kicks off preemptive task
-    // switching, which is not what we want on the main thread, since it's not a real FreeRTOS task.
-    // Just disable SIGALRM on this thread so that it only happens on FreeRTOS tasks.
-    sigset_t mask;
-    sigemptyset(&mask);
-    sigaddset(&mask, SIGALRM);
-    pthread_sigmask(SIG_BLOCK, &mask, NULL);
-
-    vPortSetExternalThread(pthread_self());
-
     // Start the FreeRTOS scheduler
     std::thread schedulerThread([]() {
         // ESP-IDF does `app_main` in a task as well. We need to do this so we can use

lib/Simulator/stubs/freertos-posix/freertos/portmacro.h

@@ -86,7 +86,6 @@ extern void vPortYield( void );
 /*-----------------------------------------------------------*/
 
 /* Critical section management. */
-extern void vPortSetExternalThread( pthread_t externalThread );
 extern void vPortDisableInterrupts( void );
 extern void vPortEnableInterrupts( void );
 #define portSET_INTERRUPT_MASK()        ( vPortDisableInterrupts() )

lib/Simulator/stubs/freertos-posix/src/Source/portable/ThirdParty/GCC/Posix/port.c

@@ -102,14 +102,15 @@ static inline Thread_t * prvGetThreadFromTask( TaskHandle_t xTask )
 
 static pthread_once_t hSigSetupThread = PTHREAD_ONCE_INIT;
 static sigset_t xAllSignals;
-pthread_t xExternalThread;
 static sigset_t xSchedulerOriginalSignalMask;
 static pthread_t hMainThread = ( pthread_t ) NULL;
 static volatile BaseType_t uxCriticalNesting;
 static BaseType_t xSchedulerEnd = pdFALSE;
 static pthread_t hTimerTickThread;
 static bool xTimerTickThreadShouldRun;
 static uint64_t prvStartTimeNs;
+static pthread_mutex_t xThreadMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_key_t xThreadKey = 0;
 /*-----------------------------------------------------------*/
 
 static void prvSetupSignalsAndSchedulerPolicy( void );
@@ -124,6 +125,44 @@ static void vPortStartFirstTask( void );
 static void prvPortYieldFromISR( void );
 /*-----------------------------------------------------------*/
 
+void prvThreadKeyDestructor( void * data )
+{
+    free( data );
+}
+
+static void prvInitThreadKey()
+{
+    pthread_mutex_lock( &xThreadMutex );
+
+    if( xThreadKey == 0 )
+    {
+        pthread_key_create( &xThreadKey, prvThreadKeyDestructor );
+    }
+
+    pthread_mutex_unlock( &xThreadMutex );
+}
+
+static void prvMarkAsFreeRTOSThread( pthread_t thread )
+{
+    prvInitThreadKey();
+    uint8_t * thread_data = malloc( 1 );
+    *thread_data = 1;
+    pthread_setspecific( xThreadKey, thread_data );
+}
+
+static BaseType_t prvIsFreeRTOSThread( pthread_t thread )
+{
+    uint8_t * thread_data = ( uint8_t * ) pthread_getspecific( xThreadKey );
+
+    return thread_data != NULL && *thread_data == 1;
+}
+
+static void prvDestroyThreadKey()
+{
+    pthread_key_delete( xThreadKey );
+}
+/*-----------------------------------------------------------*/
+
 static void prvFatalError( const char * pcCall,
                            int iErrno ) __attribute__( ( __noreturn__ ) );
 
@@ -206,24 +245,27 @@ void vPortStartFirstTask( void )
 /*
  * Clear a signal that is pending for the calling thread.
  */
-void prvClearPendingSignal( int sig ) {
+void prvClearPendingSignal( int sig )
+{
     sigset_t set, oldset;
 
     /* Block the signal */
-    sigemptyset(&set);
-    sigaddset(&set, sig);
-    pthread_sigmask(SIG_BLOCK, &set, &oldset);
+    sigemptyset( &set );
+    sigaddset( &set, sig );
+    pthread_sigmask( SIG_BLOCK, &set, &oldset );
 
     /* Check if signal is pending */
-    sigpending(&set);
-    if (sigismember(&set, sig)) {
+    sigpending( &set );
+
+    if( sigismember( &set, sig ) )
+    {
         int signum;
         /* Wait for and remove signal */
-        sigwait(&set, &signum);
+        sigwait( &set, &signum );
     }
 
     /* Restore the original signal mask */
-    pthread_sigmask(SIG_SETMASK, &oldset, NULL);
+    pthread_sigmask( SIG_SETMASK, &oldset, NULL );
 }
 /*-----------------------------------------------------------*/
 
@@ -267,7 +309,7 @@ BaseType_t xPortStartScheduler( void )
     xSchedulerEnd = pdFALSE;
 
     /* Reset pthread_once_t, needed to restart the scheduler again.
-     * memset the internal struct members for MacOS/Linux Compatability */
+     * memset the internal struct members for MacOS/Linux Compatibility */
     #if __APPLE__
         hSigSetupThread.__sig = _PTHREAD_ONCE_SIG_init;
         memset( ( void * ) &hSigSetupThread.__opaque, 0, sizeof(hSigSetupThread.__opaque));
@@ -281,6 +323,8 @@ BaseType_t xPortStartScheduler( void )
     /* Restore original signal mask. */
     ( void ) pthread_sigmask( SIG_SETMASK, &xSchedulerOriginalSignalMask, NULL );
 
+    prvDestroyThreadKey();
+
     return 0;
 }
 /*-----------------------------------------------------------*/
@@ -298,10 +342,12 @@ void vPortEndScheduler( void )
     ( void ) pthread_kill( hMainThread, SIG_RESUME );
 
     /* Waiting to be deleted here. */
-    if ( xExternalThread != pthread_self() ) {
+    if( prvIsFreeRTOSThread( pthread_self() ) == pdTRUE )
+    {
         pxCurrentThread = prvGetThreadFromTask( xTaskGetCurrentTaskHandle() );
         event_wait( pxCurrentThread->ev );
     }
+
     pthread_testcancel();
 }
 /*-----------------------------------------------------------*/
@@ -354,21 +400,20 @@ void vPortYield( void )
 }
 /*-----------------------------------------------------------*/
 
-void vPortSetExternalThread(pthread_t externalThread) {
-    xExternalThread = externalThread;
-}
-/*-----------------------------------------------------------*/
-
-void vPortDisableInterrupts(void) {
-    if (pthread_self() == xExternalThread) {
+void vPortDisableInterrupts( void )
+{
+    if( prvIsFreeRTOSThread( pthread_self() ) == pdFALSE )
+    {
         return;
     }
     pthread_sigmask(SIG_BLOCK, &xAllSignals, NULL);
 }
 /*-----------------------------------------------------------*/
 
-void vPortEnableInterrupts(void) {
-    if (pthread_self() == xExternalThread) {
+void vPortEnableInterrupts( void )
+{
+    if( prvIsFreeRTOSThread( pthread_self() ) == pdFALSE )
+    {
         return;
     }
     pthread_sigmask(SIG_UNBLOCK, &xAllSignals, NULL);
@@ -407,6 +452,8 @@ static void * prvTimerTickHandler( void * arg )
 {
     ( void ) arg;
 
+    prvMarkAsFreeRTOSThread( pthread_self() );
+
     prvPortSetCurrentThreadName("Scheduler timer");
 
     while( xTimerTickThreadShouldRun )
@@ -439,8 +486,9 @@ void prvSetupTimerInterrupt( void )
 
 static void vPortSystemTickHandler( int sig )
 {
-    if (pthread_self() == xExternalThread) {
-        fprintf(stderr, "vPortSystemTickHandler called from non-FreeRTOS thread\n");
+    if( prvIsFreeRTOSThread( pthread_self() ) == pdFALSE )
+    {
+        fprintf( stderr, "vPortSystemTickHandler called from non-FreeRTOS thread\n" );
         return;
     }
 
@@ -496,6 +544,8 @@ static void * prvWaitForStart( void * pvParams )
 {
     Thread_t * pxThread = pvParams;
 
+    prvMarkAsFreeRTOSThread( pthread_self() );
+
     prvSuspendSelf( pxThread );
 
     /* Resumed for the first time, unblocks all signals. */

lib/Simulator/stubs/freertos-posix/src/Source/portable/ThirdParty/GCC/Posix/portmacro.h

@@ -135,7 +135,7 @@ extern void vPortCancelThread( void * pxTaskToDelete );
  * are always a full memory barrier. ISRs are emulated as signals
  * which also imply a full memory barrier.
  *
- * Thus, only a compilier barrier is needed to prevent the compiler
+ * Thus, only a compiler barrier is needed to prevent the compiler
  * reordering.
  */
 #define portMEMORY_BARRIER()                        __asm volatile ( "" ::: "memory" )