Changeset 32277 in vbox

Timestamp:

Sep 7, 2010 11:34:55 AM (14 years ago)

Author:

vboxsync

Message:

DrvVD: Implement alternate select interface for Windows XP to avoid the 15ms delay when waiting for the socket to become writable

Location:

trunk

Files:

• include/VBox/VBoxHDD.h (modified) (1 diff)
• src/VBox/Devices/Storage/DrvVD.cpp (modified) (7 diffs)

trunk/include/VBox/VBoxHDD.h

@@ -1031 +1031 @@
 /** Error condition, hangup, exception or similar. */
 #define VD_INTERFACETCPNET_EVT_ERROR        RT_BIT_32(2)
+/** Hint for the select that getting interrupted while waiting is more likely.
+ * The interface implementation can optimize the waiting strategy based on this.
+ * It is assumed that it is more likely to get one of the above socket events
+ * instead of being interrupted if the flag is not set. */
+#define VD_INTERFACETCPNET_HINT_INTERRUPT   RT_BIT_32(3)
 /** Mask of the valid bits. */
-#define VD_INTERFACETCPNET_EVT_VALID_MASK   UINT32_C(0x00000007)
+#define VD_INTERFACETCPNET_EVT_VALID_MASK   UINT32_C(0x0000000f)
 /** @} */
 

trunk/src/VBox/Devices/Storage/DrvVD.cpp

@@ -35 +35 @@
 #include <iprt/poll.h>
 #include <iprt/pipe.h>
+#include <iprt/system.h>
 
 #ifdef VBOX_WITH_INIP
@@ -1002 +1003 @@
         }
     }
+    else
+    {
+        *pSock = pSockInt;
+        return VINF_SUCCESS;
+    }
 
     RTMemFree(pSockInt);
@@ -1020 +1026 @@
         {
             rc = RTPollSetRemove(pSockInt->hPollSet, VDSOCKET_POLL_ID_SOCKET);
-            AssertRC(rc);
+            Assert(RT_SUCCESS(rc) || rc == VERR_POLL_HANDLE_ID_NOT_FOUND);
         }
         rc = RTPollSetRemove(pSockInt->hPollSet, VDSOCKET_POLL_ID_PIPE);
@@ -1056 +1062 @@
             rc = RTPollSetAddSocket(pSockInt->hPollSet, pSockInt->hSocket,
                                     pSockInt->fEventsOld, VDSOCKET_POLL_ID_SOCKET);
-
-            if (RT_SUCCESS(rc))
-                return VINF_SUCCESS;
-        }
+        }
+
+        if (RT_SUCCESS(rc))
+            return VINF_SUCCESS;
 
         rc = RTTcpClientClose(pSockInt->hSocket);
@@ -1181 +1187 @@
 }
 
-/** @copydoc VDINTERFACETCPNET::pfnSelectOneEx */
-static DECLCALLBACK(int) drvvdTcpSelectOneEx(VDSOCKET Sock, uint32_t fEvents,
-                                             uint32_t *pfEvents, RTMSINTERVAL cMillies)
+static int drvvdTcpSelectOneExPoll(VDSOCKET Sock, uint32_t fEvents,
+                                   uint32_t *pfEvents, RTMSINTERVAL cMillies)
 {
     int rc = VINF_SUCCESS;
@@ -1252 +1257 @@
         }
     }
+
+    return rc;
+}
+
+/** @copydoc VDINTERFACETCPNET::pfnSelectOneEx */
+static DECLCALLBACK(int) drvvdTcpSelectOneExNoPoll(VDSOCKET Sock, uint32_t fEvents,
+                                                   uint32_t *pfEvents, RTMSINTERVAL cMillies)
+{
+    int rc = VINF_SUCCESS;
+    PVDSOCKETINT pSockInt = (PVDSOCKETINT)Sock;
+
+    *pfEvents = 0;
+
+    ASMAtomicXchgBool(&pSockInt->fWaiting, true);
+    if (ASMAtomicXchgBool(&pSockInt->fWokenUp, false))
+    {
+        ASMAtomicXchgBool(&pSockInt->fWaiting, false);
+        return VERR_INTERRUPTED;
+    }
+
+    if (   pSockInt->hSocket == NIL_RTSOCKET
+        || !fEvents)
+    {
+        /*
+         * Only the pipe is configured or the caller doesn't wait for a socket event,
+         * wait until there is something to read from the pipe.
+         */
+        size_t cbRead = 0;
+        char ch = 0;
+        rc = RTPipeReadBlocking(pSockInt->hPipeR, &ch, 1, &cbRead);
+        if (RT_SUCCESS(rc))
+        {
+            Assert(cbRead == 1);
+            rc = VERR_INTERRUPTED;
+            ASMAtomicXchgBool(&pSockInt->fWokenUp, false);
+        }
+    }
+    else
+    {
+        uint32_t fSelectEvents = 0;
+
+        if (fEvents & VD_INTERFACETCPNET_EVT_READ)
+            fSelectEvents |= RTSOCKET_EVT_READ;
+        if (fEvents & VD_INTERFACETCPNET_EVT_WRITE)
+            fSelectEvents |= RTSOCKET_EVT_WRITE;
+        if (fEvents & VD_INTERFACETCPNET_EVT_ERROR)
+            fSelectEvents |= RTSOCKET_EVT_ERROR;
+
+        if (fEvents & VD_INTERFACETCPNET_HINT_INTERRUPT)
+        {
+            uint32_t fEventsRecv = 0;
+
+            /* Make sure the socket is not in the pollset. */
+            rc = RTPollSetRemove(pSockInt->hPollSet, VDSOCKET_POLL_ID_SOCKET);
+            Assert(RT_SUCCESS(rc) || rc == VERR_POLL_HANDLE_ID_NOT_FOUND);
+
+            for (;;)
+            {
+                uint32_t id = 0;
+                rc = RTPoll(pSockInt->hPollSet, 5, &fEvents, &id);
+                if (rc == VERR_TIMEOUT)
+                {
+                    /* Check the socket. */
+                    rc = RTTcpSelectOneEx(pSockInt->hSocket, fSelectEvents, &fEventsRecv, 0);
+                    if (RT_SUCCESS(rc))
+                    {
+                        if (fEventsRecv & RTSOCKET_EVT_READ)
+                            *pfEvents |= VD_INTERFACETCPNET_EVT_READ;
+                        if (fEventsRecv & RTSOCKET_EVT_WRITE)
+                            *pfEvents |= VD_INTERFACETCPNET_EVT_WRITE;
+                        if (fEventsRecv & RTSOCKET_EVT_ERROR)
+                            *pfEvents |= VD_INTERFACETCPNET_EVT_ERROR;
+                        break; /* Quit */
+                    }
+                    else if (rc != VERR_TIMEOUT)
+                        break;
+                }
+                else if (RT_SUCCESS(rc))
+                {
+                    size_t cbRead = 0;
+                    uint8_t abBuf[10];
+                    Assert(id == VDSOCKET_POLL_ID_PIPE);
+                    Assert((fEventsRecv & RTPOLL_EVT_VALID_MASK) == RTPOLL_EVT_READ);
+
+                    /* We got interrupted, drain the pipe. */
+                    rc = RTPipeRead(pSockInt->hPipeR, abBuf, sizeof(abBuf), &cbRead);
+                    AssertRC(rc);
+
+                    ASMAtomicXchgBool(&pSockInt->fWokenUp, false);
+
+                    rc = VERR_INTERRUPTED;
+                    break;
+                }
+                else
+                    break;
+            }
+        }
+        else /* The caller waits for a socket event. */
+        {
+            uint32_t fEventsRecv = 0;
+
+            /* Loop until we got woken up or a socket event occurred. */
+            for (;;)
+            {
+                /** @todo find an adaptive wait algorithm based on the
+                 * number of wakeups in the past. */
+                rc = RTTcpSelectOneEx(pSockInt->hSocket, fSelectEvents, &fEventsRecv, 5);
+                if (rc == VERR_TIMEOUT)
+                {
+                    /* Check if there is an event pending. */
+                    size_t cbRead = 0;
+                    char ch = 0;
+                    rc = RTPipeRead(pSockInt->hPipeR, &ch, 1, &cbRead);
+                    if (RT_SUCCESS(rc) && rc != VINF_TRY_AGAIN)
+                    {
+                        Assert(cbRead == 1);
+                        rc = VERR_INTERRUPTED;
+                        ASMAtomicXchgBool(&pSockInt->fWokenUp, false);
+                        break; /* Quit */
+                    }
+                    else
+                        Assert(rc == VINF_TRY_AGAIN);
+                }
+                else if (RT_SUCCESS(rc))
+                {
+                    if (fEventsRecv & RTSOCKET_EVT_READ)
+                        *pfEvents |= VD_INTERFACETCPNET_EVT_READ;
+                    if (fEventsRecv & RTSOCKET_EVT_WRITE)
+                        *pfEvents |= VD_INTERFACETCPNET_EVT_WRITE;
+                    if (fEventsRecv & RTSOCKET_EVT_ERROR)
+                        *pfEvents |= VD_INTERFACETCPNET_EVT_ERROR;
+                    break; /* Quit */
+                }
+                else
+                    break;
+            }
+        }
+    }
+
+    ASMAtomicXchgBool(&pSockInt->fWaiting, false);
 
     return rc;
@@ -1892 +2037 @@
             pThis->VDITcpNetCallbacks.pfnGetLocalAddress = drvvdTcpGetLocalAddress;
             pThis->VDITcpNetCallbacks.pfnGetPeerAddress = drvvdTcpGetPeerAddress;
-            pThis->VDITcpNetCallbacks.pfnSelectOneEx = drvvdTcpSelectOneEx;
+
+            /*
+             * There is a 15ms delay between receiving the data and marking the socket
+             * as readable on Windows XP which hurts async I/O performance of
+             * TCP backends badly. Provide a different select method without
+             * using poll on XP.
+             * This is only used on XP because it is not as efficient as the one using poll
+             * and all other Windows versions are working fine.
+             */
+            char szOS[64];
+            memset(szOS, 0, sizeof(szOS));
+            rc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, &szOS[0], sizeof(szOS));
+
+            if (RT_SUCCESS(rc) && !strncmp(szOS, "Windows XP", 10))
+            {
+                LogRel(("VD: Detected Windows XP, disabled poll based waiting for TCP\n"));
+                pThis->VDITcpNetCallbacks.pfnSelectOneEx = drvvdTcpSelectOneExNoPoll;
+            }
+            else
+                pThis->VDITcpNetCallbacks.pfnSelectOneEx = drvvdTcpSelectOneExPoll;
+
             pThis->VDITcpNetCallbacks.pfnPoke = drvvdTcpPoke;
         }