Implemented ThreadSelf and the surprising amount of plumbing it required. Plus tests and bi

Author: adeyblue

inc/fbthread.bi

@@ -1,3 +1,4 @@
 #pragma once
 
 declare sub ThreadDetach alias "fb_ThreadDetach"( byval thread as any ptr )
+declare function ThreadSelf alias "fb_ThreadSelf"( ) as any ptr

src/rtlib/dos/symb_reg.txt

@@ -405,6 +405,7 @@ extern_asm(_fb_LPrintLongint);
 extern_asm(_fb_ConsoleViewEx);
 extern_asm(_fb_hSetFileBufSize);
 extern_asm(_fb_ThreadCall);
+extern_asm(_fb_ThreadSelf);
 extern_asm(___fb_utf8_offsetsTb);
 extern_asm(_fb_StrFill2);
 extern_asm(_fb_WstrOct_l);
@@ -1245,6 +1246,7 @@ DXE_EXPORT_TABLE (libfb_symbol_table)
     DXE_EXPORT_ASM (_fb_ConsoleViewEx)
     DXE_EXPORT_ASM (_fb_hSetFileBufSize)
     DXE_EXPORT_ASM (_fb_ThreadCall)
+    DXE_EXPORT_ASM (_fb_ThreadSelf)
     DXE_EXPORT_ASM (___fb_utf8_offsetsTb)
     DXE_EXPORT_ASM (_fb_StrFill2)
     DXE_EXPORT_ASM (_fb_WstrOct_l)

src/rtlib/dos/thread_core.c

@@ -8,10 +8,13 @@
 static void *threadproc( void *param )
 {
 	FBTHREADINFO *info = param;
+	FBTHREAD *thread = info->thread;
+
+	FB_TLSGETCTX( FBTHREAD )->self = thread;
 
 	/* call the user thread */
 	info->proc( info->param );
-	free( info);
+	free( info );
 
 	/* free mem */
 	fb_TlsFreeCtxTb( );
@@ -42,6 +45,8 @@ FBCALL FBTHREAD *fb_ThreadCreate( FB_THREADPROC proc, void *param, ssize_t stack
 
 	info->proc = proc;
 	info->param = param;
+	info->thread = thread;
+	thread->flags = 0;
 
 	if( pthread_attr_init( &tattr ) ) {
 		free( thread );
@@ -63,6 +68,7 @@ FBCALL FBTHREAD *fb_ThreadCreate( FB_THREADPROC proc, void *param, ssize_t stack
 	}
 
 	pthread_attr_destroy( &tattr );
+
 	return thread;
 
 #else
@@ -73,14 +79,18 @@ FBCALL FBTHREAD *fb_ThreadCreate( FB_THREADPROC proc, void *param, ssize_t stack
 
 FBCALL void fb_ThreadWait( FBTHREAD *thread )
 {
-
 #if defined ENABLE_MT
-	if( thread == NULL )
+	/* A wait for the main thread or ourselves will never end */
+	if(
+		( thread == NULL ) ||
+		( ( thread->flags & FBTHREAD_MAIN ) != 0 ) ||
+		( thread == FB_TLSGETCTX( FBTHREAD )->self )
+	) {
 		return;
+	}
 
 	pthread_join( thread->id, NULL );
 
 	free( thread );
 #endif
-        
 }

src/rtlib/fb_private_thread.h

@@ -15,13 +15,6 @@
 	};
 #endif
 
-/* Info structure passed to our internal threadproc()s, so it can call the
-   user's threadproc (freed at the end of our threadproc()s) */
-typedef struct {
-	FB_THREADPROC proc;
-	void         *param;
-} FBTHREADINFO;
-
 /* Thread handle returned by threadcreate(), so the caller is able to track the
    thread (freed by threadwait/threaddetach).
 
@@ -33,6 +26,14 @@ typedef struct {
    With pthreads though, it's not clear whether we could store a pthread_t into
    a void*, because pthread_t doesn't have to be an integer or pointer, and
    furthermore, zero may be a valid value for it. */
+
+typedef enum _FBTHREADFLAGS
+{
+	FBTHREAD_MAIN = 1,
+	FBTHREAD_EXITED = 2,
+	FBTHREAD_DETACHED = 4
+} FBTHREADFLAGS;
+
 struct _FBTHREAD {
 #if defined HOST_DOS && defined ENABLE_MT
 	pthread_t id;
@@ -48,4 +49,28 @@ struct _FBTHREAD {
 #else
 #error Unexpected target
 #endif
+	volatile FBTHREADFLAGS flags;
 };
+
+/* Info structure passed to our internal threadproc()s, so it can call the
+   user's threadproc (freed at the end of our threadproc()s) */
+typedef struct {
+	FB_THREADPROC     proc;
+	void             *param;
+	FBTHREAD         *thread;
+} FBTHREADINFO;
+
+typedef struct _FB_FBTHREADCTX
+{
+	FBTHREAD	*self;
+} FB_FBTHREADCTX;
+
+#define fb_FBTHREADCTX_Destructor NULL
+
+void          fb_AllocateMainFBThread( void );
+FBTHREADFLAGS fb_AtomicSetThreadFlags( volatile FBTHREADFLAGS *flags, FBTHREADFLAGS newFlag );
+
+#ifdef ENABLE_MT
+void          fb_CloseAtomicFBThreadFlagMutex( void );
+#endif
+

src/rtlib/fb_thread.h

@@ -10,6 +10,7 @@ struct _FBCOND;
 typedef struct _FBCOND FBCOND;
 
 FBCALL FBTHREAD         *fb_ThreadCreate( FB_THREADPROC proc, void *param, ssize_t stack_size );
+FBCALL FBTHREAD		*fb_ThreadSelf  ( void );
 FBCALL void              fb_ThreadWait  ( FBTHREAD *thread );
 FBCALL void              fb_ThreadDetach( FBTHREAD *thread );
 
@@ -36,6 +37,7 @@ enum {
 	FB_TLSKEY_INPUT,
 	FB_TLSKEY_PRINTUSG,
 	FB_TLSKEY_GFX,
+	FB_TLSKEY_FBTHREAD,
 	FB_TLSKEYS
 };
 
@@ -47,12 +49,12 @@ typedef struct _FB_TLS_CTX_HEADER {
 
 } FB_TLS_CTX_HEADER;
 
-FBCALL void             *fb_TlsGetCtx   ( int index, size_t len, FB_TLS_DESTRUCTOR destructor );
-FBCALL void              fb_TlsDelCtx   ( int index );
-FBCALL void              fb_TlsFreeCtxTb( void );
+FBCALL void             *fb_TlsGetCtx        ( int index, size_t len, FB_TLS_DESTRUCTOR destructor );
+FBCALL void              fb_TlsDelCtx        ( int index );
+FBCALL void              fb_TlsFreeCtxTb     ( void );
 #ifdef ENABLE_MT
-       void              fb_TlsInit     ( void );
-       void              fb_TlsExit     ( void );
+       void              fb_TlsInit          ( void );
+       void              fb_TlsExit          ( void );
 #endif
 
 #define FB_TLSGETCTX(id) ((FB_##id##CTX *)fb_TlsGetCtx( FB_TLSKEY_##id, sizeof( FB_##id##CTX ), fb_##id##CTX_Destructor ))

src/rtlib/init.c

@@ -2,6 +2,7 @@
 
 #include "fb.h"
 #include <locale.h>
+#include "fb_private_thread.h"
 
 FB_RTLIB_CTX __fb_ctx /* not initialized */;
 static int __fb_is_inicnt = 0;
@@ -23,6 +24,7 @@ void fb_hRtInit( void )
 #ifdef ENABLE_MT
 	fb_TlsInit( );
 #endif
+	fb_AllocateMainFBThread();
 
 	/**
 	 * With the default "C" locale (which is just plain 7-bit ASCII),

src/rtlib/thread_ctx.c

@@ -2,8 +2,6 @@
 
 #include "fb.h"
 #include "fb_private_thread.h"
-#include "fb_gfx_private.h"
-#include <assert.h>
 
 #if defined ENABLE_MT && defined HOST_UNIX
 	#define FB_TLSENTRY           pthread_key_t
@@ -55,7 +53,7 @@ FBCALL void *fb_TlsGetCtx( int index, size_t len, FB_TLS_DESTRUCTOR destructorFn
 	else {
 		FB_TLS_CTX_HEADER *ctxHeader = FB_TLS_DATA_TO_HEADER( ctx );
 		/* The && is intentional here so if the assert fires, the message is displayed too */
-		assert( (ctxHeader->destructor == destructorFn) && "fb_TlsGetCtx trying to set different destructor for existing data" );
+		DBG_ASSERT( (ctxHeader->destructor == destructorFn) && "fb_TlsGetCtx trying to set different destructor for existing data" );
 	}
 #endif
 
@@ -102,5 +100,6 @@ void fb_TlsExit( void )
 	for( i = 0; i < FB_TLSKEYS; i++ ) {
 		FB_TLSFREE( __fb_tls_ctxtb[i] );
 	}
+	fb_CloseAtomicFBThreadFlagMutex( );
 }
 #endif

src/rtlib/thread_self.c

@@ -0,0 +1,88 @@
+#include "fb.h"
+#include "fb_private_thread.h"
+
+#define GCC_VERSION (__GNUC__ * 10000 \
+                     + __GNUC_MINOR__ * 100 \
+                     + __GNUC_PATCHLEVEL__)
+
+/* A mutex is massively overkill for atomic int updates, 
+   but we have to support both ancient platforms and build tools
+   so those can use the super slow mutex and everything not 20 years old
+   can use the fast stuff
+
+   GCC 4.1 is the first to implement the atomic builtins, 
+   and InterlockedOr is a macro in the Windows headers for
+   atomic or operations
+
+   NeedsMutex = (EnableMT && (GCC <= 4.0 || !(Windows && InterlockedOr)))
+ */
+#if ( ( defined( ENABLE_MT ) ) && \
+	( ( GCC_VERSION < 40100 ) || \
+	  ( !( defined( HOST_WIN32 ) && defined( InterlockedOr ) ) ) \
+	) \
+)
+#define NEEDS_MUTEX 1
+static FBMUTEX *g_threadFlagMutex = NULL;
+#endif
+
+
+FBCALL FBTHREAD *fb_ThreadSelf( void )
+{
+	return FB_TLSGETCTX( FBTHREAD )->self;
+}
+
+void fb_AllocateMainFBThread( void )
+{
+	/* As TlsGetCtx will allocate a TLS structure and 
+	   space to hold the context, and as the main thread doesn't have
+           its own FBTHREAD* - to avoid making two allocations, 
+           we tell it the context is big enough to cover both
+           and make our own FBTHREAD
+	*/
+	FB_FBTHREADCTX* ctx = fb_TlsGetCtx(
+		FB_TLSKEY_FBTHREAD, 
+		sizeof( *ctx ) + sizeof( *( ctx->self ) ),
+		fb_FBTHREADCTX_Destructor
+	);
+	ctx->self = ( FBTHREAD * )( ctx + 1 );
+	memset( ctx->self, 0, sizeof( *( ctx->self ) ) );
+	ctx->self->flags = FBTHREAD_MAIN;
+
+#ifdef NEEDS_MUTEX
+	g_threadFlagMutex = fb_MutexCreate( );
+#endif
+}
+
+#ifdef ENABLE_MT
+void fb_CloseAtomicFBThreadFlagMutex( void )
+{
+#ifdef NEEDS_MUTEX
+	fb_MutexDestroy( g_threadFlagMutex );
+#endif
+}
+
+FBTHREADFLAGS fb_AtomicSetThreadFlags( volatile FBTHREADFLAGS *threadFlags, FBTHREADFLAGS newFlag )
+{
+
+#ifdef NEEDS_MUTEX
+
+	FBTHREADFLAGS before;
+	fb_MutexLock( g_threadFlagMutex );
+	before = *threadFlags;
+	*threadFlags |= newFlag;
+	fb_MutexUnlock( g_threadFlagMutex );
+	return before;
+
+#else
+
+#if GCC_VERSION >= 40100
+	return __sync_fetch_and_or( threadFlags, newFlag );
+#elif defined ( InterlockedOr )
+	return InterlockedOr( (volatile LONG *) threadFlags, newFlag );
+#endif /* GCC_VERSION */
+
+#endif /* NEEDS_MUTEX */
+
+}
+
+#endif /* ENABLE_MT */

src/rtlib/unix/thread_core.c

@@ -7,13 +7,23 @@
 static void *threadproc( void *param )
 {
 	FBTHREADINFO *info = param;
+	FBTHREAD *thread = info->thread;
+	FBTHREADFLAGS threadFlags;
+
+	FB_TLSGETCTX( FBTHREAD )->self = thread;
 
 	/* call the user thread */
 	info->proc( info->param );
+
 	free( info );
 
 	/* free mem */
 	fb_TlsFreeCtxTb( );
+	threadFlags = fb_AtomicSetThreadFlags( &thread->flags, FBTHREAD_EXITED );
+
+	if( threadFlags & FBTHREAD_DETACHED ) {
+		free( thread );
+	}
 
 	/* don't return NULL or exit() will be called */
 	return (void *)1;
@@ -38,6 +48,8 @@ FBCALL FBTHREAD *fb_ThreadCreate( FB_THREADPROC proc, void *param, ssize_t stack
 
 	info->proc = proc;
 	info->param = param;
+	info->thread = thread;
+	thread->flags = 0;
 
 	if( pthread_attr_init( &tattr ) ) {
 		free( thread );
@@ -64,10 +76,19 @@ FBCALL FBTHREAD *fb_ThreadCreate( FB_THREADPROC proc, void *param, ssize_t stack
 
 FBCALL void fb_ThreadWait( FBTHREAD *thread )
 {
-	if( thread == NULL )
+	/* A wait for the main thread or ourselves will never end 
+	   also, if we've been detached, we've nothing to wait on
+	*/
+	if(
+		( thread == NULL ) ||
+		( ( thread->flags & ( FBTHREAD_MAIN | FBTHREAD_DETACHED ) ) != 0 ) ||
+		( thread == FB_TLSGETCTX( FBTHREAD )->self )
+	) {
 		return;
+	}
 
 	pthread_join( thread->id, NULL );
 
 	free( thread );
 }
+

src/rtlib/unix/thread_detach.c

@@ -3,10 +3,15 @@
 
 FBCALL void fb_ThreadDetach( FBTHREAD *thread )
 {
-	if( thread == NULL )
+	FBTHREADFLAGS flags;
+
+	if( thread == NULL || ( thread->flags & FBTHREAD_MAIN ) )
 		return;
 
+	flags = fb_AtomicSetThreadFlags( &thread->flags, FBTHREAD_DETACHED );
 	pthread_detach( thread->id );
-
-	free( thread );
+	/* This thread has already exited, so clean up */
+	if( flags & FBTHREAD_EXITED ) {
+		free( thread );
+	}
 }