Changeset 6954 in vbox for trunk/src/VBox/Runtime/r3/posix/tls-posix.cpp

Timestamp:

Feb 14, 2008 2:41:39 PM (17 years ago)

Author:

vboxsync

Message:

Implemented RTTls for posix threads.

File:

• trunk/src/VBox/Runtime/r3/posix/tls-posix.cpp (copied) (copied from trunk/src/VBox/Runtime/r3/posix/thread-posix.cpp ) (3 diffs)

trunk/src/VBox/Runtime/r3/posix/tls-posix.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * innotek Portable Runtime - Threads, POSIX.
+ * innotek Portable Runtime - Thread Local Storage (TLS), POSIX.
  */
 
 /*
- * Copyright (C) 2006-2007 innotek GmbH
+ * Copyright (C) 2008 innotek GmbH
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -32 +32 @@
 #include <errno.h>
 #include <pthread.h>
-#include <signal.h>
-#if defined(RT_OS_SOLARIS)
-# include <sched.h>
-#endif
 
 #include <iprt/thread.h>
 #include <iprt/log.h>
 #include <iprt/assert.h>
-#include <iprt/asm.h>
 #include <iprt/err.h>
-#include "internal/thread.h"
 
 
-/*******************************************************************************
-*   Header Files                                                               *
-*******************************************************************************/
-/** The pthread key in which we store the pointer to our own PRTTHREAD structure. */
-static pthread_key_t    g_SelfKey;
+AssertCompile(sizeof(pthread_key_t) == sizeof(RTTLS));
 
 
-/*******************************************************************************
-*   Internal Functions                                                         *
-*******************************************************************************/
-static void *rtThreadNativeMain(void *pvArgs);
-static void rtThreadKeyDestruct(void *pvValue);
-
-
-int rtThreadNativeInit(void)
+RTR3DECL(int) RTTlsAlloc(void)
 {
-    /*
-     * Allocate the TLS (key in posix terms) where we store the pointer to
-     * a threads RTTHREADINT structure.
-     */
-
-    int rc = pthread_key_create(&g_SelfKey, rtThreadKeyDestruct);
+    pthread_key_t iTls = NIL_RTTLS;
+    int rc = pthread_key_create(&iTls, NULL);
     if (!rc)
-        return VINF_SUCCESS;
-    return VERR_NO_TLS_FOR_SELF;
+    {
+        Assert((RTTLS)iTls != NIL_RTTLS);
+        return iTls;
+    }
+    return NIL_RTTLS;
 }
 
 
-/**
- * Destructor called when a thread terminates.
- * @param   pvValue     The key value. PRTTHREAD in our case.
- */
-static void rtThreadKeyDestruct(void *pvValue)
+RTR3DECL(int) RTTlsAllocEx(PRTTLS piTls, PFNRTTLSDTOR pfnDestructor)
 {
-    /*
-     * Deal with alien threads.
-     */
-    PRTTHREADINT pThread = (PRTTHREADINT)pvValue;
-    if (pThread->fIntFlags & RTTHREADINT_FLAGS_ALIEN)
-    {
-        pthread_setspecific(g_SelfKey, pThread);
-        rtThreadTerminate(pThread, 0);
-        pthread_setspecific(g_SelfKey, NULL);
-    }
-}
-
-
-/**
- * Adopts a thread, this is called immediately after allocating the
- * thread structure.
- *
- * @param   pThread     Pointer to the thread structure.
- */
-int rtThreadNativeAdopt(PRTTHREADINT pThread)
-{
-    /*
-     * Block SIGALRM - required for timer-posix.cpp.
-     * This is done to limit harm done by OSes which doesn't do special SIGALRM scheduling.
-     * It will not help much if someone creates threads directly using pthread_create. :/
-     */
-    sigset_t SigSet;
-    sigemptyset(&SigSet);
-    sigaddset(&SigSet, SIGALRM);
-    sigprocmask(SIG_BLOCK, &SigSet, NULL);
-
-    int rc = pthread_setspecific(g_SelfKey, pThread);
-    if (!rc)
-        return VINF_SUCCESS;
-    return VERR_FAILED_TO_SET_SELF_TLS;
-}
-
-
-/**
- * Wrapper which unpacks the params and calls thread function.
- */
-static void *rtThreadNativeMain(void *pvArgs)
-{
-    PRTTHREADINT  pThread = (PRTTHREADINT)pvArgs;
-
-    /*
-     * Block SIGALRM - required for timer-posix.cpp.
-     * This is done to limit harm done by OSes which doesn't do special SIGALRM scheduling.
-     * It will not help much if someone creates threads directly using pthread_create. :/
-     */
-    sigset_t SigSet;
-    sigemptyset(&SigSet);
-    sigaddset(&SigSet, SIGALRM);
-    sigprocmask(SIG_BLOCK, &SigSet, NULL);
-
-    int rc = pthread_setspecific(g_SelfKey, pThread);
-    AssertReleaseMsg(!rc, ("failed to set self TLS. rc=%d thread '%s'\n", rc, pThread->szName));
-
-    /*
-     * Call common main.
-     */
-    pthread_t Self = pthread_self();
-    Assert((uintptr_t)Self == (RTNATIVETHREAD)Self && (uintptr_t)Self != NIL_RTNATIVETHREAD);
-    rc = rtThreadMain(pThread, (uintptr_t)Self, &pThread->szName[0]);
-
-    pthread_setspecific(g_SelfKey, NULL);
-    pthread_exit((void *)rc);
-    return (void *)rc;
-}
-
-
-int rtThreadNativeCreate(PRTTHREADINT pThread, PRTNATIVETHREAD pNativeThread)
-{
-    /*
-     * Set the default stack size.
-     */
-    if (!pThread->cbStack)
-        pThread->cbStack = 512*1024;
-
-    /*
-     * Setup thread attributes.
-     */
-    pthread_attr_t  ThreadAttr;
-    int rc = pthread_attr_init(&ThreadAttr);
+    pthread_key_t iTls = NIL_RTTLS;
+    int rc = pthread_key_create(&iTls, pfnDestructor);
     if (!rc)
     {
-        rc = pthread_attr_setdetachstate(&ThreadAttr, PTHREAD_CREATE_DETACHED);
-        if (!rc)
-        {
-            rc = pthread_attr_setstacksize(&ThreadAttr, pThread->cbStack);
-            if (!rc)
-            {
-                /*
-                 * Create the thread.
-                 */
-                pthread_t ThreadId;
-                rc = pthread_create(&ThreadId, &ThreadAttr, rtThreadNativeMain, pThread);
-                if (!rc)
-                {
-                    *pNativeThread = (uintptr_t)ThreadId;
-                    return VINF_SUCCESS;
-                }
-            }
-        }
-        pthread_attr_destroy(&ThreadAttr);
+        *piTls = iTls;
+        Assert((pthread_key_t)*piTls == iTls);
+        Assert(*piTls != NIL_RTTLS);
+        return VINF_SUCCESS;
     }
     return RTErrConvertFromErrno(rc);
@@ -189 +70 @@
 
 
-RTDECL(RTTHREAD) RTThreadSelf(void)
+RTR3DECL(int) RTTlsFree(RTTLS iTls)
 {
-    PRTTHREADINT pThread = (PRTTHREADINT)pthread_getspecific(g_SelfKey);
-    /** @todo import alien threads? */
-    return pThread;
+    if (iTls == NIL_RTTLS)
+        return VINF_SUCCESS;
+    int rc = pthread_key_delete(iTls);
+    if (!rc)
+        return VINF_SUCCESS;
+    return RTErrConvertFromErrno(rc);
 }
 
 
-RTDECL(RTNATIVETHREAD) RTThreadNativeSelf(void)
+RTR3DECL(void *) RTTlsGet(RTTLS iTls)
 {
-    return (RTNATIVETHREAD)pthread_self();
+    return pthread_getspecific(iTls);
 }
 
 
-RTDECL(int) RTThreadSleep(unsigned cMillies)
+RTR3DECL(int) RTTlsGetEx(RTTLS iTls, void **ppvValue)
 {
-    LogFlow(("RTThreadSleep: cMillies=%d\n", cMillies));
-    if (!cMillies)
-    {
-        /* pthread_yield() isn't part of SuS, thus this fun. */
-#ifdef RT_OS_DARWIN
-        pthread_yield_np();
-#elif defined(RT_OS_FREEBSD) /* void pthread_yield */
-        pthread_yield();
-#elif defined(RT_OS_SOLARIS)
-        sched_yield();
-#else
-        if (!pthread_yield())
-#endif
-        {
-            LogFlow(("RTThreadSleep: returning %Vrc (cMillies=%d)\n", VINF_SUCCESS, cMillies));
-            return VINF_SUCCESS;
-        }
-    }
-    else
-    {
-        struct timespec ts;
-        struct timespec tsrem = {0,0};
-
-        ts.tv_nsec = (cMillies % 1000) * 1000000;
-        ts.tv_sec  = cMillies / 1000;
-        if (!nanosleep(&ts, &tsrem))
-        {
-            LogFlow(("RTThreadSleep: returning %Vrc (cMillies=%d)\n", VINF_SUCCESS, cMillies));
-            return VINF_SUCCESS;
-        }
-    }
-
-    int rc = RTErrConvertFromErrno(errno);
-    LogFlow(("RTThreadSleep: returning %Vrc (cMillies=%d)\n", rc, cMillies));
-    return rc;
+    if (RT_UNLIKELY(iTls == NIL_RTTLS))
+        return VERR_INVALID_PARAMETER;
+    *ppvValue = pthread_getspecific(iTls);
+    return VINF_SUCCESS;
 }
 
 
-RTDECL(bool) RTThreadYield(void)
+RTR3DECL(int) RTTlsSet(RTTLS iTls, void *pvValue)
 {
-    uint64_t u64TS = ASMReadTSC();
-#ifdef RT_OS_DARWIN
-    pthread_yield_np();
-#elif defined(RT_OS_SOLARIS)
-    sched_yield();
-#else
-    pthread_yield();
-#endif
-    u64TS = ASMReadTSC() - u64TS;
-    bool fRc = u64TS > 1500;
-    LogFlow(("RTThreadYield: returning %d (%llu ticks)\n", fRc, u64TS));
-    return fRc;
-}
-
-
-RTR3DECL(uint64_t) RTThreadGetAffinity(void)
-{
-    return 1;
-}
-
-
-RTR3DECL(int) RTThreadSetAffinity(uint64_t u64Mask)
-{
-    if (u64Mask != 1)
-        return VERR_INVALID_PARAMETER;
+    int rc = pthread_setspecific(iTls, pvValue);
+    if (RT_UNLIKELY(rc != 0))
+        return RTErrConvertFromErrno(rc);
     return VINF_SUCCESS;
 }