Changeset 6957 in vbox

Timestamp:

Feb 14, 2008 3:10:17 PM (17 years ago)

Author:

vboxsync

Message:

Implemented RTTls on win32.

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (1 diff)
• r3/win/tls-win.cpp (copied) (copied from trunk/src/VBox/Runtime/r3/win/thread-win.cpp ) (2 diffs)

trunk/src/VBox/Runtime/Makefile.kmk

@@ -274 +274 @@
         r3/win/time-win.cpp \
         r3/win/timer-win.cpp \
+        r3/win/tls-win.cpp \
         r3/win/utf16locale-win.cpp \
         r3/win/utf8-win.cpp \

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * innotek Portable Runtime - Threads, Win32.
+ * innotek Portable Runtime - Thread Local Storage (TLS), Win32.
  */
 
 /*
- * 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 <Windows.h>
 
-#include <errno.h>
-#include <process.h>
-
 #include <iprt/thread.h>
 #include <iprt/log.h>
 #include <iprt/assert.h>
-#include <iprt/alloc.h>
-#include <iprt/asm.h>
 #include <iprt/err.h>
 #include "internal/thread.h"
 
 
-/*******************************************************************************
-*   Defined Constants And Macros                                               *
-*******************************************************************************/
-/** The TLS index allocated for storing the RTTHREADINT pointer. */
-static DWORD g_dwSelfTLS = TLS_OUT_OF_INDEXES;
+AssertCompile(sizeof(RTTLS) >= sizeof(DWORD));
 
 
-/*******************************************************************************
-*   Internal Functions                                                         *
-*******************************************************************************/
-static unsigned __stdcall rtThreadNativeMain(void *pvArgs);
-
-
-int rtThreadNativeInit(void)
+RTR3DECL(RTTLS) RTTlsAlloc(void)
 {
-    g_dwSelfTLS = TlsAlloc();
-    if (g_dwSelfTLS == TLS_OUT_OF_INDEXES)
-        return VERR_NO_TLS_FOR_SELF;
-    return VINF_SUCCESS;
+    DWORD iTls = TlsAlloc();
+    return iTls != TLS_OUT_OF_INDEXES ? (RTTLS)iTls : NIL_RTTLS;
 }
 
 
-void rtThreadNativeDetach(void)
+RTR3DECL(int) RTTlsAllocEx(PRTTLS piTls, PFNRTTLSDTOR pfnDestructor)
 {
-    /*
-     * Deal with alien threads.
-     */
-    PRTTHREADINT pThread = (PRTTHREADINT)TlsGetValue(g_dwSelfTLS);
-    if (    pThread
-        &&  (pThread->fIntFlags & RTTHREADINT_FLAGS_ALIEN))
+    AssertReturn(!pfnDestructor, VERR_NOT_SUPPORTED);
+    DWORD iTls = TlsAlloc();
+    if (iTls != TLS_OUT_OF_INDEXES)
     {
-        rtThreadTerminate(pThread, 0);
-        TlsSetValue(g_dwSelfTLS, NULL);
+        Assert((RTTLS)iTls != NIL_RTTLS);
+        *piTls = (RTTLS)iTls;
+        Assert((DWORD)*piTls == iTls);
+        return VINF_SUCCESS;
     }
+
+    return VERR_NO_MEMORY;
 }
 
 
-int rtThreadNativeAdopt(PRTTHREADINT pThread)
+RTR3DECL(int) RTTlsFree(RTTLS iTls)
 {
-    if (!TlsSetValue(g_dwSelfTLS, pThread))
-        return VERR_FAILED_TO_SET_SELF_TLS;
-    return VINF_SUCCESS;
+    if (iTls == NIL_RTTLS)
+        return VINF_SUCCESS;
+    if (TlsFree(iTls))
+        return VINF_SUCCESS;
+    return RTErrConvertFromWin32(GetLastError());
+
 }
 
 
-/**
- * Wrapper which unpacks the param stuff and calls thread function.
- */
-static unsigned __stdcall rtThreadNativeMain(void *pvArgs)
+RTR3DECL(void *) RTTlsGet(RTTLS iTls)
 {
-    DWORD           dwThreadId = GetCurrentThreadId();
-    PRTTHREADINT    pThread = (PRTTHREADINT)pvArgs;
-
-    if (!TlsSetValue(g_dwSelfTLS, pThread))
-        AssertReleaseMsgFailed(("failed to set self TLS. lasterr=%d thread '%s'\n", GetLastError(), pThread->szName));
-
-    int rc = rtThreadMain(pThread, dwThreadId, &pThread->szName[0]);
-
-    TlsSetValue(g_dwSelfTLS, NULL);
-    _endthreadex(rc);
-    return rc;
+    return TlsGetValue(iTls);
 }
 
 
-int rtThreadNativeCreate(PRTTHREADINT pThread, PRTNATIVETHREAD pNativeThread)
+RTR3DECL(int) RTTlsGetEx(RTTLS iTls, void **ppvValue)
 {
-    AssertReturn(pThread->cbStack < ~(unsigned)0, VERR_INVALID_PARAMETER);
-
-    /*
-     * Create the thread.
-     */
-    pThread->hThread = (uintptr_t)INVALID_HANDLE_VALUE;
-    unsigned    uThreadId = 0;
-    uintptr_t   hThread = _beginthreadex(NULL, (unsigned)pThread->cbStack, rtThreadNativeMain, pThread, 0, &uThreadId);
-    if (hThread != 0 && hThread != ~0U)
+    void *pv = TlsGetValue(iTls);
+    if (pv)
     {
-        pThread->hThread = hThread;
-        *pNativeThread = uThreadId;
+        *ppvValue = pv;
         return VINF_SUCCESS;
     }
-    return RTErrConvertFromErrno(errno);
+
+    /* TlsGetValue always updates last error */
+    *ppvValue = NULL;
+    return RTErrConvertFromWin32(GetLastError());
 }
 
 
-RTDECL(RTTHREAD) RTThreadSelf(void)
+RTR3DECL(int) RTTlsSet(RTTLS iTls, void *pvValue)
 {
-    PRTTHREADINT pThread = (PRTTHREADINT)TlsGetValue(g_dwSelfTLS);
-    /** @todo import alien threads ? */
-    return pThread;
+    if (TlsSetValue(iTls, pvValue))
+        return VINF_SUCCESS;
+    return RTErrConvertFromWin32(GetLastError());
 }
 
-
-RTDECL(RTNATIVETHREAD) RTThreadNativeSelf(void)
-{
-    return (RTNATIVETHREAD)GetCurrentThreadId();
-}
-
-
-RTR3DECL(int)   RTThreadSleep(unsigned cMillies)
-{
-    LogFlow(("RTThreadSleep: cMillies=%d\n", cMillies));
-    Sleep(cMillies);
-    LogFlow(("RTThreadSleep: returning %Vrc (cMillies=%d)\n", VINF_SUCCESS, cMillies));
-    return VINF_SUCCESS;
-}
-
-
-RTR3DECL(bool) RTThreadYield(void)
-{
-    uint64_t u64TS = ASMReadTSC();
-    Sleep(0);
-    u64TS = ASMReadTSC() - u64TS;
-    bool fRc = u64TS > 1500;
-    LogFlow(("RTThreadYield: returning %d (%llu ticks)\n", fRc, u64TS));
-    return fRc;
-}
-
-
-#if 0 /* noone is using this ... */
-/**
- * Returns the processor number the current thread was running on during this call
- *
- * @returns processor nr
- */
-static int rtThreadGetCurrentProcessorNumber(void)
-{
-    static bool           fInitialized = false;
-    static DWORD (WINAPI *pfnGetCurrentProcessorNumber)(void) = NULL;
-    if (!fInitialized)
-    {
-        HMODULE hmodKernel32 = GetModuleHandle("KERNEL32.DLL");
-        if (hmodKernel32)
-            pfnGetCurrentProcessorNumber = (DWORD (WINAPI*)(void))GetProcAddress(hmodKernel32, "GetCurrentProcessorNumber");
-        fInitialized = true;
-    }
-    if (pfnGetCurrentProcessorNumber)
-        return pfnGetCurrentProcessorNumber();
-    return -1;
-}
-#endif
-
-
-RTR3DECL(int) RTThreadSetAffinity(uint64_t u64Mask)
-{
-    Assert((DWORD_PTR)u64Mask == u64Mask || u64Mask == ~(uint64_t)0);
-    DWORD dwRet = SetThreadAffinityMask(GetCurrentThread(), (DWORD_PTR)u64Mask);
-    if (dwRet)
-        return VINF_SUCCESS;
-
-    int iLastError = GetLastError();
-    AssertMsgFailed(("SetThreadAffinityMask failed, LastError=%d\n", iLastError));
-    return RTErrConvertFromWin32(iLastError);
-}
-
-
-RTR3DECL(uint64_t) RTThreadGetAffinity(void)
-{
-    /*
-     * Haven't found no query api, but the set api returns the old mask, so let's use that.
-     */
-    DWORD_PTR dwIgnored;
-    DWORD_PTR dwProcAff = 0;
-    if (GetProcessAffinityMask(GetCurrentProcess(), &dwProcAff, &dwIgnored))
-    {
-        HANDLE hThread = GetCurrentThread();
-        DWORD dwRet = SetThreadAffinityMask(hThread, dwProcAff);
-        if (dwRet)
-        {
-            DWORD dwSet = SetThreadAffinityMask(hThread, dwRet);
-            Assert(dwSet == dwProcAff); NOREF(dwRet);
-            return dwRet;
-        }
-    }
-
-    int iLastError = GetLastError();
-    AssertMsgFailed(("SetThreadAffinityMask or GetProcessAffinityMask failed, LastError=%d\n", iLastError));
-    return RTErrConvertFromWin32(iLastError);
-}
-