Performance.cpp@ 105659

Last change on this file since 105659 was 98292, checked in by vboxsync, 23 months ago
Main/src-server: rc -> hrc/vrc. Enabled scm rc checks. bugref:10223
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 41.4 KB

Line
1	/* $Id: Performance.cpp 98292 2023-01-25 01:14:53Z vboxsync $ */
2	/** @file
3	* VBox Performance Classes implementation.
4	*/
5
6	/*
7	* Copyright (C) 2008-2023 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	/**
29	* @todo list:
30	*
31	* 1) Detection of erroneous metric names
32	*/
33
34	#define LOG_GROUP LOG_GROUP_MAIN_PERFORMANCECOLLECTOR
35	#ifndef VBOX_COLLECTOR_TEST_CASE
36	# include "VirtualBoxImpl.h"
37	# include "MachineImpl.h"
38	# include "MediumImpl.h"
39	# include "AutoCaller.h"
40	#endif
41	#include "Performance.h"
42	#include "HostNetworkInterfaceImpl.h"
43	#include "netif.h"
44
45	#include <VBox/com/array.h>
46	#include <VBox/com/ptr.h>
47	#include <VBox/com/string.h>
48	#include <iprt/errcore.h>
49	#include <iprt/string.h>
50	#include <iprt/mem.h>
51	#include <iprt/cpuset.h>
52
53	#include <algorithm>
54
55	#include "LoggingNew.h"
56
57	using namespace pm;
58
59	// Stubs for non-pure virtual methods
60
61	int CollectorHAL::getHostCpuLoad(ULONG * /* user /, ULONG /* kernel /, ULONG /* idle */)
62	{
63	return VERR_NOT_IMPLEMENTED;
64	}
65
66	int CollectorHAL::getProcessCpuLoad(RTPROCESS /* process /, ULONG /* user /, ULONG /* kernel */)
67	{
68	return VERR_NOT_IMPLEMENTED;
69	}
70
71	int CollectorHAL::getRawHostCpuLoad(uint64_t * /* user /, uint64_t /* kernel /, uint64_t /* idle */)
72	{
73	return VERR_NOT_IMPLEMENTED;
74	}
75
76	int CollectorHAL::getRawHostNetworkLoad(const char * /* name /, uint64_t /* rx /, uint64_t /* tx */)
77	{
78	return VERR_NOT_IMPLEMENTED;
79	}
80
81	int CollectorHAL::getRawHostDiskLoad(const char * /* name /, uint64_t /* disk_ms /, uint64_t /* total_ms */)
82	{
83	return VERR_NOT_IMPLEMENTED;
84	}
85
86	int CollectorHAL::getRawProcessCpuLoad(RTPROCESS /* process /, uint64_t /* user */,
87	uint64_t * /* kernel /, uint64_t /* total */)
88	{
89	return VERR_NOT_IMPLEMENTED;
90	}
91
92	int CollectorHAL::getHostMemoryUsage(ULONG * /* total /, ULONG /* used /, ULONG /* available */)
93	{
94	return VERR_NOT_IMPLEMENTED;
95	}
96
97	int CollectorHAL::getHostFilesystemUsage(const char * /* name /, ULONG /* total /, ULONG /* used */,
98	ULONG * /* available */)
99	{
100	return VERR_NOT_IMPLEMENTED;
101	}
102
103	int CollectorHAL::getHostDiskSize(const char * /* name /, uint64_t /* size */)
104	{
105	return VERR_NOT_IMPLEMENTED;
106	}
107
108	int CollectorHAL::getProcessMemoryUsage(RTPROCESS /* process /, ULONG /* used */)
109	{
110	return VERR_NOT_IMPLEMENTED;
111	}
112
113	int CollectorHAL::getDiskListByFs(const char * /* name /, DiskList& / listUsage /, DiskList& / listLoad */)
114	{
115	return VERR_NOT_IMPLEMENTED;
116	}
117
118	/* Generic implementations */
119
120	int CollectorHAL::getHostCpuMHz(ULONG *mhz)
121	{
122	unsigned cCpus = 0;
123	uint64_t u64TotalMHz = 0;
124	RTCPUSET OnlineSet;
125	RTMpGetOnlineSet(&OnlineSet);
126	for (int iCpu = 0; iCpu < RTCPUSET_MAX_CPUS; iCpu++)
127	{
128	Log7Func(("{%p}: Checking if CPU %d is member of online set...\n", this, (int)iCpu));
129	if (RTCpuSetIsMemberByIndex(&OnlineSet, iCpu))
130	{
131	Log7Func(("{%p}: Getting frequency for CPU %d...\n", this, (int)iCpu));
132	uint32_t uMHz = RTMpGetCurFrequency(RTMpCpuIdFromSetIndex(iCpu));
133	if (uMHz != 0)
134	{
135	Log7Func(("{%p}: CPU %d %u MHz\n", this, (int)iCpu, uMHz));
136	u64TotalMHz += uMHz;
137	cCpus++;
138	}
139	}
140	}
141
142	if (cCpus)
143	{
144	*mhz = (ULONG)(u64TotalMHz / cCpus);
145	return VINF_SUCCESS;
146	}
147
148	/* This is always the case on darwin, so don't assert there. */
149	#ifndef RT_OS_DARWIN
150	AssertFailed();
151	#endif
152	*mhz = 0;
153	return VERR_NOT_IMPLEMENTED;
154	}
155
156	#ifndef VBOX_COLLECTOR_TEST_CASE
157
158	CollectorGuestQueue::CollectorGuestQueue()
159	{
160	mEvent = NIL_RTSEMEVENT;
161	RTSemEventCreate(&mEvent);
162	}
163
164	CollectorGuestQueue::~CollectorGuestQueue()
165	{
166	RTSemEventDestroy(mEvent);
167	}
168
169	void CollectorGuestQueue::push(CollectorGuestRequest* rq)
170	{
171	RTCLock lock(mLockMtx);
172
173	mQueue.push(rq);
174	RTSemEventSignal(mEvent);
175	}
176
177	CollectorGuestRequest* CollectorGuestQueue::pop()
178	{
179	int vrc = VINF_SUCCESS;
180	CollectorGuestRequest *rq = NULL;
181
182	do
183	{
184	{
185	RTCLock lock(mLockMtx);
186
187	if (!mQueue.empty())
188	{
189	rq = mQueue.front();
190	mQueue.pop();
191	}
192	}
193
194	if (rq)
195	return rq;
196	vrc = RTSemEventWaitNoResume(mEvent, RT_INDEFINITE_WAIT);
197	} while (RT_SUCCESS(vrc));
198
199	return NULL;
200	}
201
202	HRESULT CGRQEnable::execute()
203	{
204	Assert(mCGuest);
205	return mCGuest->enableInternal(mMask);
206	}
207
208	void CGRQEnable::debugPrint(void aObject, const char aFunction, const char *aText)
209	{
210	NOREF(aObject);
211	NOREF(aFunction);
212	NOREF(aText);
213	Log7((LOG_FN_FMT ": {%p}: CGRQEnable(mask=0x%x) %s\n", aObject, aFunction, mMask, aText));
214	}
215
216	HRESULT CGRQDisable::execute()
217	{
218	Assert(mCGuest);
219	return mCGuest->disableInternal(mMask);
220	}
221
222	void CGRQDisable::debugPrint(void aObject, const char aFunction, const char *aText)
223	{
224	NOREF(aObject);
225	NOREF(aFunction);
226	NOREF(aText);
227	Log7((LOG_FN_FMT ": {%p}: CGRQDisable(mask=0x%x) %s\n", aObject, aFunction, mMask, aText));
228	}
229
230	HRESULT CGRQAbort::execute()
231	{
232	return E_ABORT;
233	}
234
235	void CGRQAbort::debugPrint(void aObject, const char aFunction, const char *aText)
236	{
237	NOREF(aObject);
238	NOREF(aFunction);
239	NOREF(aText);
240	Log7((LOG_FN_FMT ": {%p}: CGRQAbort %s\n", aObject, aFunction, aText));
241	}
242
243	CollectorGuest::CollectorGuest(Machine *machine, RTPROCESS process) :
244	mUnregistered(false), mEnabled(false), mValid(false), mMachine(machine), mProcess(process),
245	mCpuUser(0), mCpuKernel(0), mCpuIdle(0),
246	mMemTotal(0), mMemFree(0), mMemBalloon(0), mMemShared(0), mMemCache(0), mPageTotal(0),
247	mAllocVMM(0), mFreeVMM(0), mBalloonedVMM(0), mSharedVMM(0), mVmNetRx(0), mVmNetTx(0)
248	{
249	Assert(mMachine);
250	/* cannot use ComObjPtr<Machine> in Performance.h, do it manually */
251	mMachine->AddRef();
252	}
253
254	CollectorGuest::~CollectorGuest()
255	{
256	/* cannot use ComObjPtr<Machine> in Performance.h, do it manually */
257	mMachine->Release();
258	// Assert(!cEnabled); why?
259	}
260
261	HRESULT CollectorGuest::enableVMMStats(bool mCollectVMMStats)
262	{
263	HRESULT hrc = S_OK;
264
265	if (mGuest)
266	{
267	/** @todo replace this with a direct call to mGuest in trunk! */
268	AutoCaller autoCaller(mMachine);
269	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
270
271	ComPtr<IInternalSessionControl> directControl;
272
273	hrc = mMachine->i_getDirectControl(&directControl);
274	if (hrc != S_OK)
275	return hrc;
276
277	/* enable statistics collection; this is a remote call (!) */
278	hrc = directControl->EnableVMMStatistics(mCollectVMMStats);
279	Log7Func(("{%p}: %sable VMM stats (%s)\n",
280	this, mCollectVMMStats ? "En" : "Dis", SUCCEEDED(hrc) ? "success" : "failed"));
281	}
282
283	return hrc;
284	}
285
286	HRESULT CollectorGuest::enable(ULONG mask)
287	{
288	return enqueueRequest(new CGRQEnable(mask));
289	}
290
291	HRESULT CollectorGuest::disable(ULONG mask)
292	{
293	return enqueueRequest(new CGRQDisable(mask));
294	}
295
296	HRESULT CollectorGuest::enableInternal(ULONG mask)
297	{
298	HRESULT ret = S_OK;
299
300	if ((mEnabled & mask) == mask)
301	return E_UNEXPECTED;
302
303	if (!mEnabled)
304	{
305	/* Must make sure that the machine object does not get uninitialized
306	* in the middle of enabling this collector. Causes timing-related
307	* behavior otherwise, which we don't want. In particular the
308	* GetRemoteConsole call below can hang if the VM didn't completely
309	* terminate (the VM processes stop processing events shortly before
310	* closing the session). This avoids the hang. */
311	AutoCaller autoCaller(mMachine);
312	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
313
314	mMachineName = mMachine->i_getName();
315
316	ComPtr<IInternalSessionControl> directControl;
317
318	ret = mMachine->i_getDirectControl(&directControl);
319	if (ret != S_OK)
320	return ret;
321
322	/* get the associated console; this is a remote call (!) */
323	ret = directControl->COMGETTER(RemoteConsole)(mConsole.asOutParam());
324	if (ret != S_OK)
325	return ret;
326
327	ret = mConsole->COMGETTER(Guest)(mGuest.asOutParam());
328	if (ret == S_OK)
329	{
330	ret = mGuest->COMSETTER(StatisticsUpdateInterval)(1 /* 1 sec */);
331	Log7Func(("{%p}: Set guest statistics update interval to 1 sec (%s)\n",
332	this, SUCCEEDED(ret) ? "success" : "failed"));
333	}
334	}
335	if ((mask & VMSTATS_VMM_RAM) == VMSTATS_VMM_RAM)
336	enableVMMStats(true);
337	mEnabled \|= mask;
338
339	return ret;
340	}
341
342	HRESULT CollectorGuest::disableInternal(ULONG mask)
343	{
344	if (!(mEnabled & mask))
345	return E_UNEXPECTED;
346
347	if ((mask & VMSTATS_VMM_RAM) == VMSTATS_VMM_RAM)
348	enableVMMStats(false);
349	mEnabled &= ~mask;
350	if (!mEnabled)
351	{
352	Assert(mGuest && mConsole);
353	HRESULT ret = mGuest->COMSETTER(StatisticsUpdateInterval)(0 /* off */);
354	NOREF(ret);
355	Log7Func(("{%p}: Set guest statistics update interval to 0 sec (%s)\n",
356	this, SUCCEEDED(ret) ? "success" : "failed"));
357	invalidate(VMSTATS_ALL);
358	}
359
360	return S_OK;
361	}
362
363	HRESULT CollectorGuest::enqueueRequest(CollectorGuestRequest *aRequest)
364	{
365	if (mManager)
366	{
367	aRequest->setGuest(this);
368	return mManager->enqueueRequest(aRequest);
369	}
370
371	Log7Func(("{%p}: Attempted enqueue guest request when mManager is null\n", this));
372	return E_POINTER;
373	}
374
375	void CollectorGuest::updateStats(ULONG aValidStats, ULONG aCpuUser,
376	ULONG aCpuKernel, ULONG aCpuIdle,
377	ULONG aMemTotal, ULONG aMemFree,
378	ULONG aMemBalloon, ULONG aMemShared,
379	ULONG aMemCache, ULONG aPageTotal,
380	ULONG aAllocVMM, ULONG aFreeVMM,
381	ULONG aBalloonedVMM, ULONG aSharedVMM,
382	ULONG aVmNetRx, ULONG aVmNetTx)
383	{
384	if ((aValidStats & VMSTATS_GUEST_CPULOAD) == VMSTATS_GUEST_CPULOAD)
385	{
386	mCpuUser = aCpuUser;
387	mCpuKernel = aCpuKernel,
388	mCpuIdle = aCpuIdle;
389	}
390	if ((aValidStats & VMSTATS_GUEST_RAMUSAGE) == VMSTATS_GUEST_RAMUSAGE)
391	{
392	mMemTotal = aMemTotal;
393	mMemFree = aMemFree;
394	mMemBalloon = aMemBalloon;
395	mMemShared = aMemShared;
396	mMemCache = aMemCache;
397	mPageTotal = aPageTotal;
398	}
399	if ((aValidStats & VMSTATS_VMM_RAM) == VMSTATS_VMM_RAM)
400	{
401	mAllocVMM = aAllocVMM;
402	mFreeVMM = aFreeVMM;
403	mBalloonedVMM = aBalloonedVMM;
404	mSharedVMM = aSharedVMM;
405	}
406	if ((aValidStats & VMSTATS_NET_RATE) == VMSTATS_NET_RATE)
407	{
408	mVmNetRx = aVmNetRx;
409	mVmNetTx = aVmNetTx;
410	}
411	mValid = aValidStats;
412	}
413
414	CollectorGuestManager::CollectorGuestManager()
415	: mVMMStatsProvider(NULL), mGuestBeingCalled(NULL)
416	{
417	int vrc = RTThreadCreate(&mThread, CollectorGuestManager::requestProcessingThread,
418	this, 0, RTTHREADTYPE_MAIN_WORKER, RTTHREADFLAGS_WAITABLE,
419	"CGMgr");
420	NOREF(vrc);
421	Log7Func(("{%p}: RTThreadCreate returned %Rrc (mThread=%p)\n", this, vrc, mThread));
422	}
423
424	CollectorGuestManager::~CollectorGuestManager()
425	{
426	Assert(mGuests.size() == 0);
427	HRESULT hrc = enqueueRequest(new CGRQAbort());
428	if (SUCCEEDED(hrc))
429	{
430	/* We wait only if we were able to put the abort request to a queue */
431	Log7Func(("{%p}: Waiting for CGM request processing thread to stop...\n", this));
432	int vrcThread = VINF_SUCCESS;
433	int vrc = RTThreadWait(mThread, 1000 /* 1 sec */, &vrcThread);
434	Log7Func(("{%p}: RTThreadWait returned %Rrc (thread exit code: %Rrc)\n", this, vrc, vrcThread));
435	RT_NOREF(vrc);
436	}
437	}
438
439	void CollectorGuestManager::registerGuest(CollectorGuest* pGuest)
440	{
441	pGuest->setManager(this);
442	mGuests.push_back(pGuest);
443	/*
444	* If no VMM stats provider was elected previously than this is our
445	* candidate.
446	*/
447	if (!mVMMStatsProvider)
448	mVMMStatsProvider = pGuest;
449	Log7Func(("{%p}: Registered guest=%p provider=%p\n", this, pGuest, mVMMStatsProvider));
450	}
451
452	void CollectorGuestManager::unregisterGuest(CollectorGuest* pGuest)
453	{
454	Log7Func(("{%p}: About to unregister guest=%p provider=%p\n", this, pGuest, mVMMStatsProvider));
455	//mGuests.remove(pGuest); => destroyUnregistered()
456	pGuest->unregister();
457	if (pGuest == mVMMStatsProvider)
458	{
459	/* This was our VMM stats provider, it is time to re-elect */
460	CollectorGuestList::iterator it;
461	/* Assume that nobody can provide VMM stats */
462	mVMMStatsProvider = NULL;
463
464	for (it = mGuests.begin(); it != mGuests.end(); ++it)
465	{
466	/* Skip unregistered as they are about to be destroyed */
467	if ((*it)->isUnregistered())
468	continue;
469
470	if ((*it)->isEnabled())
471	{
472	/* Found the guest already collecting stats, elect it */
473	mVMMStatsProvider = *it;
474	HRESULT hrc = mVMMStatsProvider->enqueueRequest(new CGRQEnable(VMSTATS_VMM_RAM));
475	if (FAILED(hrc))
476	{
477	/* This is not a good candidate -- try to find another */
478	mVMMStatsProvider = NULL;
479	continue;
480	}
481	break;
482	}
483	}
484	if (!mVMMStatsProvider)
485	{
486	/* If nobody collects stats, take the first registered */
487	for (it = mGuests.begin(); it != mGuests.end(); ++it)
488	{
489	/* Skip unregistered as they are about to be destroyed */
490	if ((*it)->isUnregistered())
491	continue;
492
493	mVMMStatsProvider = *it;
494	//mVMMStatsProvider->enable(VMSTATS_VMM_RAM);
495	HRESULT hrc = mVMMStatsProvider->enqueueRequest(new CGRQEnable(VMSTATS_VMM_RAM));
496	if (SUCCEEDED(hrc))
497	break;
498	/* This was not a good candidate -- try to find another */
499	mVMMStatsProvider = NULL;
500	}
501	}
502	}
503	Log7Func(("[%p}: LEAVE new provider=%p\n", this, mVMMStatsProvider));
504	}
505
506	void CollectorGuestManager::destroyUnregistered()
507	{
508	CollectorGuestList::iterator it;
509
510	for (it = mGuests.begin(); it != mGuests.end();)
511	if ((*it)->isUnregistered())
512	{
513	delete *it;
514	it = mGuests.erase(it);
515	Log7Func(("{%p}: Number of guests after erasing unregistered is %d\n",
516	this, mGuests.size()));
517	}
518	else
519	++it;
520	}
521
522	HRESULT CollectorGuestManager::enqueueRequest(CollectorGuestRequest *aRequest)
523	{
524	#ifdef DEBUG
525	aRequest->debugPrint(this, __PRETTY_FUNCTION__, "added to CGM queue");
526	#endif /* DEBUG */
527	/*
528	* It is very unlikely that we will get high frequency calls to configure
529	* guest metrics collection, so we rely on this fact to detect blocked
530	* guests. If the guest has not finished processing the previous request
531	* after half a second we consider it blocked.
532	*/
533	if (aRequest->getGuest() && aRequest->getGuest() == mGuestBeingCalled)
534	{
535	/*
536	* Before we can declare a guest blocked we need to wait for a while
537	* and then check again as it may never had a chance to process
538	* the previous request. Half a second is an eternity for processes
539	* and is barely noticable by humans.
540	*/
541	Log7Func(("{%p}: Suspecting %s is stalled. Waiting for .5 sec...\n",
542	this, aRequest->getGuest()->getVMName().c_str()));
543	RTThreadSleep(500 /* ms */);
544	if (aRequest->getGuest() == mGuestBeingCalled) {
545	Log7Func(("{%p}: Request processing stalled for %s\n",
546	this, aRequest->getGuest()->getVMName().c_str()));
547	/* Request execution got stalled for this guest -- report an error */
548	return E_FAIL;
549	}
550	}
551	mQueue.push(aRequest);
552	return S_OK;
553	}
554
555	/* static */
556	DECLCALLBACK(int) CollectorGuestManager::requestProcessingThread(RTTHREAD /* aThread /, void pvUser)
557	{
558	CollectorGuestRequest *pReq;
559	CollectorGuestManager mgr = static_cast<CollectorGuestManager>(pvUser);
560
561	HRESULT hrc = S_OK;
562
563	Log7Func(("{%p}: Starting request processing loop...\n", mgr));
564	while ((pReq = mgr->mQueue.pop()) != NULL)
565	{
566	#ifdef DEBUG
567	pReq->debugPrint(mgr, __PRETTY_FUNCTION__, "is being executed...");
568	#endif /* DEBUG */
569	mgr->mGuestBeingCalled = pReq->getGuest();
570	hrc = pReq->execute();
571	mgr->mGuestBeingCalled = NULL;
572	delete pReq;
573	if (hrc == E_ABORT)
574	break;
575	if (FAILED(hrc))
576	Log7Func(("{%p}: request::execute returned %Rhrc\n", mgr, hrc));
577	}
578	Log7Func(("{%p}: Exiting request processing loop... hrc=%Rhrc\n", mgr, hrc));
579
580	return VINF_SUCCESS;
581	}
582
583
584	#endif /* !VBOX_COLLECTOR_TEST_CASE */
585
586	bool BaseMetric::collectorBeat(uint64_t nowAt)
587	{
588	if (isEnabled())
589	{
590	if (mLastSampleTaken == 0)
591	{
592	mLastSampleTaken = nowAt;
593	Log4Func(("{%p}: Collecting %s for obj(%p)...\n",
594	this, getName(), (void *)mObject));
595	return true;
596	}
597	/*
598	* We use low resolution timers which may fire just a little bit early.
599	* We compensate for that by jumping into the future by several
600	* milliseconds (see @bugref{6345}).
601	*/
602	if (nowAt - mLastSampleTaken + PM_SAMPLER_PRECISION_MS >= mPeriod * 1000)
603	{
604	/*
605	* We don't want the beat to drift. This is why the timestamp of
606	* the last taken sample is not the actual time but the time we
607	* should have taken the measurement at.
608	*/
609	mLastSampleTaken += mPeriod * 1000;
610	Log4Func(("{%p}: Collecting %s for obj(%p)...\n",
611	this, getName(), (void *)mObject));
612	return true;
613	}
614	Log4Func(("{%p}: Enabled but too early to collect %s for obj(%p)\n",
615	this, getName(), (void *)mObject));
616	}
617	return false;
618	}
619
620	void HostCpuLoad::init(ULONG period, ULONG length)
621	{
622	mPeriod = period;
623	mLength = length;
624	mUser->init(mLength);
625	mKernel->init(mLength);
626	mIdle->init(mLength);
627	}
628
629	void HostCpuLoad::collect()
630	{
631	ULONG user, kernel, idle;
632	int vrc = mHAL->getHostCpuLoad(&user, &kernel, &idle);
633	if (RT_SUCCESS(vrc))
634	{
635	mUser->put(user);
636	mKernel->put(kernel);
637	mIdle->put(idle);
638	}
639	}
640
641	void HostCpuLoadRaw::init(ULONG period, ULONG length)
642	{
643	HostCpuLoad::init(period, length);
644	mHAL->getRawHostCpuLoad(&mUserPrev, &mKernelPrev, &mIdlePrev);
645	}
646
647	void HostCpuLoadRaw::preCollect(CollectorHints& hints, uint64_t /* iTick */)
648	{
649	hints.collectHostCpuLoad();
650	}
651
652	void HostCpuLoadRaw::collect()
653	{
654	uint64_t user, kernel, idle;
655	uint64_t userDiff, kernelDiff, idleDiff, totalDiff;
656
657	int vrc = mHAL->getRawHostCpuLoad(&user, &kernel, &idle);
658	if (RT_SUCCESS(vrc))
659	{
660	userDiff = user - mUserPrev;
661	kernelDiff = kernel - mKernelPrev;
662	idleDiff = idle - mIdlePrev;
663	totalDiff = userDiff + kernelDiff + idleDiff;
664
665	if (totalDiff == 0)
666	{
667	/* This is only possible if none of counters has changed! */
668	LogFlowThisFunc(("Impossible! User, kernel and idle raw "
669	"counters has not changed since last sample.\n" ));
670	mUser->put(0);
671	mKernel->put(0);
672	mIdle->put(0);
673	}
674	else
675	{
676	mUser->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * userDiff / totalDiff));
677	mKernel->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * kernelDiff / totalDiff));
678	mIdle->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * idleDiff / totalDiff));
679	}
680
681	mUserPrev = user;
682	mKernelPrev = kernel;
683	mIdlePrev = idle;
684	}
685	}
686
687	#ifndef VBOX_COLLECTOR_TEST_CASE
688	static bool getLinkSpeed(const char szShortName, uint32_t pSpeed)
689	{
690	# ifdef VBOX_WITH_HOSTNETIF_API
691	NETIFSTATUS enmState = NETIF_S_UNKNOWN;
692	int vrc = NetIfGetState(szShortName, &enmState);
693	if (RT_FAILURE(vrc))
694	return false;
695	if (enmState != NETIF_S_UP)
696	*pSpeed = 0;
697	else
698	{
699	vrc = NetIfGetLinkSpeed(szShortName, pSpeed);
700	if (RT_FAILURE(vrc))
701	return false;
702	}
703	return true;
704	# else /* !VBOX_WITH_HOSTNETIF_API */
705	RT_NOREF(szShortName, pSpeed);
706	return false;
707	# endif /* VBOX_WITH_HOSTNETIF_API */
708	}
709
710	void HostNetworkSpeed::init(ULONG period, ULONG length)
711	{
712	mPeriod = period;
713	mLength = length;
714	mLinkSpeed->init(length);
715	/*
716	* Retrieve the link speed now as it may be wrong if the metric was
717	* registered at boot (see @bugref{6613}).
718	*/
719	getLinkSpeed(mShortName.c_str(), &mSpeed);
720	}
721
722	void HostNetworkLoadRaw::init(ULONG period, ULONG length)
723	{
724	mPeriod = period;
725	mLength = length;
726	mRx->init(mLength);
727	mTx->init(mLength);
728	/*
729	* Retrieve the link speed now as it may be wrong if the metric was
730	* registered at boot (see @bugref{6613}).
731	*/
732	uint32_t uSpeedMbit = 65535;
733	if (getLinkSpeed(mShortName.c_str(), &uSpeedMbit))
734	mSpeed = (uint64_t)uSpeedMbit * (1000000/8); /* Convert to bytes/sec */
735	/int vrc =/ mHAL->getRawHostNetworkLoad(mShortName.c_str(), &mRxPrev, &mTxPrev);
736	//AssertRC(vrc);
737	}
738
739	void HostNetworkLoadRaw::preCollect(CollectorHints& /* hints /, uint64_t / iTick */)
740	{
741	if (RT_FAILURE(mRc))
742	{
743	ComPtr<IHostNetworkInterface> networkInterface;
744	ComPtr<IHost> host = getObject();
745	HRESULT hrc = host->FindHostNetworkInterfaceByName(com::Bstr(mInterfaceName).raw(), networkInterface.asOutParam());
746	if (SUCCEEDED(hrc))
747	{
748	static uint32_t s_tsLogRelLast;
749	uint32_t tsNow = RTTimeProgramSecTS();
750	if ( tsNow < RT_SEC_1HOUR
751	\|\| (tsNow - s_tsLogRelLast >= 60))
752	{
753	s_tsLogRelLast = tsNow;
754	LogRel(("Failed to collect network metrics for %s: %Rrc (%d). Max one msg/min.\n", mInterfaceName.c_str(), mRc, mRc));
755	}
756	mRc = VINF_SUCCESS;
757	}
758	}
759	}
760
761	void HostNetworkLoadRaw::collect()
762	{
763	uint64_t rx = mRxPrev;
764	uint64_t tx = mTxPrev;
765
766	if (RT_UNLIKELY(mSpeed * getPeriod() == 0))
767	{
768	LogFlowThisFunc(("Check cable for %s! speed=%llu period=%d.\n", mShortName.c_str(), mSpeed, getPeriod()));
769	/* We do not collect host network metrics for unplugged interfaces! */
770	return;
771	}
772	mRc = mHAL->getRawHostNetworkLoad(mShortName.c_str(), &rx, &tx);
773	if (RT_SUCCESS(mRc))
774	{
775	uint64_t rxDiff = rx - mRxPrev;
776	uint64_t txDiff = tx - mTxPrev;
777
778	mRx->put((ULONG)(PM_NETWORK_LOAD_MULTIPLIER * rxDiff / (mSpeed * getPeriod())));
779	mTx->put((ULONG)(PM_NETWORK_LOAD_MULTIPLIER * txDiff / (mSpeed * getPeriod())));
780
781	mRxPrev = rx;
782	mTxPrev = tx;
783	}
784	else
785	LogFlowThisFunc(("Failed to collect data: %Rrc (%d)."
786	" Will update the list of interfaces...\n", mRc,mRc));
787	}
788	#endif /* !VBOX_COLLECTOR_TEST_CASE */
789
790	void HostDiskLoadRaw::init(ULONG period, ULONG length)
791	{
792	mPeriod = period;
793	mLength = length;
794	mUtil->init(mLength);
795	int vrc = mHAL->getRawHostDiskLoad(mDiskName.c_str(), &mDiskPrev, &mTotalPrev);
796	AssertRC(vrc);
797	}
798
799	void HostDiskLoadRaw::preCollect(CollectorHints& hints, uint64_t /* iTick */)
800	{
801	hints.collectHostCpuLoad();
802	}
803
804	void HostDiskLoadRaw::collect()
805	{
806	uint64_t disk, total;
807
808	int vrc = mHAL->getRawHostDiskLoad(mDiskName.c_str(), &disk, &total);
809	if (RT_SUCCESS(vrc))
810	{
811	uint64_t diskDiff = disk - mDiskPrev;
812	uint64_t totalDiff = total - mTotalPrev;
813
814	if (RT_UNLIKELY(totalDiff == 0))
815	{
816	Assert(totalDiff);
817	LogFlowThisFunc(("Improbable! Less than millisecond passed! Disk=%s\n", mDiskName.c_str()));
818	mUtil->put(0);
819	}
820	else if (diskDiff > totalDiff)
821	{
822	/*
823	* It is possible that the disk spent more time than CPU because
824	* CPU measurements are taken during the pre-collect phase. We try
825	* to compensate for than by adding the extra to the next round of
826	* measurements.
827	*/
828	mUtil->put(PM_NETWORK_LOAD_MULTIPLIER);
829	Assert((diskDiff - totalDiff) < mPeriod * 1000);
830	if ((diskDiff - totalDiff) > mPeriod * 1000)
831	{
832	LogRel(("Disk utilization time exceeds CPU time by more"
833	" than the collection period (%llu ms)\n", diskDiff - totalDiff));
834	}
835	else
836	{
837	disk = mDiskPrev + totalDiff;
838	LogFlowThisFunc(("Moved %u milliseconds to the next period.\n", (unsigned)(diskDiff - totalDiff)));
839	}
840	}
841	else
842	{
843	mUtil->put((ULONG)(PM_NETWORK_LOAD_MULTIPLIER * diskDiff / totalDiff));
844	}
845
846	mDiskPrev = disk;
847	mTotalPrev = total;
848	}
849	else
850	LogFlowThisFunc(("Failed to collect data: %Rrc (%d)\n", vrc, vrc));
851	}
852
853	void HostCpuMhz::init(ULONG period, ULONG length)
854	{
855	mPeriod = period;
856	mLength = length;
857	mMHz->init(mLength);
858	}
859
860	void HostCpuMhz::collect()
861	{
862	ULONG mhz;
863	int vrc = mHAL->getHostCpuMHz(&mhz);
864	if (RT_SUCCESS(vrc))
865	mMHz->put(mhz);
866	}
867
868	void HostRamUsage::init(ULONG period, ULONG length)
869	{
870	mPeriod = period;
871	mLength = length;
872	mTotal->init(mLength);
873	mUsed->init(mLength);
874	mAvailable->init(mLength);
875	}
876
877	void HostRamUsage::preCollect(CollectorHints& hints, uint64_t /* iTick */)
878	{
879	hints.collectHostRamUsage();
880	}
881
882	void HostRamUsage::collect()
883	{
884	ULONG total, used, available;
885	int vrc = mHAL->getHostMemoryUsage(&total, &used, &available);
886	if (RT_SUCCESS(vrc))
887	{
888	mTotal->put(total);
889	mUsed->put(used);
890	mAvailable->put(available);
891	}
892	}
893
894	void HostFilesystemUsage::init(ULONG period, ULONG length)
895	{
896	mPeriod = period;
897	mLength = length;
898	mTotal->init(mLength);
899	mUsed->init(mLength);
900	mAvailable->init(mLength);
901	}
902
903	void HostFilesystemUsage::preCollect(CollectorHints& /* hints /, uint64_t / iTick */)
904	{
905	}
906
907	void HostFilesystemUsage::collect()
908	{
909	ULONG total, used, available;
910	int vrc = mHAL->getHostFilesystemUsage(mFsName.c_str(), &total, &used, &available);
911	if (RT_SUCCESS(vrc))
912	{
913	mTotal->put(total);
914	mUsed->put(used);
915	mAvailable->put(available);
916	}
917	}
918
919	void HostDiskUsage::init(ULONG period, ULONG length)
920	{
921	mPeriod = period;
922	mLength = length;
923	mTotal->init(mLength);
924	}
925
926	void HostDiskUsage::preCollect(CollectorHints& /* hints /, uint64_t / iTick */)
927	{
928	}
929
930	void HostDiskUsage::collect()
931	{
932	uint64_t total;
933	int vrc = mHAL->getHostDiskSize(mDiskName.c_str(), &total);
934	if (RT_SUCCESS(vrc))
935	mTotal->put((ULONG)(total / _1M));
936	}
937
938	#ifndef VBOX_COLLECTOR_TEST_CASE
939
940	void HostRamVmm::init(ULONG period, ULONG length)
941	{
942	mPeriod = period;
943	mLength = length;
944	mAllocVMM->init(mLength);
945	mFreeVMM->init(mLength);
946	mBalloonVMM->init(mLength);
947	mSharedVMM->init(mLength);
948	}
949
950	HRESULT HostRamVmm::enable()
951	{
952	HRESULT hrc = S_OK;
953	CollectorGuest *provider = mCollectorGuestManager->getVMMStatsProvider();
954	if (provider)
955	hrc = provider->enable(VMSTATS_VMM_RAM);
956	BaseMetric::enable();
957	return hrc;
958	}
959
960	HRESULT HostRamVmm::disable()
961	{
962	HRESULT hrc = S_OK;
963	BaseMetric::disable();
964	CollectorGuest *provider = mCollectorGuestManager->getVMMStatsProvider();
965	if (provider)
966	hrc = provider->disable(VMSTATS_VMM_RAM);
967	return hrc;
968	}
969
970	void HostRamVmm::preCollect(CollectorHints& hints, uint64_t /* iTick */)
971	{
972	hints.collectHostRamVmm();
973	}
974
975	void HostRamVmm::collect()
976	{
977	CollectorGuest *provider = mCollectorGuestManager->getVMMStatsProvider();
978	if (provider)
979	{
980	Log7Func(("{%p}: provider=%p enabled=%RTbool valid=%RTbool...\n",
981	this, provider, provider->isEnabled(), provider->isValid(VMSTATS_VMM_RAM) ));
982	if (provider->isValid(VMSTATS_VMM_RAM))
983	{
984	/* Provider is ready, get updated stats */
985	mAllocCurrent = provider->getAllocVMM();
986	mFreeCurrent = provider->getFreeVMM();
987	mBalloonedCurrent = provider->getBalloonedVMM();
988	mSharedCurrent = provider->getSharedVMM();
989	provider->invalidate(VMSTATS_VMM_RAM);
990	}
991	/*
992	* Note that if there are no new values from the provider we will use
993	* the ones most recently provided instead of zeros, which is probably
994	* a desirable behavior.
995	*/
996	}
997	else
998	{
999	mAllocCurrent = 0;
1000	mFreeCurrent = 0;
1001	mBalloonedCurrent = 0;
1002	mSharedCurrent = 0;
1003	}
1004	Log7Func(("{%p}: mAllocCurrent=%u mFreeCurrent=%u mBalloonedCurrent=%u mSharedCurrent=%u\n",
1005	this, mAllocCurrent, mFreeCurrent, mBalloonedCurrent, mSharedCurrent));
1006	mAllocVMM->put(mAllocCurrent);
1007	mFreeVMM->put(mFreeCurrent);
1008	mBalloonVMM->put(mBalloonedCurrent);
1009	mSharedVMM->put(mSharedCurrent);
1010	}
1011
1012	#endif /* !VBOX_COLLECTOR_TEST_CASE */
1013
1014
1015
1016	void MachineCpuLoad::init(ULONG period, ULONG length)
1017	{
1018	mPeriod = period;
1019	mLength = length;
1020	mUser->init(mLength);
1021	mKernel->init(mLength);
1022	}
1023
1024	void MachineCpuLoad::collect()
1025	{
1026	ULONG user, kernel;
1027	int vrc = mHAL->getProcessCpuLoad(mProcess, &user, &kernel);
1028	if (RT_SUCCESS(vrc))
1029	{
1030	mUser->put(user);
1031	mKernel->put(kernel);
1032	}
1033	}
1034
1035	void MachineCpuLoadRaw::preCollect(CollectorHints& hints, uint64_t /* iTick */)
1036	{
1037	hints.collectProcessCpuLoad(mProcess);
1038	}
1039
1040	void MachineCpuLoadRaw::collect()
1041	{
1042	uint64_t processUser, processKernel, hostTotal;
1043
1044	int vrc = mHAL->getRawProcessCpuLoad(mProcess, &processUser, &processKernel, &hostTotal);
1045	if (RT_SUCCESS(vrc))
1046	{
1047	if (hostTotal == mHostTotalPrev)
1048	{
1049	/* Nearly impossible, but... */
1050	mUser->put(0);
1051	mKernel->put(0);
1052	}
1053	else
1054	{
1055	mUser->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * (processUser - mProcessUserPrev) / (hostTotal - mHostTotalPrev)));
1056	mKernel->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * (processKernel - mProcessKernelPrev ) / (hostTotal - mHostTotalPrev)));
1057	}
1058
1059	mHostTotalPrev = hostTotal;
1060	mProcessUserPrev = processUser;
1061	mProcessKernelPrev = processKernel;
1062	}
1063	}
1064
1065	void MachineRamUsage::init(ULONG period, ULONG length)
1066	{
1067	mPeriod = period;
1068	mLength = length;
1069	mUsed->init(mLength);
1070	}
1071
1072	void MachineRamUsage::preCollect(CollectorHints& hints, uint64_t /* iTick */)
1073	{
1074	hints.collectProcessRamUsage(mProcess);
1075	}
1076
1077	void MachineRamUsage::collect()
1078	{
1079	ULONG used;
1080	int vrc = mHAL->getProcessMemoryUsage(mProcess, &used);
1081	if (RT_SUCCESS(vrc))
1082	mUsed->put(used);
1083	}
1084
1085
1086	#ifndef VBOX_COLLECTOR_TEST_CASE
1087
1088	void MachineDiskUsage::init(ULONG period, ULONG length)
1089	{
1090	mPeriod = period;
1091	mLength = length;
1092	mUsed->init(mLength);
1093	}
1094
1095	void MachineDiskUsage::preCollect(CollectorHints& /* hints /, uint64_t / iTick */)
1096	{
1097	}
1098
1099	void MachineDiskUsage::collect()
1100	{
1101	ULONG used = 0;
1102
1103	for (MediaList::iterator it = mDisks.begin(); it != mDisks.end(); ++it)
1104	{
1105	ComObjPtr<Medium> pMedium = *it;
1106
1107	/* just in case */
1108	AssertContinue(!pMedium.isNull());
1109
1110	AutoCaller localAutoCaller(pMedium);
1111	if (FAILED(localAutoCaller.hrc())) continue;
1112
1113	AutoReadLock local_alock(pMedium COMMA_LOCKVAL_SRC_POS);
1114
1115	used += (ULONG)(pMedium->i_getSize() / _1M);
1116	}
1117
1118	mUsed->put(used);
1119	}
1120
1121	void MachineNetRate::init(ULONG period, ULONG length)
1122	{
1123	mPeriod = period;
1124	mLength = length;
1125
1126	mRx->init(mLength);
1127	mTx->init(mLength);
1128	}
1129
1130	void MachineNetRate::collect()
1131	{
1132	if (mCGuest->isValid(VMSTATS_NET_RATE))
1133	{
1134	mRx->put(mCGuest->getVmNetRx());
1135	mTx->put(mCGuest->getVmNetTx());
1136	mCGuest->invalidate(VMSTATS_NET_RATE);
1137	}
1138	}
1139
1140	HRESULT MachineNetRate::enable()
1141	{
1142	HRESULT hrc = mCGuest->enable(VMSTATS_NET_RATE);
1143	BaseMetric::enable();
1144	return hrc;
1145	}
1146
1147	HRESULT MachineNetRate::disable()
1148	{
1149	BaseMetric::disable();
1150	return mCGuest->disable(VMSTATS_NET_RATE);
1151	}
1152
1153	void MachineNetRate::preCollect(CollectorHints& hints, uint64_t /* iTick */)
1154	{
1155	hints.collectGuestStats(mCGuest->getProcess());
1156	}
1157
1158	void GuestCpuLoad::init(ULONG period, ULONG length)
1159	{
1160	mPeriod = period;
1161	mLength = length;
1162
1163	mUser->init(mLength);
1164	mKernel->init(mLength);
1165	mIdle->init(mLength);
1166	}
1167
1168	void GuestCpuLoad::preCollect(CollectorHints& hints, uint64_t /* iTick */)
1169	{
1170	hints.collectGuestStats(mCGuest->getProcess());
1171	}
1172
1173	void GuestCpuLoad::collect()
1174	{
1175	if (mCGuest->isValid(VMSTATS_GUEST_CPULOAD))
1176	{
1177	mUser->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * mCGuest->getCpuUser()) / 100);
1178	mKernel->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * mCGuest->getCpuKernel()) / 100);
1179	mIdle->put((ULONG)(PM_CPU_LOAD_MULTIPLIER * mCGuest->getCpuIdle()) / 100);
1180	mCGuest->invalidate(VMSTATS_GUEST_CPULOAD);
1181	}
1182	}
1183
1184	HRESULT GuestCpuLoad::enable()
1185	{
1186	HRESULT hrc = mCGuest->enable(VMSTATS_GUEST_CPULOAD);
1187	BaseMetric::enable();
1188	return hrc;
1189	}
1190
1191	HRESULT GuestCpuLoad::disable()
1192	{
1193	BaseMetric::disable();
1194	return mCGuest->disable(VMSTATS_GUEST_CPULOAD);
1195	}
1196
1197	void GuestRamUsage::init(ULONG period, ULONG length)
1198	{
1199	mPeriod = period;
1200	mLength = length;
1201
1202	mTotal->init(mLength);
1203	mFree->init(mLength);
1204	mBallooned->init(mLength);
1205	mShared->init(mLength);
1206	mCache->init(mLength);
1207	mPagedTotal->init(mLength);
1208	}
1209
1210	void GuestRamUsage::collect()
1211	{
1212	if (mCGuest->isValid(VMSTATS_GUEST_RAMUSAGE))
1213	{
1214	mTotal->put(mCGuest->getMemTotal());
1215	mFree->put(mCGuest->getMemFree());
1216	mBallooned->put(mCGuest->getMemBalloon());
1217	mShared->put(mCGuest->getMemShared());
1218	mCache->put(mCGuest->getMemCache());
1219	mPagedTotal->put(mCGuest->getPageTotal());
1220	mCGuest->invalidate(VMSTATS_GUEST_RAMUSAGE);
1221	}
1222	}
1223
1224	HRESULT GuestRamUsage::enable()
1225	{
1226	HRESULT hrc = mCGuest->enable(VMSTATS_GUEST_RAMUSAGE);
1227	BaseMetric::enable();
1228	return hrc;
1229	}
1230
1231	HRESULT GuestRamUsage::disable()
1232	{
1233	BaseMetric::disable();
1234	return mCGuest->disable(VMSTATS_GUEST_RAMUSAGE);
1235	}
1236
1237	void GuestRamUsage::preCollect(CollectorHints& hints, uint64_t /* iTick */)
1238	{
1239	hints.collectGuestStats(mCGuest->getProcess());
1240	}
1241
1242	#endif /* !VBOX_COLLECTOR_TEST_CASE */
1243
1244	void CircularBuffer::init(ULONG ulLength)
1245	{
1246	if (mData)
1247	RTMemFree(mData);
1248	mLength = ulLength;
1249	if (mLength)
1250	mData = (ULONG)RTMemAllocZ(ulLength sizeof(ULONG));
1251	else
1252	mData = NULL;
1253	mWrapped = false;
1254	mEnd = 0;
1255	mSequenceNumber = 0;
1256	}
1257
1258	ULONG CircularBuffer::length()
1259	{
1260	return mWrapped ? mLength : mEnd;
1261	}
1262
1263	void CircularBuffer::put(ULONG value)
1264	{
1265	if (mData)
1266	{
1267	mData[mEnd++] = value;
1268	if (mEnd >= mLength)
1269	{
1270	mEnd = 0;
1271	mWrapped = true;
1272	}
1273	++mSequenceNumber;
1274	}
1275	}
1276
1277	void CircularBuffer::copyTo(ULONG *data)
1278	{
1279	if (mWrapped)
1280	{
1281	memcpy(data, mData + mEnd, (mLength - mEnd) * sizeof(ULONG));
1282	// Copy the wrapped part
1283	if (mEnd)
1284	memcpy(data + (mLength - mEnd), mData, mEnd * sizeof(ULONG));
1285	}
1286	else
1287	memcpy(data, mData, mEnd * sizeof(ULONG));
1288	}
1289
1290	void SubMetric::query(ULONG *data)
1291	{
1292	copyTo(data);
1293	}
1294
1295	void Metric::query(ULONG *data, ULONG count, ULONG *sequenceNumber)
1296	{
1297	ULONG length;
1298	ULONG *tmpData;
1299
1300	length = mSubMetric->length();
1301	*sequenceNumber = mSubMetric->getSequenceNumber() - length;
1302	if (length)
1303	{
1304	tmpData = (ULONG)RTMemAlloc(sizeof(tmpData)*length);
1305	mSubMetric->query(tmpData);
1306	if (mAggregate)
1307	{
1308	*count = 1;
1309	data = (ULONG)RTMemAlloc(sizeof(**data));
1310	**data = mAggregate->compute(tmpData, length);
1311	RTMemFree(tmpData);
1312	}
1313	else
1314	{
1315	*count = length;
1316	*data = tmpData;
1317	}
1318	}
1319	else
1320	{
1321	*count = 0;
1322	*data = 0;
1323	}
1324	}
1325
1326	ULONG AggregateAvg::compute(ULONG *data, ULONG length)
1327	{
1328	uint64_t tmp = 0;
1329	for (ULONG i = 0; i < length; ++i)
1330	tmp += data[i];
1331	return (ULONG)(tmp / length);
1332	}
1333
1334	const char * AggregateAvg::getName()
1335	{
1336	return "avg";
1337	}
1338
1339	ULONG AggregateMin::compute(ULONG *data, ULONG length)
1340	{
1341	ULONG tmp = *data;
1342	for (ULONG i = 0; i < length; ++i)
1343	if (data[i] < tmp)
1344	tmp = data[i];
1345	return tmp;
1346	}
1347
1348	const char * AggregateMin::getName()
1349	{
1350	return "min";
1351	}
1352
1353	ULONG AggregateMax::compute(ULONG *data, ULONG length)
1354	{
1355	ULONG tmp = *data;
1356	for (ULONG i = 0; i < length; ++i)
1357	if (data[i] > tmp)
1358	tmp = data[i];
1359	return tmp;
1360	}
1361
1362	const char * AggregateMax::getName()
1363	{
1364	return "max";
1365	}
1366
1367	Filter::Filter(const std::vector<com::Utf8Str> &metricNames,
1368	const std::vector<ComPtr<IUnknown> > &objects)
1369	{
1370	if (!objects.size())
1371	{
1372	if (metricNames.size())
1373	{
1374	for (size_t i = 0; i < metricNames.size(); ++i)
1375	processMetricList(metricNames[i], ComPtr<IUnknown>());
1376	}
1377	else
1378	processMetricList("*", ComPtr<IUnknown>());
1379	}
1380	else
1381	{
1382	for (size_t i = 0; i < objects.size(); ++i)
1383	switch (metricNames.size())
1384	{
1385	case 0:
1386	processMetricList("*", objects[i]);
1387	break;
1388	case 1:
1389	processMetricList(metricNames[0], objects[i]);
1390	break;
1391	default:
1392	processMetricList(metricNames[i], objects[i]);
1393	break;
1394	}
1395	}
1396	}
1397
1398	Filter::Filter(const com::Utf8Str &name, const ComPtr<IUnknown> &aObject)
1399	{
1400	processMetricList(name, aObject);
1401	}
1402
1403	void Filter::processMetricList(const com::Utf8Str &name, const ComPtr<IUnknown> object)
1404	{
1405	size_t startPos = 0;
1406
1407	for (size_t pos = name.find(",");
1408	pos != com::Utf8Str::npos;
1409	pos = name.find(",", startPos))
1410	{
1411	mElements.push_back(std::make_pair(object, RTCString(name.substr(startPos, pos - startPos).c_str())));
1412	startPos = pos + 1;
1413	}
1414	mElements.push_back(std::make_pair(object, RTCString(name.substr(startPos).c_str())));
1415	}
1416
1417	/**
1418	* The following method was borrowed from stamR3Match (VMM/STAM.cpp) and
1419	* modified to handle the special case of trailing colon in the pattern.
1420	*
1421	* @returns True if matches, false if not.
1422	* @param pszPat Pattern.
1423	* @param pszName Name to match against the pattern.
1424	* @param fSeenColon Seen colon (':').
1425	*/
1426	bool Filter::patternMatch(const char pszPat, const char pszName,
1427	bool fSeenColon)
1428	{
1429	/* ASSUMES ASCII */
1430	for (;;)
1431	{
1432	char chPat = *pszPat;
1433	switch (chPat)
1434	{
1435	default:
1436	if (*pszName != chPat)
1437	return false;
1438	break;
1439
1440	case '*':
1441	{
1442	while ((chPat = ++pszPat) == '' \|\| chPat == '?')
1443	/* nothing */;
1444
1445	/* Handle a special case, the mask terminating with a colon. */
1446	if (chPat == ':')
1447	{
1448	if (!fSeenColon && !pszPat[1])
1449	return !strchr(pszName, ':');
1450	fSeenColon = true;
1451	}
1452
1453	for (;;)
1454	{
1455	char ch = *pszName++;
1456	if ( ch == chPat
1457	&& ( !chPat
1458	\|\| patternMatch(pszPat + 1, pszName, fSeenColon)))
1459	return true;
1460	if (!ch)
1461	return false;
1462	}
1463	/* won't ever get here */
1464	break;
1465	}
1466
1467	case '?':
1468	if (!*pszName)
1469	return false;
1470	break;
1471
1472	/* Handle a special case, the mask terminating with a colon. */
1473	case ':':
1474	if (!fSeenColon && !pszPat[1])
1475	return !*pszName;
1476	if (*pszName != ':')
1477	return false;
1478	fSeenColon = true;
1479	break;
1480
1481	case '\0':
1482	return !*pszName;
1483	}
1484	pszName++;
1485	pszPat++;
1486	}
1487	/* not reached */
1488	}
1489
1490	bool Filter::match(const ComPtr<IUnknown> object, const RTCString &name) const
1491	{
1492	ElementList::const_iterator it;
1493
1494	//Log7(("Filter::match(%p, %s)\n", static_cast<const IUnknown*> (object), name.c_str()));
1495	for (it = mElements.begin(); it != mElements.end(); ++it)
1496	{
1497	//Log7(("...matching against(%p, %s)\n", static_cast<const IUnknown> ((it).first), (*it).second.c_str()));
1498	if ((it).first.isNull() \|\| (it).first == object)
1499	{
1500	// Objects match, compare names
1501	if (patternMatch((*it).second.c_str(), name.c_str()))
1502	{
1503	//LogFlowThisFunc(("...found!\n"));
1504	return true;
1505	}
1506	}
1507	}
1508	//Log7(("...no matches!\n"));
1509	return false;
1510	}
1511	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/src-server/Performance.cpp@ 105659

Download in other formats: