VirtualBox

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

Last change on this file since 78352 was 77102, checked in by vboxsync, 6 years ago

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