Changeset 19185 in vbox

Timestamp:

Apr 26, 2009 9:04:33 AM (16 years ago)

Author:

vboxsync

Message:

Runtime/Aio: Slight changes to the API for Windows. Fix the Solaris backend

Location:

trunk

Files:

• include/iprt/file.h (modified) (6 diffs)
• src/VBox/Runtime/r3/linux/fileaio-linux.cpp (modified) (3 diffs)
• src/VBox/Runtime/testcase/tstFileAio.cpp (modified) (2 diffs)

trunk/include/iprt/file.h

@@ -787 +787 @@
  * RTFileAioReqPrepareWrite() which will write to a given file.
  *
- * The second object is the context. Requests are associated with a context
- * during RTFileAioCtxSubmit() which will also submit the requests to the
- * operating system.
+ * The second object is the context. A file is associated with a context
+ * and requests for this file may complete only on the context the file
+ * was associated with and not on the context given in RTFileAioCtxSubmit()
+ * (see below for further information).
  * RTFileAioCtxWait() is used to wait for completion of requests which were
  * associated with the context. While waiting for requests the thread can not
@@ -811 +812 @@
  * there are some things to consider to make the code as portable as possible.
  *
- * The only restriction at the moment is that every buffer has to be aligned to a 512 byte boundary.
+ * The first restriction at the moment is that every buffer has to be aligned to a 512 byte boundary.
  * This limitation comes from the Linux io_* interface. To use the interface the file
  * must be opened with O_DIRECT. This flag disables the kernel cache too which may
@@ -822 +823 @@
  * file systems. So Linus comment about this flag is comprehensible but Linux
  * lacks an alternative at the moment.
+ *
+ * The next limitation applies only to Windows. Reqeusts are not assoicated with the
+ * I/O context they are associated with but with the file the request is for.
+ * The file needs to be associated with exactly one I/O completion port and requests
+ * for this file will only arrive at that context after they completed and not on
+ * the context the request was submitted.
+ * To associate a file with a specific context RTFileAioCtxAssociateWithFile() is
+ * used. It is only implemented on Windows and does nothing on the other platforms.
+ * If the file needs to be associated with different context for some reason
+ * the file must be closed first. After it was opened again the new context
+ * can be associated with the other context.
+ * This can't be done by the API because there is no way to retrieve the flags
+ * the file was opened with.
  */
 
@@ -963 +977 @@
 
 /**
+ * Associates a file with a async I/O context.
+ * Requests for this file will arrive at the completion port
+ * associated with the file.
+ *
+ * @returns IPRT status code.
+ *
+ * @param   hAioCtx        The async I/O context handle.
+ * @param   hFile          The file handle.
+ */
+RTDECL(int) RTFileAioCtxAssociateWithFile(RTFILEAIOCTX hAioCtx, RTFILE hFile);
+
+/**
  * Submits a set of requests to an async I/O context for processing.
- *
- * @todo Is it possible to call this API while another thread is in
- *       RTFileAioCtxWait?
  *
  * @returns IPRT status code.
@@ -973 +996 @@
  * @param   pahReqs         Pointer to an array of request handles.
  * @param   cReqs           The number of entries in the array.
+ * @param   pcReqs          Where to store the number of requests
+ *                          successfully submitted before an error
+ *                          occured. If VINF_SUCCESS is returned
+ *                          the value equals cReqs. This value is always
+ *                          set.
  *
  * @remarks @a cReqs uses the type size_t while it really is a uint32_t, this is
@@ -978 +1006 @@
  *          macros.
  */
-RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ phReqs, size_t cReqs);
+RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs, size_t *pcReqs);
 
 /**

trunk/src/VBox/Runtime/r3/linux/fileaio-linux.cpp

@@ -458 +458 @@
         *phAioCtx = (RTFILEAIOCTX)pCtxInt;
     }
+    else
+        RTMemFree(pCtxInt);
 
     return rc;
@@ -500 +502 @@
 }
 
-
-RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs)
+RTDECL(int) RTFileAioCtxAssociateWithFile(RTFILEAIOCTS hAioCtx, RTFILE hFile)
+{
+    /* Nothing to do. */
+    return VINF_SUCCESS;
+}
+
+RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs, size_t *pcReqs)
 {
     /*
      * Parameter validation.
      */
+    AssertPtrReturn(pcReqs, VERR_INVALID_POINTER);
+    *pcReqs = 0;
     PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
     RTFILEAIOCTX_VALID_RETURN(pCtxInt);
@@ -539 +548 @@
     if (RT_FAILURE(rc))
         ASMAtomicSubS32(&pCtxInt->cRequests, cReqs);
+    else
+        *pcReqs = cReqs;
 
     return rc;

trunk/src/VBox/Runtime/testcase/tstFileAio.cpp

@@ -63 +63 @@
         RTFOFF           Offset = 0;
         size_t           cbLeft = cbTestFile;
-
-        /* Initialize buffers. */
-        for (unsigned i = 0; i < RT_ELEMENTS(apvBuf); i++)
+        int cRun = 0;
+
+        /* Associate file with context.*/
+        rc = RTFileAioCtxAssociateWithFile(hAioContext, File);
+        if (RT_SUCCESS(rc))
         {
-            apvBuf[i] = RTMemPageAllocZ(cbTestBuf);
-
-            if (fWrite)
-                memcpy(apvBuf[i], pvTestBuf, cbTestBuf);
+            /* Initialize buffers. */
+            for (unsigned i = 0; i < RT_ELEMENTS(apvBuf); i++)
+            {
+                apvBuf[i] = RTMemPageAllocZ(cbTestBuf);
+
+                if (fWrite)
+                    memcpy(apvBuf[i], pvTestBuf, cbTestBuf);
+            }
+
+            /* Initialize requests. */
+            for (unsigned i = 0; i < RT_ELEMENTS(aReqs); i++)
+                RTFileAioReqCreate(&aReqs[i]);
+
+            while (cbLeft)
+            {
+                int cReqs = 0;
+                size_t cReqsSubmitted = 0;
+
+                for (unsigned i = 0; i < RT_ELEMENTS(aReqs); i++)
+                {
+                    size_t cbTransfer = (cbLeft < cbTestBuf) ? cbLeft : cbTestBuf;
+
+                    if (!cbTransfer)
+                        break;
+
+                    if (fWrite)
+                        rc = RTFileAioReqPrepareWrite(aReqs[i], File, Offset, apvBuf[i],
+                                                      cbTransfer, apvBuf[i]);
+                    else
+                        rc = RTFileAioReqPrepareRead(aReqs[i], File, Offset, apvBuf[i],
+                                                     cbTransfer, apvBuf[i]);
+
+                    cbLeft -= cbTransfer;
+                    Offset += cbTransfer;
+                    cReqs++;
+                }
+
+                rc = RTFileAioCtxSubmit(hAioContext, aReqs, cReqs, &cReqsSubmitted);
+                if (RT_FAILURE(rc))
+                {
+                    RTPrintf("tstFileAio: FATAL ERROR - Failed to submit tasks after %d runs. rc=%Rrc\n", cRun, rc);
+                    cErrors++;
+                    break;
+                }
+                else if (cReqs != cReqsSubmitted)
+                {
+                    RTPrintf("tstFileAio: FATAL ERROR - Submitted tasks but the result is not equal to the number of submitted tasks\n", rc);
+                    cErrors++;
+                    break;
+                }
+
+                /* Wait */
+                RTFILEAIOREQ aReqsCompleted[TSTFILEAIO_MAX_REQS_IN_FLIGHT];
+                uint32_t cCompleted = 0;
+                rc = RTFileAioCtxWait(hAioContext, cReqs, RT_INDEFINITE_WAIT,
+                                      aReqsCompleted, TSTFILEAIO_MAX_REQS_IN_FLIGHT,
+                                      &cCompleted);
+                if (RT_FAILURE(rc))
+                {
+                    RTPrintf("tstFileAio: FATAL ERROR - Waiting failed. rc=%Rrc\n", rc);
+                    cErrors++;
+                    break;
+                }
+
+                if (!fWrite)
+                {
+                    for (uint32_t i = 0; i < cCompleted; i++)
+                    {
+                        /* Compare that we read the right stuff. */
+                        void *pvBuf = RTFileAioReqGetUser(aReqsCompleted[i]);
+
+                        size_t cbTransfered;
+                        int rcReq = RTFileAioReqGetRC(aReqsCompleted[i], &cbTransfered);
+                        if (RT_FAILURE(rcReq) || (cbTransfered != cbTestBuf))
+                        {
+                            RTPrintf("tstFileAio: FATAL ERROR - Request %d failed with rc=%Rrc cbTransfered=%d.\n",
+                                     i, rcReq, cbTransfered);
+                            cErrors++;
+                            rc = rcReq;
+                            break;
+                        }
+
+                        if (memcmp(pvBuf, pvTestBuf, cbTestBuf) != 0)
+                        {
+                            RTPrintf("tstFileAio: FATAL ERROR - Unexpected content in memory.\n");
+                            cErrors++;
+                            break;
+                        }
+                        memset(pvBuf, 0, cbTestBuf);
+                    }
+                }
+                cRun++;
+                if (RT_FAILURE(rc))
+                    break;
+            }
+
+            /* Free buffers. */
+            for (unsigned i = 0; i < RT_ELEMENTS(apvBuf); i++)
+                RTMemPageFree(apvBuf[i]);
+
+            /* Free requests. */
+            for (unsigned i = 0; i < RT_ELEMENTS(aReqs); i++)
+                RTFileAioReqDestroy(aReqs[i]);
+
+            NanoTS = RTTimeNanoTS() - NanoTS;
+            unsigned SpeedKBs = cbTestFile / (NanoTS / 1000000000.0) / 1024;
+
+            RTPrintf("tstFileAio: Completed simple %s test: %d.%03d MB/sec\n",
+                     fWrite ? "write" : "read",
+                     SpeedKBs / 1000,
+                     SpeedKBs % 1000);
         }
-
-        /* Initialize requests. */
-        for (unsigned i = 0; i < RT_ELEMENTS(aReqs); i++)
-            RTFileAioReqCreate(&aReqs[i]);
-
-        while (cbLeft)
+        else
         {
-            int cReqs = 0;
-
-            for (unsigned i = 0; i < RT_ELEMENTS(aReqs); i++)
-            {
-                size_t cbTransfer = (cbLeft < cbTestBuf) ? cbLeft : cbTestBuf;
-
-                if (!cbTransfer)
-                    break;
-
-                if (fWrite)
-                    rc = RTFileAioReqPrepareWrite(aReqs[i], File, Offset, apvBuf[i],
-                                                  cbTransfer, apvBuf[i]);
-                else
-                    rc = RTFileAioReqPrepareRead(aReqs[i], File, Offset, apvBuf[i],
-                                                 cbTransfer, apvBuf[i]);
-
-                cbLeft -= cbTransfer;
-                Offset += cbTransfer;
-                cReqs++;
-            }
-
-            rc = RTFileAioCtxSubmit(hAioContext, aReqs, cReqs);
-            if (RT_FAILURE(rc))
-            {
-                RTPrintf("tstFileAio: FATAL ERROR - Failed to submit tasks. rc=%Rrc\n", rc);
-                cErrors++;
-                break;
-            }
-
-            /* Wait */
-            RTFILEAIOREQ aReqsCompleted[TSTFILEAIO_MAX_REQS_IN_FLIGHT];
-            uint32_t cCompleted = 0;
-            rc = RTFileAioCtxWait(hAioContext, cReqs, RT_INDEFINITE_WAIT,
-                                  aReqsCompleted, TSTFILEAIO_MAX_REQS_IN_FLIGHT,
-                                  &cCompleted);
-            if (RT_FAILURE(rc))
-            {
-                RTPrintf("tstFileAio: FATAL ERROR - Waiting failed. rc=%Rrc\n", rc);
-                cErrors++;
-                break;
-            }
-
-            if (!fWrite)
-            {
-                for (uint32_t i = 0; i < cCompleted; i++)
-                {
-                    /* Compare that we read the right stuff. */
-                    void *pvBuf = RTFileAioReqGetUser(aReqsCompleted[i]);
-
-                    if (memcmp(pvBuf, pvTestBuf, cbTestBuf) != 0)
-                    {
-                        RTPrintf("tstFileAio: FATAL ERROR - Unexpected content in memory.\n");
-                        cErrors++;
-                        break;
-                    }
-                    memset(pvBuf, 0, cbTestBuf);
-                }
-            }
+            RTPrintf("tstFileAio: FATAL ERROR - Failed to asssociate file with async I/O context. rc=%Rrc\n", rc);
+            cErrors++;
         }
-
-        /* Free buffers. */
-        for (unsigned i = 0; i < RT_ELEMENTS(apvBuf); i++)
-            RTMemPageFree(apvBuf[i]);
-
-        /* Free requests. */
-        for (unsigned i = 0; i < RT_ELEMENTS(aReqs); i++)
-            RTFileAioReqDestroy(aReqs[i]);
-
-        NanoTS = RTTimeNanoTS() - NanoTS;
-        unsigned SpeedKBs = cbTestFile / (NanoTS / 1000000000.0) / 1024;
-
-        RTPrintf("tstFileAio: Completed simple %s test: %d.%03d MB/sec\n",
-                 fWrite ? "write" : "read",
-                 SpeedKBs / 1000,
-                 SpeedKBs % 1000);
 
         rc = RTFileAioCtxDestroy(hAioContext);
@@ -190 +222 @@
     RTPrintf("tstFileAio: Preparing test file, this can take some time and needs quite a bit of harddisk\n");
     tstFileAioTestReadWriteBasic(File, true, pvTestBuf, 64*_1K, 100*_1M);
-    tstFileAioTestReadWriteBasic(File, false, pvTestBuf, 64*_1K, 100*_1M);
-
+    /* Reopen the file. */
     RTFileClose(File);
+    rc = RTFileOpen(&File, "tstFileAio#1.tst", RTFILE_O_READWRITE | RTFILE_O_DENY_NONE | RTFILE_O_ASYNC_IO);
+    if (RT_SUCCESS(rc))
+    {
+        tstFileAioTestReadWriteBasic(File, false, pvTestBuf, 64*_1K, 100*_1M);
+        RTFileClose(File);
+    }
+    else
+    {
+        RTPrintf("tstFileAio: FATAL ERROR - Failed to open file #1. rc=%Rrc\n", rc);
+        cErrors++;
+    }
+
+    /* Cleanup */
     RTMemFree(pvTestBuf);
     RTFileDelete("tstFileAio#1.tst");