Changeset 10944 in vbox for trunk/src/VBox/Runtime/generic/timerlr-generic.cpp

Timestamp:

Jul 29, 2008 6:08:58 PM (17 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

33809

Message:

iprt: RTTimerLR - low resolution timer API (< 10 Hz).

File:

• trunk/src/VBox/Runtime/generic/timerlr-generic.cpp (copied) (copied from trunk/src/VBox/Runtime/generic/timer-generic.cpp ) (14 diffs)

trunk/src/VBox/Runtime/generic/timerlr-generic.cpp

@@ -1 +1 @@
 /** $Id$ */
 /** @file
- * IPRT - Timers, Generic.
+ * IPRT - Low Resolution Timers, Generic.
+ *
+ * This code is more or less identicial to timer-generic.cpp, so
+ * bugfixes goes into both files.
  */
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2008 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -45 +48 @@
 
 
-
 /*******************************************************************************
 *   Structures and Typedefs                                                    *
@@ -52 +54 @@
  * The internal representation of a timer handle.
  */
-typedef struct RTTIMER
+typedef struct RTTIMERLRINT
 {
     /** Magic.
-     * This is RTTIMER_MAGIC, but changes to something else before the timer
+     * This is RTTIMERRT_MAGIC, but changes to something else before the timer
      * is destroyed to indicate clearly that thread should exit. */
     uint32_t volatile       u32Magic;
     /** Flag indicating the the timer is suspended. */
-    uint8_t volatile        fSuspended;
+    bool volatile           fSuspended;
     /** Flag indicating that the timer has been destroyed. */
-    uint8_t volatile        fDestroyed;
+    bool volatile           fDestroyed;
     /** Callback. */
-    PFNRTTIMER              pfnTimer;
+    PFNRTTIMERLR            pfnTimer;
     /** User argument. */
     void                   *pvUser;
     /** The timer thread. */
-    RTTHREAD                Thread;
+    RTTHREAD                hThread;
     /** Event semaphore on which the thread is blocked. */
-    RTSEMEVENT              Event;
+    RTSEMEVENT              hEvent;
     /** The timer interval. 0 if one-shot. */
     uint64_t                u64NanoInterval;
@@ -80 +82 @@
     /** The current tick number (since u64StartTS). */
     uint64_t volatile       iTick;
-} RTTIMER;
+} RTTIMERLRINT;
+typedef RTTIMERLRINT *PRTTIMERLRINT;
 
 
@@ -86 +89 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
-static DECLCALLBACK(int) rtTimerThread(RTTHREAD Thread, void *pvUser);
-
-
-RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, unsigned fFlags, PFNRTTIMER pfnTimer, void *pvUser)
-{
-    *ppTimer = NULL;
-
-    /*
-     * We don't support the fancy MP features.
+static DECLCALLBACK(int) rtTimerLRThread(RTTHREAD hThread, void *pvUser);
+
+
+RTDECL(int) RTTimerLRCreateEx(RTTIMERLR *phTimerLR, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMERLR pfnTimer, void *pvUser)
+{
+    AssertPtr(phTimerLR);
+    *phTimerLR = NIL_RTTIMERLR;
+
+    /*
+     * We don't support the fancy MP features, nor intervals lower than 100 ms.
      */
     if (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
         return VERR_NOT_SUPPORTED;
+    if (u64NanoInterval < 100*1000*1000)
+        return VERR_INVALID_PARAMETER;
 
     /*
      * Allocate and initialize the timer handle.
      */
-    PRTTIMER pTimer = (PRTTIMER)RTMemAlloc(sizeof(*pTimer));
-    if (!pTimer)
+    PRTTIMERLRINT pThis = (PRTTIMERLRINT)RTMemAlloc(sizeof(*pThis));
+    if (!pThis)
         return VERR_NO_MEMORY;
 
-    pTimer->u32Magic = RTTIMER_MAGIC;
-    pTimer->fSuspended = true;
-    pTimer->fDestroyed = false;
-    pTimer->pfnTimer = pfnTimer;
-    pTimer->pvUser = pvUser;
-    pTimer->Thread = NIL_RTTHREAD;
-    pTimer->Event = NIL_RTSEMEVENT;
-    pTimer->u64NanoInterval = u64NanoInterval;
-    pTimer->u64StartTS = 0;
-
-    int rc = RTSemEventCreate(&pTimer->Event);
+    pThis->u32Magic = RTTIMERLR_MAGIC;
+    pThis->fSuspended = true;
+    pThis->fDestroyed = false;
+    pThis->pfnTimer = pfnTimer;
+    pThis->pvUser = pvUser;
+    pThis->hThread = NIL_RTTHREAD;
+    pThis->hEvent = NIL_RTSEMEVENT;
+    pThis->u64NanoInterval = u64NanoInterval;
+    pThis->u64StartTS = 0;
+
+    int rc = RTSemEventCreate(&pThis->hEvent);
     if (RT_SUCCESS(rc))
     {
-        rc = RTThreadCreate(&pTimer->Thread, rtTimerThread, pTimer, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "TIMER");
+        rc = RTThreadCreate(&pThis->hThread, rtTimerLRThread, pThis, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "TIMER");
         if (RT_SUCCESS(rc))
         {
-            *ppTimer = pTimer;
+            *phTimerLR = pThis;
             return VINF_SUCCESS;
         }
 
-        pTimer->u32Magic = 0;
-        RTSemEventDestroy(pTimer->Event);
-        pTimer->Event = NIL_RTSEMEVENT;
+        pThis->u32Magic = 0;
+        RTSemEventDestroy(pThis->hEvent);
+        pThis->hEvent = NIL_RTSEMEVENT;
     }
-    RTMemFree(pTimer);
+    RTMemFree(pThis);
 
     return rc;
@@ -136 +142 @@
 
 
-/**
- * Validates the timer handle.
- *
- * @returns true if valid, false if invalid.
- * @param   pTimer  The handle.
- */
-DECLINLINE(bool) rtTimerIsValid(PRTTIMER pTimer)
-{
-    AssertReturn(VALID_PTR(pTimer), false);
-    AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, false);
-    AssertReturn(!pTimer->fDestroyed, false);
-    return true;
-}
-
-
-RTDECL(int) RTTimerDestroy(PRTTIMER pTimer)
-{
-    /* It's ok to pass NULL pointer. */
-    if (pTimer == /*NIL_RTTIMER*/ NULL)
+RTDECL(int) RTTimerLRDestroy(RTTIMERLR hTimerLR)
+{
+    /*
+     * Validate input, NIL is fine though.
+     */
+    if (hTimerLR == NIL_RTTIMERLR)
         return VINF_SUCCESS;
-    if (!rtTimerIsValid(pTimer))
-        return VERR_INVALID_HANDLE;
+    PRTTIMERLRINT pThis = hTimerLR;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTTIMERLR_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(!pThis->fDestroyed, VERR_INVALID_HANDLE);
 
     /*
@@ -163 +158 @@
      * If it's suspended we can safely set the destroy flag and signal it.
      */
-    RTTHREAD Thread = pTimer->Thread;
-    if (!pTimer->fSuspended)
+    RTTHREAD hThread = pThis->hThread;
+    if (!pThis->fSuspended)
     {
-        ASMAtomicXchgU8(&pTimer->fSuspended, true);
-        ASMAtomicXchgU8(&pTimer->fDestroyed, true);
+        ASMAtomicWriteBool(&pThis->fSuspended, true);
+        ASMAtomicWriteBool(&pThis->fDestroyed, true);
     }
     else
     {
-        ASMAtomicXchgU8(&pTimer->fDestroyed, true);
-        int rc = RTSemEventSignal(pTimer->Event);
+        ASMAtomicWriteBool(&pThis->fDestroyed, true);
+        int rc = RTSemEventSignal(pThis->hEvent);
         if (rc == VERR_ALREADY_POSTED)
             rc = VINF_SUCCESS;
@@ -178 +173 @@
     }
 
-    RTThreadWait(Thread, 250, NULL);
+    RTThreadWait(hThread, 250, NULL);
     return VINF_SUCCESS;
 }
 
 
-RTDECL(int) RTTimerStart(PRTTIMER pTimer, uint64_t u64First)
-{
-    if (!rtTimerIsValid(pTimer))
-        return VERR_INVALID_HANDLE;
-    if (!pTimer->fSuspended)
+RTDECL(int) RTTimerLRStart(RTTIMERLR hTimerLR, uint64_t u64First)
+{
+    /*
+     * Validate input.
+     */
+    PRTTIMERLRINT pThis = hTimerLR;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTTIMERLR_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(!pThis->fDestroyed, VERR_INVALID_HANDLE);
+
+    if (u64First && u64First < 100*1000*1000)
+        return VERR_INVALID_PARAMETER;
+
+    if (!pThis->fSuspended)
         return VERR_TIMER_ACTIVE;
 
@@ -194 +198 @@
      */
     u64First += RTTimeNanoTS();
-    ASMAtomicXchgU64(&pTimer->iTick, 0);
-    ASMAtomicXchgU64(&pTimer->u64StartTS, u64First);
-    ASMAtomicXchgU64(&pTimer->u64NextTS, u64First);
-    ASMAtomicXchgU8(&pTimer->fSuspended, false);
-    int rc = RTSemEventSignal(pTimer->Event);
+    ASMAtomicWriteU64(&pThis->iTick, 0);
+    ASMAtomicWriteU64(&pThis->u64StartTS, u64First);
+    ASMAtomicWriteU64(&pThis->u64NextTS, u64First);
+    ASMAtomicWriteBool(&pThis->fSuspended, false);
+    int rc = RTSemEventSignal(pThis->hEvent);
     if (rc == VERR_ALREADY_POSTED)
         rc = VINF_SUCCESS;
@@ -206 +210 @@
 
 
-RTDECL(int) RTTimerStop(PRTTIMER pTimer)
-{
-    if (!rtTimerIsValid(pTimer))
-        return VERR_INVALID_HANDLE;
-    if (pTimer->fSuspended)
+RTDECL(int) RTTimerLRStop(RTTIMERLR hTimerLR)
+{
+    /*
+     * Validate input.
+     */
+    PRTTIMERLRINT pThis = hTimerLR;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(pThis->u32Magic == RTTIMERLR_MAGIC, VERR_INVALID_HANDLE);
+    AssertReturn(!pThis->fDestroyed, VERR_INVALID_HANDLE);
+
+    if (pThis->fSuspended)
         return VERR_TIMER_SUSPENDED;
 
@@ -216 +226 @@
      * Mark it as suspended and kick the thread.
      */
-    ASMAtomicXchgU8(&pTimer->fSuspended, true);
-    int rc = RTSemEventSignal(pTimer->Event);
+    ASMAtomicWriteBool(&pThis->fSuspended, true);
+    int rc = RTSemEventSignal(pThis->hEvent);
     if (rc == VERR_ALREADY_POSTED)
         rc = VINF_SUCCESS;
@@ -225 +235 @@
 
 
-static DECLCALLBACK(int) rtTimerThread(RTTHREAD Thread, void *pvUser)
-{
-    PRTTIMER pTimer = (PRTTIMER)pvUser;
+static DECLCALLBACK(int) rtTimerLRThread(RTTHREAD hThread, void *pvUser)
+{
+    PRTTIMERLRINT pThis = (PRTTIMERLRINT)pvUser;
 
     /*
      * The loop.
      */
-    while (!pTimer->fDestroyed)
+    while (!ASMAtomicUoReadBool(&pThis->fDestroyed))
     {
-        if (pTimer->fSuspended)
+        if (ASMAtomicUoReadBool(&pThis->fSuspended))
         {
-            int rc = RTSemEventWait(pTimer->Event, RT_INDEFINITE_WAIT);
+            int rc = RTSemEventWait(pThis->hEvent, RT_INDEFINITE_WAIT);
             if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED)
             {
@@ -246 +256 @@
         {
             const uint64_t u64NanoTS = RTTimeNanoTS();
-            if (u64NanoTS >= pTimer->u64NextTS)
+            if (u64NanoTS >= pThis->u64NextTS)
             {
-                pTimer->iTick++;
-                pTimer->pfnTimer(pTimer, pTimer->pvUser, pTimer->iTick);
+                pThis->iTick++;
+                pThis->pfnTimer(pThis, pThis->pvUser, pThis->iTick);
 
                 /* status changed? */
-                if (pTimer->fSuspended || pTimer->fDestroyed)
+                if (    ASMAtomicUoReadBool(&pThis->fSuspended)
+                    ||  ASMAtomicUoReadBool(&pThis->fDestroyed))
                     continue;
 
                 /* one shot? */
-                if (!pTimer->u64NanoInterval)
+                if (!pThis->u64NanoInterval)
                 {
-                    ASMAtomicXchgU8(&pTimer->fSuspended, true);
+                    ASMAtomicWriteBool(&pThis->fSuspended, true);
                     continue;
                 }
 
                 /* calc the next time we should fire. */
-                pTimer->u64NextTS = pTimer->u64StartTS + pTimer->iTick * pTimer->u64NanoInterval;
-                if (pTimer->u64NextTS < u64NanoTS)
+                pThis->u64NextTS = pThis->u64StartTS + pThis->iTick * pThis->u64NanoInterval;
+                if (pThis->u64NextTS < u64NanoTS)
 #ifdef IN_RING3 /* In ring-3 we'll catch up lost ticks immediately. */
-                    pTimer->u64NextTS = u64NanoTS + 1;
+                    pThis->u64NextTS = u64NanoTS + 1;
 #else
-                    pTimer->u64NextTS = u64NanoTS + RTTimerGetSystemGranularity() / 2;
+                    pThis->u64NextTS = u64NanoTS + RTTimerGetSystemGranularity() / 2;
 #endif
             }
 
             /* block. */
-            uint64_t cNanoSeconds = pTimer->u64NextTS - u64NanoTS;
+            uint64_t cNanoSeconds = pThis->u64NextTS - u64NanoTS;
 #ifdef IN_RING3 /* In ring-3 we'll catch up lost ticks immediately. */
             if (cNanoSeconds > 10)
 #endif
             {
-                int rc = RTSemEventWait(pTimer->Event, cNanoSeconds < 1000000 ? 1 : cNanoSeconds / 1000000);
+                int rc = RTSemEventWait(pThis->hEvent, cNanoSeconds < 1000000 ? 1 : cNanoSeconds / 1000000);
                 if (RT_FAILURE(rc) && rc != VERR_INTERRUPTED && rc != VERR_TIMEOUT)
                 {
@@ -291 +302 @@
      * Release the timer resources.
      */
-    ASMAtomicIncU32(&pTimer->u32Magic); /* make the handle invalid. */
-    int rc = RTSemEventDestroy(pTimer->Event); AssertRC(rc);
-    pTimer->Event = NIL_RTSEMEVENT;
-    pTimer->Thread = NIL_RTTHREAD;
-    RTMemFree(pTimer);
+    ASMAtomicWriteU32(&pThis->u32Magic, ~RTTIMERLR_MAGIC); /* make the handle invalid. */
+    int rc = RTSemEventDestroy(pThis->hEvent); AssertRC(rc);
+    pThis->hEvent = NIL_RTSEMEVENT;
+    pThis->hThread = NIL_RTTHREAD;
+    RTMemFree(pThis);
 
     return VINF_SUCCESS;
 }
 
-
-
-
-RTDECL(uint32_t) RTTimerGetSystemGranularity(void)
-{
-    return 10000000; /* 10ms */
-}
-
-
-RTDECL(int) RTTimerRequestSystemGranularity(uint32_t u32Request, uint32_t *pu32Granted)
-{
-    return VERR_NOT_SUPPORTED;
-}
-
-
-RTDECL(int) RTTimerReleaseSystemGranularity(uint32_t u32Granted)
-{
-    return VERR_NOT_SUPPORTED;
-}
-