VirtualBox

source: vbox/trunk/src/VBox/Main/testcase/tstCollector.cpp

Last change on this file was 106061, checked in by vboxsync, 3 months ago

Copyright year updates by scm.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 20.3 KB
Line 
1/* $Id: tstCollector.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2/** @file
3 * VirtualBox Main - Performance collector classes test cases.
4 */
5
6/*
7 * Copyright (C) 2008-2024 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28#ifdef RT_OS_DARWIN
29# include "../src-server/darwin/PerformanceDarwin.cpp"
30#endif
31#ifdef RT_OS_FREEBSD
32# include "../src-server/freebsd/PerformanceFreeBSD.cpp"
33#endif
34#ifdef RT_OS_LINUX
35# include "../src-server/linux/PerformanceLinux.cpp"
36#endif
37#ifdef RT_OS_OS2
38# include "../src-server/os2/PerformanceOS2.cpp"
39#endif
40#ifdef RT_OS_SOLARIS
41# include "../src-server/solaris/PerformanceSolaris.cpp"
42#endif
43#ifdef RT_OS_WINDOWS
44# define _WIN32_DCOM
45# include <iprt/win/objidl.h>
46# include <iprt/win/objbase.h>
47# include "../src-server/win/PerformanceWin.cpp"
48#endif
49
50#include <iprt/initterm.h>
51#include <iprt/stream.h>
52#include <iprt/env.h>
53#include <iprt/err.h>
54#include <iprt/process.h>
55#include <iprt/thread.h>
56#include <iprt/time.h>
57
58#define RUN_TIME_MS 1000
59
60#define N_CALLS(n, fn) \
61 do {\
62 for (int call = 0; call < n; ++call) \
63 rc = collector->fn; \
64 if (RT_FAILURE(rc)) \
65 RTPrintf("tstCollector: "#fn" -> %Rrc\n", rc); \
66 } while (0)
67
68#define CALLS_PER_SECOND(fn, args) \
69 do { \
70 nCalls = 0; \
71 start = RTTimeMilliTS(); \
72 do { \
73 rc = collector->fn args; \
74 if (RT_FAILURE(rc)) \
75 break; \
76 ++nCalls; \
77 } while (RTTimeMilliTS() - start < RUN_TIME_MS); \
78 if (RT_FAILURE(rc)) \
79 RTPrintf("tstCollector: "#fn" -> %Rrc\n", rc); \
80 else \
81 RTPrintf("%70s -- %u calls per second\n", #fn, nCalls); \
82 } while (0)
83
84static void shutdownProcessList(std::vector<RTPROCESS> const &rProcesses)
85{
86 for (size_t i = 0; i < rProcesses.size(); i++)
87 RTProcTerminate(rProcesses[i]);
88}
89
90static void measurePerformance(pm::CollectorHAL *collector, const char *pszName, int cVMs)
91{
92
93 const char * const args[] = { pszName, "-child", NULL };
94 pm::CollectorHints hints;
95 std::vector<RTPROCESS> processes;
96
97 hints.collectHostCpuLoad();
98 hints.collectHostRamUsage();
99 /* Start fake VMs */
100 for (int i = 0; i < cVMs; ++i)
101 {
102 RTPROCESS pid;
103 int rc = RTProcCreate(pszName, args, RTENV_DEFAULT, 0, &pid);
104 if (RT_FAILURE(rc))
105 {
106 hints.getProcesses(processes);
107 shutdownProcessList(processes);
108
109 RTPrintf("tstCollector: RTProcCreate() -> %Rrc\n", rc);
110 return;
111 }
112 hints.collectProcessCpuLoad(pid);
113 hints.collectProcessRamUsage(pid);
114 }
115
116 hints.getProcesses(processes);
117 RTThreadSleep(30000); // Let children settle for half a minute
118
119 int rc;
120 ULONG tmp;
121 uint64_t tmp64;
122 uint64_t start;
123 unsigned int nCalls;
124 /* Pre-collect */
125 CALLS_PER_SECOND(preCollect, (hints, 0));
126 /* Host CPU load */
127 CALLS_PER_SECOND(getRawHostCpuLoad, (&tmp64, &tmp64, &tmp64));
128 /* Process CPU load */
129 CALLS_PER_SECOND(getRawProcessCpuLoad, (processes[nCalls % cVMs], &tmp64, &tmp64, &tmp64));
130 /* Host CPU speed */
131 CALLS_PER_SECOND(getHostCpuMHz, (&tmp));
132 /* Host RAM usage */
133 CALLS_PER_SECOND(getHostMemoryUsage, (&tmp, &tmp, &tmp));
134 /* Process RAM usage */
135 CALLS_PER_SECOND(getProcessMemoryUsage, (processes[nCalls % cVMs], &tmp));
136
137 start = RTTimeNanoTS();
138
139 int times;
140 for (times = 0; times < 100; times++)
141 {
142 /* Pre-collect */
143 N_CALLS(1, preCollect(hints, 0));
144 /* Host CPU load */
145 N_CALLS(1, getRawHostCpuLoad(&tmp64, &tmp64, &tmp64));
146 /* Host CPU speed */
147 N_CALLS(1, getHostCpuMHz(&tmp));
148 /* Host RAM usage */
149 N_CALLS(1, getHostMemoryUsage(&tmp, &tmp, &tmp));
150 /* Process CPU load */
151 N_CALLS(cVMs, getRawProcessCpuLoad(processes[call], &tmp64, &tmp64, &tmp64));
152 /* Process RAM usage */
153 N_CALLS(cVMs, getProcessMemoryUsage(processes[call], &tmp));
154 }
155 RTPrintf("\n%d VMs -- %u%% of CPU time\n", cVMs, (unsigned)((double)(RTTimeNanoTS() - start) / 10000000.0 / times));
156
157 /* Shut down fake VMs */
158 shutdownProcessList(processes);
159}
160
161#ifdef RT_OS_SOLARIS
162#define NETIFNAME "net0"
163#else
164#define NETIFNAME "eth0"
165#endif
166static int testNetwork(pm::CollectorHAL *collector)
167{
168 pm::CollectorHints hints;
169 uint64_t hostRxStart, hostTxStart;
170 uint64_t hostRxStop, hostTxStop, speed = 125000000; /* Assume 1Gbit/s */
171
172 RTPrintf("tstCollector: TESTING - Network load, sleeping for 5 s...\n");
173
174 hostRxStart = hostTxStart = 0;
175 int rc = collector->preCollect(hints, 0);
176 if (RT_FAILURE(rc))
177 {
178 RTPrintf("tstCollector: preCollect() -> %Rrc\n", rc);
179 return 1;
180 }
181 rc = collector->getRawHostNetworkLoad(NETIFNAME, &hostRxStart, &hostTxStart);
182 if (rc == VERR_NOT_IMPLEMENTED)
183 RTPrintf("tstCollector: getRawHostNetworkLoad() not implemented, skipping\n");
184 else
185 {
186 if (RT_FAILURE(rc))
187 {
188 RTPrintf("tstCollector: getRawHostNetworkLoad() -> %Rrc\n", rc);
189 return 1;
190 }
191
192 RTThreadSleep(5000); // Sleep for five seconds
193
194 rc = collector->preCollect(hints, 0);
195 if (RT_FAILURE(rc))
196 {
197 RTPrintf("tstCollector: preCollect() -> %Rrc\n", rc);
198 return 1;
199 }
200 hostRxStop = hostRxStart;
201 hostTxStop = hostTxStart;
202 rc = collector->getRawHostNetworkLoad(NETIFNAME, &hostRxStop, &hostTxStop);
203 if (RT_FAILURE(rc))
204 {
205 RTPrintf("tstCollector: getRawHostNetworkLoad() -> %Rrc\n", rc);
206 return 1;
207 }
208 RTPrintf("tstCollector: host network speed = %llu bytes/sec (%llu mbit/sec)\n",
209 speed, speed/(1000000/8));
210 RTPrintf("tstCollector: host network rx = %llu bytes/sec (%llu mbit/sec, %u.%u %%)\n",
211 (hostRxStop - hostRxStart)/5, (hostRxStop - hostRxStart)/(5000000/8),
212 (hostRxStop - hostRxStart) * 100 / (speed * 5),
213 (hostRxStop - hostRxStart) * 10000 / (speed * 5) % 100);
214 RTPrintf("tstCollector: host network tx = %llu bytes/sec (%llu mbit/sec, %u.%u %%)\n\n",
215 (hostTxStop - hostTxStart)/5, (hostTxStop - hostTxStart)/(5000000/8),
216 (hostTxStop - hostTxStart) * 100 / (speed * 5),
217 (hostTxStop - hostTxStart) * 10000 / (speed * 5) % 100);
218 }
219
220 return 0;
221}
222
223#define FSNAME "/"
224static int testFsUsage(pm::CollectorHAL *collector)
225{
226 RTPrintf("tstCollector: TESTING - File system usage\n");
227
228 ULONG total, used, available;
229
230 int rc = collector->getHostFilesystemUsage(FSNAME, &total, &used, &available);
231 if (rc == VERR_NOT_IMPLEMENTED)
232 RTPrintf("tstCollector: getHostFilesystemUsage() not implemented, skipping\n");
233 else
234 {
235 if (RT_FAILURE(rc))
236 {
237 RTPrintf("tstCollector: getHostFilesystemUsage() -> %Rrc\n", rc);
238 return 1;
239 }
240 RTPrintf("tstCollector: host root fs total = %lu MB\n", total);
241 RTPrintf("tstCollector: host root fs used = %lu MB\n", used);
242 RTPrintf("tstCollector: host root fs available = %lu MB\n\n", available);
243 }
244 return 0;
245}
246
247static int testDisk(pm::CollectorHAL *collector)
248{
249 pm::CollectorHints hints;
250 uint64_t diskMsStart, totalMsStart;
251 uint64_t diskMsStop, totalMsStop;
252
253 pm::DiskList disksUsage, disksLoad;
254 int rc = collector->getDiskListByFs(FSNAME, disksUsage, disksLoad);
255 if (rc == VERR_NOT_IMPLEMENTED)
256 RTPrintf("tstCollector: getDiskListByFs() not implemented, skipping\n");
257 else
258 {
259 if (RT_FAILURE(rc))
260 {
261 RTPrintf("tstCollector: getDiskListByFs(%s) -> %Rrc\n", FSNAME, rc);
262 return 1;
263 }
264 if (disksUsage.empty())
265 {
266 RTPrintf("tstCollector: getDiskListByFs(%s) returned empty usage list\n", FSNAME);
267 return 0;
268 }
269 if (disksLoad.empty())
270 {
271 RTPrintf("tstCollector: getDiskListByFs(%s) returned empty usage list\n", FSNAME);
272 return 0;
273 }
274
275 pm::DiskList::iterator it;
276 for (it = disksUsage.begin(); it != disksUsage.end(); ++it)
277 {
278 uint64_t diskSize = 0;
279 rc = collector->getHostDiskSize(it->c_str(), &diskSize);
280 RTPrintf("tstCollector: TESTING - Disk size (%s) = %llu\n", it->c_str(), diskSize);
281 if (rc == VERR_FILE_NOT_FOUND)
282 RTPrintf("tstCollector: getHostDiskSize(%s) returned VERR_FILE_NOT_FOUND\n", it->c_str());
283 else if (RT_FAILURE(rc))
284 {
285 RTPrintf("tstCollector: getHostDiskSize() -> %Rrc\n", rc);
286 return 1;
287 }
288 }
289
290 for (it = disksLoad.begin(); it != disksLoad.end(); ++it)
291 {
292 RTPrintf("tstCollector: TESTING - Disk utilization (%s), sleeping for 5 s...\n", it->c_str());
293
294 hints.collectHostCpuLoad();
295 rc = collector->preCollect(hints, 0);
296 if (RT_FAILURE(rc))
297 {
298 RTPrintf("tstCollector: preCollect() -> %Rrc\n", rc);
299 return 1;
300 }
301 rc = collector->getRawHostDiskLoad(it->c_str(), &diskMsStart, &totalMsStart);
302 if (RT_FAILURE(rc))
303 {
304 RTPrintf("tstCollector: getRawHostDiskLoad() -> %Rrc\n", rc);
305 return 1;
306 }
307
308 RTThreadSleep(5000); // Sleep for five seconds
309
310 rc = collector->preCollect(hints, 0);
311 if (RT_FAILURE(rc))
312 {
313 RTPrintf("tstCollector: preCollect() -> %Rrc\n", rc);
314 return 1;
315 }
316 rc = collector->getRawHostDiskLoad(it->c_str(), &diskMsStop, &totalMsStop);
317 if (RT_FAILURE(rc))
318 {
319 RTPrintf("tstCollector: getRawHostDiskLoad() -> %Rrc\n", rc);
320 return 1;
321 }
322 RTPrintf("tstCollector: host disk util = %llu msec (%u.%u %%), total = %llu msec\n\n",
323 (diskMsStop - diskMsStart),
324 (unsigned)((diskMsStop - diskMsStart) * 100 / (totalMsStop - totalMsStart)),
325 (unsigned)((diskMsStop - diskMsStart) * 10000 / (totalMsStop - totalMsStart) % 100),
326 totalMsStop - totalMsStart);
327 }
328 }
329
330 return 0;
331}
332
333
334
335int main(int argc, char *argv[])
336{
337 bool cpuTest, ramTest, netTest, diskTest, fsTest, perfTest;
338 cpuTest = ramTest = netTest = diskTest = fsTest = perfTest = false;
339 /*
340 * Initialize the VBox runtime without loading
341 * the support driver.
342 */
343 int rc = RTR3InitExe(argc, &argv, 0);
344 if (RT_FAILURE(rc))
345 {
346 RTPrintf("tstCollector: RTR3InitExe() -> %d\n", rc);
347 return 1;
348 }
349 if (argc > 1)
350 {
351 if (!strcmp(argv[1], "-child"))
352 {
353 /* We have spawned ourselves as a child process -- scratch the leg */
354 RTThreadSleep(1000000);
355 return 1;
356 }
357 for (int i = 1; i < argc; i++)
358 {
359 if (!strcmp(argv[i], "-cpu"))
360 cpuTest = true;
361 else if (!strcmp(argv[i], "-ram"))
362 ramTest = true;
363 else if (!strcmp(argv[i], "-net"))
364 netTest = true;
365 else if (!strcmp(argv[i], "-disk"))
366 diskTest = true;
367 else if (!strcmp(argv[i], "-fs"))
368 fsTest = true;
369 else if (!strcmp(argv[i], "-perf"))
370 perfTest = true;
371 else
372 {
373 RTPrintf("tstCollector: Unknown option: %s\n", argv[i]);
374 return 2;
375 }
376 }
377 }
378 else
379 cpuTest = ramTest = netTest = diskTest = fsTest = perfTest = true;
380
381#ifdef RT_OS_WINDOWS
382 HRESULT hRes = CoInitialize(NULL);
383 /*
384 * Need to initialize security to access performance enumerators.
385 */
386 hRes = CoInitializeSecurity(
387 NULL,
388 -1,
389 NULL,
390 NULL,
391 RPC_C_AUTHN_LEVEL_NONE,
392 RPC_C_IMP_LEVEL_IMPERSONATE,
393 NULL, EOAC_NONE, 0);
394#endif
395
396 pm::CollectorHAL *collector = pm::createHAL();
397 if (!collector)
398 {
399 RTPrintf("tstCollector: createMetricFactory() failed\n");
400 return 1;
401 }
402
403 pm::CollectorHints hints;
404 if (cpuTest)
405 {
406 hints.collectHostCpuLoad();
407 hints.collectProcessCpuLoad(RTProcSelf());
408 }
409 if (ramTest)
410 {
411 hints.collectHostRamUsage();
412 hints.collectProcessRamUsage(RTProcSelf());
413 }
414
415 uint64_t start;
416
417 uint64_t hostUserStart, hostKernelStart, hostIdleStart;
418 uint64_t hostUserStop, hostKernelStop, hostIdleStop, hostTotal;
419
420 uint64_t processUserStart, processKernelStart, processTotalStart;
421 uint64_t processUserStop, processKernelStop, processTotalStop;
422
423 rc = collector->preCollect(hints, 0);
424 if (RT_FAILURE(rc))
425 {
426 RTPrintf("tstCollector: preCollect() -> %Rrc\n", rc);
427 return 1;
428 }
429 if (cpuTest)
430 {
431 RTPrintf("tstCollector: TESTING - CPU load, sleeping for 5 s...\n");
432
433 rc = collector->getRawHostCpuLoad(&hostUserStart, &hostKernelStart, &hostIdleStart);
434 if (RT_FAILURE(rc))
435 {
436 RTPrintf("tstCollector: getRawHostCpuLoad() -> %Rrc\n", rc);
437 return 1;
438 }
439 rc = collector->getRawProcessCpuLoad(RTProcSelf(), &processUserStart, &processKernelStart, &processTotalStart);
440 if (RT_FAILURE(rc))
441 {
442 RTPrintf("tstCollector: getRawProcessCpuLoad() -> %Rrc\n", rc);
443 return 1;
444 }
445
446 RTThreadSleep(5000); // Sleep for 5 seconds
447
448 rc = collector->preCollect(hints, 0);
449 if (RT_FAILURE(rc))
450 {
451 RTPrintf("tstCollector: preCollect() -> %Rrc\n", rc);
452 return 1;
453 }
454 rc = collector->getRawHostCpuLoad(&hostUserStop, &hostKernelStop, &hostIdleStop);
455 if (RT_FAILURE(rc))
456 {
457 RTPrintf("tstCollector: getRawHostCpuLoad() -> %Rrc\n", rc);
458 return 1;
459 }
460 rc = collector->getRawProcessCpuLoad(RTProcSelf(), &processUserStop, &processKernelStop, &processTotalStop);
461 if (RT_FAILURE(rc))
462 {
463 RTPrintf("tstCollector: getRawProcessCpuLoad() -> %Rrc\n", rc);
464 return 1;
465 }
466 hostTotal = hostUserStop - hostUserStart
467 + hostKernelStop - hostKernelStart
468 + hostIdleStop - hostIdleStart;
469 RTPrintf("tstCollector: host cpu user = %u.%u %%\n",
470 (unsigned)((hostUserStop - hostUserStart) * 100 / hostTotal),
471 (unsigned)((hostUserStop - hostUserStart) * 10000 / hostTotal % 100));
472 RTPrintf("tstCollector: host cpu kernel = %u.%u %%\n",
473 (unsigned)((hostKernelStop - hostKernelStart) * 100 / hostTotal),
474 (unsigned)((hostKernelStop - hostKernelStart) * 10000 / hostTotal % 100));
475 RTPrintf("tstCollector: host cpu idle = %u.%u %%\n",
476 (unsigned)((hostIdleStop - hostIdleStart) * 100 / hostTotal),
477 (unsigned)((hostIdleStop - hostIdleStart) * 10000 / hostTotal % 100));
478 RTPrintf("tstCollector: process cpu user = %u.%u %%\n",
479 (unsigned)((processUserStop - processUserStart) * 100 / (processTotalStop - processTotalStart)),
480 (unsigned)((processUserStop - processUserStart) * 10000 / (processTotalStop - processTotalStart) % 100));
481 RTPrintf("tstCollector: process cpu kernel = %u.%u %%\n\n",
482 (unsigned)((processKernelStop - processKernelStart) * 100 / (processTotalStop - processTotalStart)),
483 (unsigned)((processKernelStop - processKernelStart) * 10000 / (processTotalStop - processTotalStart) % 100));
484
485 RTPrintf("tstCollector: TESTING - CPU load, looping for 5 s...\n");
486 rc = collector->preCollect(hints, 0);
487 if (RT_FAILURE(rc))
488 {
489 RTPrintf("tstCollector: preCollect() -> %Rrc\n", rc);
490 return 1;
491 }
492 rc = collector->getRawHostCpuLoad(&hostUserStart, &hostKernelStart, &hostIdleStart);
493 if (RT_FAILURE(rc))
494 {
495 RTPrintf("tstCollector: getRawHostCpuLoad() -> %Rrc\n", rc);
496 return 1;
497 }
498 rc = collector->getRawProcessCpuLoad(RTProcSelf(), &processUserStart, &processKernelStart, &processTotalStart);
499 if (RT_FAILURE(rc))
500 {
501 RTPrintf("tstCollector: getRawProcessCpuLoad() -> %Rrc\n", rc);
502 return 1;
503 }
504 start = RTTimeMilliTS();
505 while (RTTimeMilliTS() - start < 5000)
506 ; // Loop for 5 seconds
507 rc = collector->preCollect(hints, 0);
508 if (RT_FAILURE(rc))
509 {
510 RTPrintf("tstCollector: preCollect() -> %Rrc\n", rc);
511 return 1;
512 }
513 rc = collector->getRawHostCpuLoad(&hostUserStop, &hostKernelStop, &hostIdleStop);
514 if (RT_FAILURE(rc))
515 {
516 RTPrintf("tstCollector: getRawHostCpuLoad() -> %Rrc\n", rc);
517 return 1;
518 }
519 rc = collector->getRawProcessCpuLoad(RTProcSelf(), &processUserStop, &processKernelStop, &processTotalStop);
520 if (RT_FAILURE(rc))
521 {
522 RTPrintf("tstCollector: getRawProcessCpuLoad() -> %Rrc\n", rc);
523 return 1;
524 }
525 hostTotal = hostUserStop - hostUserStart
526 + hostKernelStop - hostKernelStart
527 + hostIdleStop - hostIdleStart;
528 RTPrintf("tstCollector: host cpu user = %u.%u %%\n",
529 (unsigned)((hostUserStop - hostUserStart) * 100 / hostTotal),
530 (unsigned)((hostUserStop - hostUserStart) * 10000 / hostTotal % 100));
531 RTPrintf("tstCollector: host cpu kernel = %u.%u %%\n",
532 (unsigned)((hostKernelStop - hostKernelStart) * 100 / hostTotal),
533 (unsigned)((hostKernelStop - hostKernelStart) * 10000 / hostTotal % 100));
534 RTPrintf("tstCollector: host cpu idle = %u.%u %%\n",
535 (unsigned)((hostIdleStop - hostIdleStart) * 100 / hostTotal),
536 (unsigned)((hostIdleStop - hostIdleStart) * 10000 / hostTotal % 100));
537 RTPrintf("tstCollector: process cpu user = %u.%u %%\n",
538 (unsigned)((processUserStop - processUserStart) * 100 / (processTotalStop - processTotalStart)),
539 (unsigned)((processUserStop - processUserStart) * 10000 / (processTotalStop - processTotalStart) % 100));
540 RTPrintf("tstCollector: process cpu kernel = %u.%u %%\n\n",
541 (unsigned)((processKernelStop - processKernelStart) * 100 / (processTotalStop - processTotalStart)),
542 (unsigned)((processKernelStop - processKernelStart) * 10000 / (processTotalStop - processTotalStart) % 100));
543 }
544
545 if (ramTest)
546 {
547 RTPrintf("tstCollector: TESTING - Memory usage\n");
548
549 ULONG total, used, available, processUsed;
550
551 rc = collector->getHostMemoryUsage(&total, &used, &available);
552 if (RT_FAILURE(rc))
553 {
554 RTPrintf("tstCollector: getHostMemoryUsage() -> %Rrc\n", rc);
555 return 1;
556 }
557 rc = collector->getProcessMemoryUsage(RTProcSelf(), &processUsed);
558 if (RT_FAILURE(rc))
559 {
560 RTPrintf("tstCollector: getProcessMemoryUsage() -> %Rrc\n", rc);
561 return 1;
562 }
563 RTPrintf("tstCollector: host mem total = %lu kB\n", total);
564 RTPrintf("tstCollector: host mem used = %lu kB\n", used);
565 RTPrintf("tstCollector: host mem available = %lu kB\n", available);
566 RTPrintf("tstCollector: process mem used = %lu kB\n\n", processUsed);
567 }
568
569 if (netTest)
570 rc = testNetwork(collector);
571 if (fsTest)
572 rc = testFsUsage(collector);
573 if (diskTest)
574 rc = testDisk(collector);
575 if (perfTest)
576 {
577 RTPrintf("tstCollector: TESTING - Performance\n\n");
578
579 measurePerformance(collector, argv[0], 100);
580 }
581
582 delete collector;
583
584 RTPrintf("\ntstCollector FINISHED.\n");
585
586 return RTEXITCODE_SUCCESS;
587}
588
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette