tstFileAio.cpp@ 25000

Last change on this file since 25000 was 25000, checked in by vboxsync, 15 years ago
IPRT: Fixed -Wshadow warnings, found two bugs in error paths.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 11.7 KB

Line
1	/* $Id: tstFileAio.cpp 25000 2009-11-26 14:22:44Z vboxsync $ */
2	/** @file
3	* IPRT Testcase - File Async I/O.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*
26	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27	* Clara, CA 95054 USA or visit http://www.sun.com if you need
28	* additional information or have any questions.
29	*/
30
31
32	/*******************************************************************************
33	* Header Files *
34	*******************************************************************************/
35	#include <iprt/file.h>
36	#include <iprt/types.h>
37	#include <iprt/err.h>
38	#include <iprt/string.h>
39	#include <iprt/stream.h>
40	#include <iprt/mem.h>
41	#include <iprt/initterm.h>
42
43	/** @todo make configurable through cmd line. */
44	#define TSTFILEAIO_MAX_REQS_IN_FLIGHT 64
45	#define TSTFILEAIO_BUFFER_SIZE 64*_1K
46
47	/* Global error counter. */
48	int cErrors = 0;
49
50	void tstFileAioTestReadWriteBasic(RTFILE File, bool fWrite, void *pvTestBuf, size_t cbTestBuf, size_t cbTestFile, uint32_t cMaxReqsInFlight)
51	{
52	int rc = VINF_SUCCESS;
53	RTFILEAIOCTX hAioContext;
54	uint64_t NanoTS = RTTimeNanoTS();
55
56	RTPrintf("tstFileAio: Starting simple %s test...\n", fWrite ? "write" : "read");
57
58	rc = RTFileAioCtxCreate(&hAioContext, cMaxReqsInFlight);
59	if (RT_SUCCESS(rc))
60	{
61	RTFILEAIOREQ *paReqs = NULL;
62	void **papvBuf = NULL;
63	RTFOFF Offset = 0;
64	size_t cbLeft = cbTestFile;
65	int cRun = 0;
66
67	/* Allocate request array. */
68	paReqs = (PRTFILEAIOREQ)RTMemAllocZ(cMaxReqsInFlight * sizeof(RTFILEAIOREQ));
69	if (paReqs)
70	{
71	/* Allocate array holding pointer to data buffers. */
72	papvBuf = (void *)RTMemAllocZ(cMaxReqsInFlight sizeof(void *));
73	if (papvBuf)
74	{
75	/* Allocate array holding completed requests. */
76	RTFILEAIOREQ *paReqsCompleted = NULL;
77	paReqsCompleted = (PRTFILEAIOREQ)RTMemAllocZ(cMaxReqsInFlight * sizeof(RTFILEAIOREQ));
78	if (paReqsCompleted)
79	{
80	/* Associate file with context.*/
81	rc = RTFileAioCtxAssociateWithFile(hAioContext, File);
82	if (RT_SUCCESS(rc))
83	{
84	/* Initialize buffers. */
85	for (unsigned i = 0; i < cMaxReqsInFlight; i++)
86	{
87	papvBuf[i] = RTMemPageAllocZ(cbTestBuf);
88
89	if (fWrite)
90	memcpy(papvBuf[i], pvTestBuf, cbTestBuf);
91	}
92
93	/* Initialize requests. */
94	for (unsigned i = 0; i < cMaxReqsInFlight; i++)
95	RTFileAioReqCreate(&paReqs[i]);
96
97	while (cbLeft)
98	{
99	int cReqs = 0;
100
101	for (unsigned i = 0; i < cMaxReqsInFlight; i++)
102	{
103	size_t cbTransfer = (cbLeft < cbTestBuf) ? cbLeft : cbTestBuf;
104
105	if (!cbTransfer)
106	break;
107
108	if (fWrite)
109	rc = RTFileAioReqPrepareWrite(paReqs[i], File, Offset, papvBuf[i],
110	cbTransfer, papvBuf[i]);
111	else
112	rc = RTFileAioReqPrepareRead(paReqs[i], File, Offset, papvBuf[i],
113	cbTransfer, papvBuf[i]);
114
115	cbLeft -= cbTransfer;
116	Offset += cbTransfer;
117	cReqs++;
118	}
119
120	rc = RTFileAioCtxSubmit(hAioContext, paReqs, cReqs);
121	if (RT_FAILURE(rc))
122	{
123	RTPrintf("tstFileAio: FATAL ERROR - Failed to submit tasks after %d runs. rc=%Rrc\n", cRun, rc);
124	cErrors++;
125	break;
126	}
127
128	/* Wait */
129	uint32_t cCompleted = 0;
130	rc = RTFileAioCtxWait(hAioContext, cReqs, RT_INDEFINITE_WAIT,
131	paReqsCompleted, cMaxReqsInFlight,
132	&cCompleted);
133	if (RT_FAILURE(rc))
134	{
135	RTPrintf("tstFileAio: FATAL ERROR - Waiting failed. rc=%Rrc\n", rc);
136	cErrors++;
137	break;
138	}
139
140	if (!fWrite)
141	{
142	for (uint32_t i = 0; i < cCompleted; i++)
143	{
144	/* Compare that we read the right stuff. */
145	void *pvBuf = RTFileAioReqGetUser(paReqsCompleted[i]);
146
147	size_t cbTransfered;
148	int rcReq = RTFileAioReqGetRC(paReqsCompleted[i], &cbTransfered);
149	if (RT_FAILURE(rcReq) \|\| (cbTransfered != cbTestBuf))
150	{
151	RTPrintf("tstFileAio: FATAL ERROR - Request %d failed with rc=%Rrc cbTransfered=%d.\n",
152	i, rcReq, cbTransfered);
153	cErrors++;
154	rc = rcReq;
155	break;
156	}
157
158	if (memcmp(pvBuf, pvTestBuf, cbTestBuf) != 0)
159	{
160	RTPrintf("tstFileAio: FATAL ERROR - Unexpected content in memory.\n");
161	cErrors++;
162	break;
163	}
164	memset(pvBuf, 0, cbTestBuf);
165	}
166	}
167	cRun++;
168	if (RT_FAILURE(rc))
169	break;
170	}
171
172	/* Free buffers. */
173	for (unsigned i = 0; i < cMaxReqsInFlight; i++)
174	RTMemPageFree(papvBuf[i]);
175
176	/* Free requests. */
177	for (unsigned i = 0; i < cMaxReqsInFlight; i++)
178	{
179	rc = RTFileAioReqDestroy(paReqs[i]);
180	if (RT_FAILURE(rc))
181	{
182	RTPrintf("tstFileAio: ERROR - Failed to destroy request %d. rc=%Rrc\n", i, rc);
183	cErrors++;
184	}
185	}
186
187	NanoTS = RTTimeNanoTS() - NanoTS;
188	unsigned SpeedKBs = (unsigned)(cbTestFile / (NanoTS / 1000000000.0) / 1024);
189
190	RTPrintf("tstFileAio: Completed simple %s test: %d.%03d MB/sec\n",
191	fWrite ? "write" : "read",
192	SpeedKBs / 1000,
193	SpeedKBs % 1000);
194	}
195	else
196	{
197	RTPrintf("tstFileAio: FATAL ERROR - Failed to asssociate file with async I/O context. rc=%Rrc\n", rc);
198	cErrors++;
199	}
200	}
201	else
202	{
203	RTPrintf("tstFileAio: FATAL ERROR - Failed to allocate memory for completed request array.\n");
204	cErrors++;
205	}
206	RTMemFree(papvBuf);
207	}
208	else
209	{
210	RTPrintf("tstFileAio: FATAL ERROR - Failed to allocate memory for buffer array.\n");
211	cErrors++;
212	}
213	RTMemFree(paReqs);
214	}
215	else
216	{
217	RTPrintf("tstFileAio: FATAL ERROR - Failed to allocate memory for request array.\n");
218	cErrors++;
219	}
220
221	rc = RTFileAioCtxDestroy(hAioContext);
222	if (RT_FAILURE(rc))
223	{
224	RTPrintf("tstFileAio: FATAL ERROR - Failed to destroy async I/O context. rc=%Rrc\n", rc);
225	cErrors++;
226	}
227	}
228	else
229	{
230	RTPrintf("tstFileAio: FATAL ERROR - Failed to create async I/O context. rc=%Rrc\n", rc);
231	cErrors++;
232	}
233	}
234
235	int main()
236	{
237	RTPrintf("tstFileAio: TESTING\n");
238	RTR3Init();
239
240	/* Check if the API is available. */
241	RTFILEAIOLIMITS AioLimits;
242
243	memset(&AioLimits, 0, sizeof(AioLimits));
244	int rc = RTFileAioGetLimits(&AioLimits);
245	if (RT_FAILURE(rc))
246	{
247	if (rc == VERR_NOT_SUPPORTED)
248	RTPrintf("tstFileAio: FATAL ERROR - File AIO API not available\n");
249	else
250	RTPrintf("tstFileAio: FATAL ERROR - Unexpected error rc=%Rrc\n", rc);
251	return 1;
252	}
253
254	RTFILE File;
255	void *pvTestBuf = NULL;
256	rc = RTFileOpen(&File, "tstFileAio#1.tst", RTFILE_O_READWRITE \| RTFILE_O_CREATE_REPLACE \| RTFILE_O_DENY_NONE \| RTFILE_O_ASYNC_IO);
257	if (RT_FAILURE(rc))
258	{
259	RTPrintf("tstFileAio: FATAL ERROR - Failed to open file #1. rc=%Rrc\n", rc);
260	return 1;
261	}
262
263	pvTestBuf = RTMemAllocZ(64 * _1K);
264	for (unsigned i = 0; i < 64*_1K; i++)
265	((char *)pvTestBuf)[i] = i % 256;
266
267	uint32_t cReqsMax = AioLimits.cReqsOutstandingMax < TSTFILEAIO_MAX_REQS_IN_FLIGHT
268	? AioLimits.cReqsOutstandingMax
269	: TSTFILEAIO_MAX_REQS_IN_FLIGHT;
270
271	/* Basic write test. */
272	RTPrintf("tstFileAio: Preparing test file, this can take some time and needs quite a bit of harddisk\n");
273	tstFileAioTestReadWriteBasic(File, true, pvTestBuf, 64_1K, 100_1M, cReqsMax);
274	/* Reopen the file. */
275	RTFileClose(File);
276	rc = RTFileOpen(&File, "tstFileAio#1.tst", RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE \| RTFILE_O_ASYNC_IO);
277	if (RT_SUCCESS(rc))
278	{
279	tstFileAioTestReadWriteBasic(File, false, pvTestBuf, 64_1K, 100_1M, cReqsMax);
280	RTFileClose(File);
281	}
282	else
283	{
284	RTPrintf("tstFileAio: FATAL ERROR - Failed to open file #1. rc=%Rrc\n", rc);
285	cErrors++;
286	}
287
288	/* Cleanup */
289	RTMemFree(pvTestBuf);
290	RTFileDelete("tstFileAio#1.tst");
291	/*
292	* Summary
293	*/
294	if (cErrors == 0)
295	RTPrintf("tstFileAio: SUCCESS\n");
296	else
297	RTPrintf("tstFileAio: FAILURE - %d errors\n", cErrors);
298	return !!cErrors;
299	}
300

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/testcase/tstFileAio.cpp@ 25000

Download in other formats: