VirtualBox

source: vbox/trunk/src/VBox/VMM/testcase/tstPDMAsyncCompletion.cpp@ 43667

Last change on this file since 43667 was 39084, checked in by vboxsync, 13 years ago

VMM: -Wunused-parameter on mac.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 8.6 KB
Line 
1/* $Id: tstPDMAsyncCompletion.cpp 39084 2011-10-22 00:37:15Z vboxsync $ */
2/** @file
3 * PDM Asynchronous Completion Testcase.
4 *
5 * This testcase is for testing the async completion interface.
6 * It implements a file copy program which uses the interface to copy the data.
7 *
8 * Use: ./tstPDMAsyncCompletion <source> <destination>
9 */
10
11/*
12 * Copyright (C) 2008-2010 Oracle Corporation
13 *
14 * This file is part of VirtualBox Open Source Edition (OSE), as
15 * available from http://www.virtualbox.org. This file is free software;
16 * you can redistribute it and/or modify it under the terms of the GNU
17 * General Public License (GPL) as published by the Free Software
18 * Foundation, in version 2 as it comes in the "COPYING" file of the
19 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
20 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
21 */
22
23/*******************************************************************************
24* Header Files *
25*******************************************************************************/
26#define LOG_GROUP LOG_GROUP_PDM_ASYNC_COMPLETION
27
28#include "VMInternal.h" /* UVM */
29#include <VBox/vmm/vm.h>
30#include <VBox/vmm/uvm.h>
31#include <VBox/vmm/pdmasynccompletion.h>
32#include <VBox/vmm/vmm.h>
33#include <VBox/vmm/cpum.h>
34#include <VBox/err.h>
35#include <VBox/log.h>
36#include <VBox/vmm/pdmapi.h>
37#include <iprt/alloc.h>
38#include <iprt/asm.h>
39#include <iprt/assert.h>
40#include <iprt/file.h>
41#include <iprt/initterm.h>
42#include <iprt/semaphore.h>
43#include <iprt/stream.h>
44#include <iprt/string.h>
45#include <iprt/thread.h>
46
47#define TESTCASE "tstPDMAsyncCompletion"
48
49/*
50 * Number of simultaneous active tasks.
51 */
52#define NR_TASKS 80
53#define BUFFER_SIZE (64*_1K)
54
55/* Buffers to store data in .*/
56uint8_t *g_AsyncCompletionTasksBuffer[NR_TASKS];
57PPDMASYNCCOMPLETIONTASK g_AsyncCompletionTasks[NR_TASKS];
58volatile uint32_t g_cTasksLeft;
59RTSEMEVENT g_FinishedEventSem;
60
61void pfnAsyncTaskCompleted(PVM pVM, void *pvUser, void *pvUser2, int rc)
62{
63 LogFlow((TESTCASE ": %s: pVM=%p pvUser=%p pvUser2=%p\n", __FUNCTION__, pVM, pvUser, pvUser2));
64 NOREF(rc);
65
66 uint32_t cTasksStillLeft = ASMAtomicDecU32(&g_cTasksLeft);
67
68 if (!cTasksStillLeft)
69 {
70 /* All tasks processed. Wakeup main. */
71 RTSemEventSignal(g_FinishedEventSem);
72 }
73}
74
75int main(int argc, char *argv[])
76{
77 int rcRet = 0; /* error count */
78 PPDMASYNCCOMPLETIONENDPOINT pEndpointSrc, pEndpointDst;
79
80 RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_SUPLIB);
81
82 if (argc != 3)
83 {
84 RTPrintf(TESTCASE ": Usage is ./tstPDMAsyncCompletion <source> <dest>\n");
85 return 1;
86 }
87
88 PVM pVM;
89 int rc = VMR3Create(1, NULL, NULL, NULL, NULL, NULL, &pVM);
90 if (RT_SUCCESS(rc))
91 {
92 PPDMASYNCCOMPLETIONTEMPLATE pTemplate;
93
94 /*
95 * Little hack to avoid the VM_ASSERT_EMT assertion.
96 */
97 RTTlsSet(pVM->pUVM->vm.s.idxTLS, &pVM->pUVM->aCpus[0]);
98 pVM->pUVM->aCpus[0].pUVM = pVM->pUVM;
99 pVM->pUVM->aCpus[0].vm.s.NativeThreadEMT = RTThreadNativeSelf();
100
101 /*
102 * Create the template.
103 */
104 rc = PDMR3AsyncCompletionTemplateCreateInternal(pVM, &pTemplate, pfnAsyncTaskCompleted, NULL, "Test");
105 if (RT_FAILURE(rc))
106 {
107 RTPrintf(TESTCASE ": Error while creating the template!! rc=%d\n", rc);
108 return 1;
109 }
110
111 /*
112 * Create event semaphore.
113 */
114 rc = RTSemEventCreate(&g_FinishedEventSem);
115 AssertRC(rc);
116
117 /*
118 * Create the temporary buffers.
119 */
120 for (unsigned i=0; i < NR_TASKS; i++)
121 {
122 g_AsyncCompletionTasksBuffer[i] = (uint8_t *)RTMemAllocZ(BUFFER_SIZE);
123 if (!g_AsyncCompletionTasksBuffer[i])
124 {
125 RTPrintf(TESTCASE ": out of memory!\n");
126 return ++rcRet;
127 }
128 }
129
130 /* Create the destination as the async completion API can't do this. */
131 RTFILE FileTmp;
132 rc = RTFileOpen(&FileTmp, argv[2], RTFILE_O_READWRITE | RTFILE_O_OPEN_CREATE | RTFILE_O_DENY_NONE);
133 if (RT_FAILURE(rc))
134 {
135 RTPrintf(TESTCASE ": Error while creating the destination!! rc=%d\n", rc);
136 return ++rcRet;
137 }
138 RTFileClose(FileTmp);
139
140 /* Create our file endpoint */
141 rc = PDMR3AsyncCompletionEpCreateForFile(&pEndpointSrc, argv[1], 0, pTemplate);
142 if (RT_SUCCESS(rc))
143 {
144 rc = PDMR3AsyncCompletionEpCreateForFile(&pEndpointDst, argv[2], 0, pTemplate);
145 if (RT_SUCCESS(rc))
146 {
147 PDMR3PowerOn(pVM);
148
149 /* Wait for all threads to finish initialization. */
150 RTThreadSleep(100);
151
152 int fReadPass = true;
153 uint64_t cbSrc;
154 size_t offSrc = 0;
155 size_t offDst = 0;
156 uint32_t cTasksUsed = 0;
157
158 rc = PDMR3AsyncCompletionEpGetSize(pEndpointSrc, &cbSrc);
159 if (RT_SUCCESS(rc))
160 {
161 /* Copy the data. */
162 for (;;)
163 {
164 if (fReadPass)
165 {
166 cTasksUsed = (BUFFER_SIZE * NR_TASKS) <= (cbSrc - offSrc)
167 ? NR_TASKS
168 : ((cbSrc - offSrc) / BUFFER_SIZE)
169 + ((cbSrc - offSrc) % BUFFER_SIZE) > 0
170 ? 1
171 : 0;
172
173 g_cTasksLeft = cTasksUsed;
174
175 for (uint32_t i = 0; i < cTasksUsed; i++)
176 {
177 size_t cbRead = ((size_t)offSrc + BUFFER_SIZE) <= cbSrc ? BUFFER_SIZE : cbSrc - offSrc;
178 RTSGSEG DataSeg;
179
180 DataSeg.pvSeg = g_AsyncCompletionTasksBuffer[i];
181 DataSeg.cbSeg = cbRead;
182
183 rc = PDMR3AsyncCompletionEpRead(pEndpointSrc, offSrc, &DataSeg, 1, cbRead, NULL,
184 &g_AsyncCompletionTasks[i]);
185 AssertRC(rc);
186 offSrc += cbRead;
187 if (offSrc == cbSrc)
188 break;
189 }
190 }
191 else
192 {
193 g_cTasksLeft = cTasksUsed;
194
195 for (uint32_t i = 0; i < cTasksUsed; i++)
196 {
197 size_t cbWrite = (offDst + BUFFER_SIZE) <= cbSrc ? BUFFER_SIZE : cbSrc - offDst;
198 RTSGSEG DataSeg;
199
200 DataSeg.pvSeg = g_AsyncCompletionTasksBuffer[i];
201 DataSeg.cbSeg = cbWrite;
202
203 rc = PDMR3AsyncCompletionEpWrite(pEndpointDst, offDst, &DataSeg, 1, cbWrite, NULL,
204 &g_AsyncCompletionTasks[i]);
205 AssertRC(rc);
206 offDst += cbWrite;
207 if (offDst == cbSrc)
208 break;
209 }
210 }
211
212 rc = RTSemEventWait(g_FinishedEventSem, RT_INDEFINITE_WAIT);
213 AssertRC(rc);
214
215 if (!fReadPass && (offDst == cbSrc))
216 break;
217 else if (fReadPass)
218 fReadPass = false;
219 else
220 {
221 cTasksUsed = 0;
222 fReadPass = true;
223 }
224 }
225 }
226 else
227 {
228 RTPrintf(TESTCASE ": Error querying size of the endpoint!! rc=%d\n", rc);
229 rcRet++;
230 }
231
232 PDMR3PowerOff(pVM);
233 PDMR3AsyncCompletionEpClose(pEndpointDst);
234 }
235 PDMR3AsyncCompletionEpClose(pEndpointSrc);
236 }
237
238 rc = VMR3Destroy(pVM);
239 AssertMsg(rc == VINF_SUCCESS, ("%s: Destroying VM failed rc=%Rrc!!\n", __FUNCTION__, rc));
240
241 /*
242 * Clean up.
243 */
244 for (uint32_t i = 0; i < NR_TASKS; i++)
245 {
246 RTMemFree(g_AsyncCompletionTasksBuffer[i]);
247 }
248 }
249 else
250 {
251 RTPrintf(TESTCASE ": failed to create VM!! rc=%Rrc\n", rc);
252 rcRet++;
253 }
254
255 return rcRet;
256}
257
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use