PerformanceImpl.cpp@ 34927

Last change on this file since 34927 was 30764, checked in by vboxsync, 14 years ago
back out r63543, r63544 until windows build problems can be solved properly
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 23.4 KB

Line
1	/* $Id: PerformanceImpl.cpp 30764 2010-07-09 14:12:12Z vboxsync $ */
2
3	/** @file
4	*
5	* VBox Performance API COM Classes implementation
6	*/
7
8	/*
9	* Copyright (C) 2008-2010 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	#include "PerformanceImpl.h"
21
22	#include "AutoCaller.h"
23	#include "Logging.h"
24
25	#include <iprt/process.h>
26
27	#include <VBox/err.h>
28	#include <VBox/settings.h>
29
30	#include <vector>
31	#include <algorithm>
32	#include <functional>
33
34	#include "Performance.h"
35
36	static const char *g_papcszMetricNames[] =
37	{
38	"CPU/Load/User",
39	"CPU/Load/User:avg",
40	"CPU/Load/User:min",
41	"CPU/Load/User:max",
42	"CPU/Load/Kernel",
43	"CPU/Load/Kernel:avg",
44	"CPU/Load/Kernel:min",
45	"CPU/Load/Kernel:max",
46	"CPU/Load/Idle",
47	"CPU/Load/Idle:avg",
48	"CPU/Load/Idle:min",
49	"CPU/Load/Idle:max",
50	"CPU/MHz",
51	"CPU/MHz:avg",
52	"CPU/MHz:min",
53	"CPU/MHz:max",
54	"RAM/Usage/Total",
55	"RAM/Usage/Total:avg",
56	"RAM/Usage/Total:min",
57	"RAM/Usage/Total:max",
58	"RAM/Usage/Used",
59	"RAM/Usage/Used:avg",
60	"RAM/Usage/Used:min",
61	"RAM/Usage/Used:max",
62	"RAM/Usage/Free",
63	"RAM/Usage/Free:avg",
64	"RAM/Usage/Free:min",
65	"RAM/Usage/Free:max",
66	"RAM/VMM/Used",
67	"RAM/VMM/Used:avg",
68	"RAM/VMM/Used:min",
69	"RAM/VMM/Used:max",
70	"RAM/VMM/Free",
71	"RAM/VMM/Free:avg",
72	"RAM/VMM/Free:min",
73	"RAM/VMM/Free:max",
74	"RAM/VMM/Ballooned",
75	"RAM/VMM/Ballooned:avg",
76	"RAM/VMM/Ballooned:min",
77	"RAM/VMM/Ballooned:max",
78	"RAM/VMM/Shared",
79	"RAM/VMM/Shared:avg",
80	"RAM/VMM/Shared:min",
81	"RAM/VMM/Shared:max",
82	"Guest/CPU/Load/User",
83	"Guest/CPU/Load/User:avg",
84	"Guest/CPU/Load/User:min",
85	"Guest/CPU/Load/User:max",
86	"Guest/CPU/Load/Kernel",
87	"Guest/CPU/Load/Kernel:avg",
88	"Guest/CPU/Load/Kernel:min",
89	"Guest/CPU/Load/Kernel:max",
90	"Guest/CPU/Load/Idle",
91	"Guest/CPU/Load/Idle:avg",
92	"Guest/CPU/Load/Idle:min",
93	"Guest/CPU/Load/Idle:max",
94	"Guest/RAM/Usage/Total",
95	"Guest/RAM/Usage/Total:avg",
96	"Guest/RAM/Usage/Total:min",
97	"Guest/RAM/Usage/Total:max",
98	"Guest/RAM/Usage/Free",
99	"Guest/RAM/Usage/Free:avg",
100	"Guest/RAM/Usage/Free:min",
101	"Guest/RAM/Usage/Free:max",
102	"Guest/RAM/Usage/Balloon",
103	"Guest/RAM/Usage/Balloon:avg",
104	"Guest/RAM/Usage/Balloon:min",
105	"Guest/RAM/Usage/Balloon:max",
106	"Guest/RAM/Usage/Shared",
107	"Guest/RAM/Usage/Shared:avg",
108	"Guest/RAM/Usage/Shared:min",
109	"Guest/RAM/Usage/Shared:max",
110	"Guest/RAM/Usage/Cache",
111	"Guest/RAM/Usage/Cache:avg",
112	"Guest/RAM/Usage/Cache:min",
113	"Guest/RAM/Usage/Cache:max",
114	"Guest/Pagefile/Usage/Total",
115	"Guest/Pagefile/Usage/Total:avg",
116	"Guest/Pagefile/Usage/Total:min",
117	"Guest/Pagefile/Usage/Total:max",
118	};
119
120	////////////////////////////////////////////////////////////////////////////////
121	// PerformanceCollector class
122	////////////////////////////////////////////////////////////////////////////////
123
124	// constructor / destructor
125	////////////////////////////////////////////////////////////////////////////////
126
127	PerformanceCollector::PerformanceCollector() : mMagic(0) {}
128
129	PerformanceCollector::~PerformanceCollector() {}
130
131	HRESULT PerformanceCollector::FinalConstruct()
132	{
133	LogFlowThisFunc(("\n"));
134
135	return S_OK;
136	}
137
138	void PerformanceCollector::FinalRelease()
139	{
140	LogFlowThisFunc(("\n"));
141	}
142
143	// public initializer/uninitializer for internal purposes only
144	////////////////////////////////////////////////////////////////////////////////
145
146	/**
147	* Initializes the PerformanceCollector object.
148	*/
149	HRESULT PerformanceCollector::init()
150	{
151	/* Enclose the state transition NotReady->InInit->Ready */
152	AutoInitSpan autoInitSpan(this);
153	AssertReturn(autoInitSpan.isOk(), E_FAIL);
154
155	LogFlowThisFuncEnter();
156
157	HRESULT rc = S_OK;
158
159	m.hal = pm::createHAL();
160
161	/* Let the sampler know it gets a valid collector. */
162	mMagic = MAGIC;
163
164	/* Start resource usage sampler */
165	int vrc = RTTimerLRCreate (&m.sampler, VBOX_USAGE_SAMPLER_MIN_INTERVAL,
166	&PerformanceCollector::staticSamplerCallback, this);
167	AssertMsgRC (vrc, ("Failed to create resource usage "
168	"sampling timer(%Rra)\n", vrc));
169	if (RT_FAILURE(vrc))
170	rc = E_FAIL;
171
172	if (SUCCEEDED(rc))
173	autoInitSpan.setSucceeded();
174
175	LogFlowThisFuncLeave();
176
177	return rc;
178	}
179
180	/**
181	* Uninitializes the PerformanceCollector object.
182	*
183	* Called either from FinalRelease() or by the parent when it gets destroyed.
184	*/
185	void PerformanceCollector::uninit()
186	{
187	LogFlowThisFuncEnter();
188
189	/* Enclose the state transition Ready->InUninit->NotReady */
190	AutoUninitSpan autoUninitSpan(this);
191	if (autoUninitSpan.uninitDone())
192	{
193	LogFlowThisFunc(("Already uninitialized.\n"));
194	LogFlowThisFuncLeave();
195	return;
196	}
197
198	mMagic = 0;
199
200	/* Destroy resource usage sampler */
201	int vrc = RTTimerLRDestroy (m.sampler);
202	AssertMsgRC (vrc, ("Failed to destroy resource usage "
203	"sampling timer (%Rra)\n", vrc));
204	m.sampler = NULL;
205
206	//delete m.factory;
207	//m.factory = NULL;
208
209	delete m.hal;
210	m.hal = NULL;
211
212	LogFlowThisFuncLeave();
213	}
214
215	// IPerformanceCollector properties
216	////////////////////////////////////////////////////////////////////////////////
217
218	STDMETHODIMP PerformanceCollector::COMGETTER(MetricNames)(ComSafeArrayOut(BSTR, theMetricNames))
219	{
220	if (ComSafeArrayOutIsNull(theMetricNames))
221	return E_POINTER;
222
223	AutoCaller autoCaller(this);
224	if (FAILED(autoCaller.rc())) return autoCaller.rc();
225
226	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
227
228	com::SafeArray<BSTR> metricNames(RT_ELEMENTS(g_papcszMetricNames));
229	for (size_t i = 0; i < RT_ELEMENTS(g_papcszMetricNames); i++)
230	{
231	Bstr tmp(g_papcszMetricNames[i]); /* gcc-3.3 cruft */
232	tmp.cloneTo(&metricNames[i]);
233	}
234	//gMetricNames.detachTo(ComSafeArrayOutArg(theMetricNames));
235	metricNames.detachTo(ComSafeArrayOutArg(theMetricNames));
236
237	return S_OK;
238	}
239
240	// IPerformanceCollector methods
241	////////////////////////////////////////////////////////////////////////////////
242
243	HRESULT PerformanceCollector::toIPerformanceMetric(pm::Metric src, IPerformanceMetric *dst)
244	{
245	ComObjPtr<PerformanceMetric> metric;
246	HRESULT rc = metric.createObject();
247	if (SUCCEEDED(rc))
248	rc = metric->init (src);
249	AssertComRCReturnRC(rc);
250	metric.queryInterfaceTo(dst);
251	return rc;
252	}
253
254	HRESULT PerformanceCollector::toIPerformanceMetric(pm::BaseMetric src, IPerformanceMetric *dst)
255	{
256	ComObjPtr<PerformanceMetric> metric;
257	HRESULT rc = metric.createObject();
258	if (SUCCEEDED(rc))
259	rc = metric->init (src);
260	AssertComRCReturnRC(rc);
261	metric.queryInterfaceTo(dst);
262	return rc;
263	}
264
265	STDMETHODIMP PerformanceCollector::GetMetrics(ComSafeArrayIn(IN_BSTR, metricNames),
266	ComSafeArrayIn(IUnknown *, objects),
267	ComSafeArrayOut(IPerformanceMetric *, outMetrics))
268	{
269	LogFlowThisFuncEnter();
270	//LogFlowThisFunc(("mState=%d, mType=%d\n", mState, mType));
271
272	HRESULT rc = S_OK;
273
274	AutoCaller autoCaller(this);
275	if (FAILED(autoCaller.rc())) return autoCaller.rc();
276
277	pm::Filter filter (ComSafeArrayInArg (metricNames),
278	ComSafeArrayInArg (objects));
279
280	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
281
282	MetricList filteredMetrics;
283	MetricList::iterator it;
284	for (it = m.metrics.begin(); it != m.metrics.end(); ++it)
285	if (filter.match ((it)->getObject(), (it)->getName()))
286	filteredMetrics.push_back (*it);
287
288	com::SafeIfaceArray<IPerformanceMetric> retMetrics (filteredMetrics.size());
289	int i = 0;
290	for (it = filteredMetrics.begin(); it != filteredMetrics.end(); ++it)
291	{
292	ComObjPtr<PerformanceMetric> metric;
293	rc = metric.createObject();
294	if (SUCCEEDED(rc))
295	rc = metric->init (*it);
296	AssertComRCReturnRC(rc);
297	LogFlow (("PerformanceCollector::GetMetrics() store a metric at "
298	"retMetrics[%d]...\n", i));
299	metric.queryInterfaceTo(&retMetrics[i++]);
300	}
301	retMetrics.detachTo(ComSafeArrayOutArg(outMetrics));
302	LogFlowThisFuncLeave();
303	return rc;
304	}
305
306	STDMETHODIMP PerformanceCollector::SetupMetrics(ComSafeArrayIn(IN_BSTR, metricNames),
307	ComSafeArrayIn(IUnknown *, objects),
308	ULONG aPeriod,
309	ULONG aCount,
310	ComSafeArrayOut(IPerformanceMetric *, outMetrics))
311	{
312	AutoCaller autoCaller(this);
313	if (FAILED(autoCaller.rc())) return autoCaller.rc();
314
315	pm::Filter filter(ComSafeArrayInArg (metricNames),
316	ComSafeArrayInArg (objects));
317
318	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
319
320	HRESULT rc = S_OK;
321	BaseMetricList filteredMetrics;
322	BaseMetricList::iterator it;
323	for (it = m.baseMetrics.begin(); it != m.baseMetrics.end(); ++it)
324	if (filter.match((it)->getObject(), (it)->getName()))
325	{
326	LogFlow (("PerformanceCollector::SetupMetrics() setting period to %u,"
327	" count to %u for %s\n", aPeriod, aCount, (*it)->getName()));
328	(*it)->init(aPeriod, aCount);
329	if (aPeriod == 0 \|\| aCount == 0)
330	{
331	LogFlow (("PerformanceCollector::SetupMetrics() disabling %s\n",
332	(*it)->getName()));
333	(*it)->disable();
334	}
335	else
336	{
337	LogFlow (("PerformanceCollector::SetupMetrics() enabling %s\n",
338	(*it)->getName()));
339	(*it)->enable();
340	}
341	filteredMetrics.push_back(*it);
342	}
343
344	com::SafeIfaceArray<IPerformanceMetric> retMetrics(filteredMetrics.size());
345	int i = 0;
346	for (it = filteredMetrics.begin();
347	it != filteredMetrics.end() && SUCCEEDED(rc); ++it)
348	rc = toIPerformanceMetric(*it, &retMetrics[i++]);
349	retMetrics.detachTo(ComSafeArrayOutArg(outMetrics));
350
351	LogFlowThisFuncLeave();
352	return rc;
353	}
354
355	STDMETHODIMP PerformanceCollector::EnableMetrics(ComSafeArrayIn(IN_BSTR, metricNames),
356	ComSafeArrayIn(IUnknown *, objects),
357	ComSafeArrayOut(IPerformanceMetric *, outMetrics))
358	{
359	AutoCaller autoCaller(this);
360	if (FAILED(autoCaller.rc())) return autoCaller.rc();
361
362	pm::Filter filter(ComSafeArrayInArg(metricNames),
363	ComSafeArrayInArg(objects));
364
365	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); /* Write lock is not needed atm since we are */
366	/* fiddling with enable bit only, but we */
367	/* care for those who come next :-). */
368
369	HRESULT rc = S_OK;
370	BaseMetricList filteredMetrics;
371	BaseMetricList::iterator it;
372	for (it = m.baseMetrics.begin(); it != m.baseMetrics.end(); ++it)
373	if (filter.match((it)->getObject(), (it)->getName()))
374	{
375	(*it)->enable();
376	filteredMetrics.push_back(*it);
377	}
378
379	com::SafeIfaceArray<IPerformanceMetric> retMetrics(filteredMetrics.size());
380	int i = 0;
381	for (it = filteredMetrics.begin();
382	it != filteredMetrics.end() && SUCCEEDED(rc); ++it)
383	rc = toIPerformanceMetric(*it, &retMetrics[i++]);
384	retMetrics.detachTo(ComSafeArrayOutArg(outMetrics));
385
386	LogFlowThisFuncLeave();
387	return rc;
388	}
389
390	STDMETHODIMP PerformanceCollector::DisableMetrics(ComSafeArrayIn(IN_BSTR, metricNames),
391	ComSafeArrayIn(IUnknown *, objects),
392	ComSafeArrayOut(IPerformanceMetric *, outMetrics))
393	{
394	AutoCaller autoCaller(this);
395	if (FAILED(autoCaller.rc())) return autoCaller.rc();
396
397	pm::Filter filter(ComSafeArrayInArg(metricNames),
398	ComSafeArrayInArg(objects));
399
400	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); /* Write lock is not needed atm since we are */
401	/* fiddling with enable bit only, but we */
402	/* care for those who come next :-). */
403
404	HRESULT rc = S_OK;
405	BaseMetricList filteredMetrics;
406	BaseMetricList::iterator it;
407	for (it = m.baseMetrics.begin(); it != m.baseMetrics.end(); ++it)
408	if (filter.match((it)->getObject(), (it)->getName()))
409	{
410	(*it)->disable();
411	filteredMetrics.push_back(*it);
412	}
413
414	com::SafeIfaceArray<IPerformanceMetric> retMetrics(filteredMetrics.size());
415	int i = 0;
416	for (it = filteredMetrics.begin();
417	it != filteredMetrics.end() && SUCCEEDED(rc); ++it)
418	rc = toIPerformanceMetric(*it, &retMetrics[i++]);
419	retMetrics.detachTo(ComSafeArrayOutArg(outMetrics));
420
421	LogFlowThisFuncLeave();
422	return rc;
423	}
424
425	STDMETHODIMP PerformanceCollector::QueryMetricsData(ComSafeArrayIn (IN_BSTR, metricNames),
426	ComSafeArrayIn (IUnknown *, objects),
427	ComSafeArrayOut(BSTR, outMetricNames),
428	ComSafeArrayOut(IUnknown *, outObjects),
429	ComSafeArrayOut(BSTR, outUnits),
430	ComSafeArrayOut(ULONG, outScales),
431	ComSafeArrayOut(ULONG, outSequenceNumbers),
432	ComSafeArrayOut(ULONG, outDataIndices),
433	ComSafeArrayOut(ULONG, outDataLengths),
434	ComSafeArrayOut(LONG, outData))
435	{
436	AutoCaller autoCaller(this);
437	if (FAILED(autoCaller.rc())) return autoCaller.rc();
438
439	pm::Filter filter(ComSafeArrayInArg(metricNames),
440	ComSafeArrayInArg(objects));
441
442	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
443
444	/* Let's compute the size of the resulting flat array */
445	size_t flatSize = 0;
446	MetricList filteredMetrics;
447	MetricList::iterator it;
448	for (it = m.metrics.begin(); it != m.metrics.end(); ++it)
449	if (filter.match ((it)->getObject(), (it)->getName()))
450	{
451	filteredMetrics.push_back (*it);
452	flatSize += (*it)->getLength();
453	}
454
455	int i = 0;
456	size_t flatIndex = 0;
457	size_t numberOfMetrics = filteredMetrics.size();
458	com::SafeArray<BSTR> retNames(numberOfMetrics);
459	com::SafeIfaceArray<IUnknown> retObjects(numberOfMetrics);
460	com::SafeArray<BSTR> retUnits(numberOfMetrics);
461	com::SafeArray<ULONG> retScales(numberOfMetrics);
462	com::SafeArray<ULONG> retSequenceNumbers(numberOfMetrics);
463	com::SafeArray<ULONG> retIndices(numberOfMetrics);
464	com::SafeArray<ULONG> retLengths(numberOfMetrics);
465	com::SafeArray<LONG> retData(flatSize);
466
467	for (it = filteredMetrics.begin(); it != filteredMetrics.end(); ++it, ++i)
468	{
469	ULONG *values, length, sequenceNumber;
470	/* @todo We may want to revise the query method to get rid of excessive alloc/memcpy calls. */
471	(*it)->query(&values, &length, &sequenceNumber);
472	LogFlow (("PerformanceCollector::QueryMetricsData() querying metric %s "
473	"returned %d values.\n", (*it)->getName(), length));
474	memcpy(retData.raw() + flatIndex, values, length * sizeof(*values));
475	Bstr tmp((*it)->getName());
476	tmp.detachTo(&retNames[i]);
477	(*it)->getObject().queryInterfaceTo(&retObjects[i]);
478	tmp = (*it)->getUnit();
479	tmp.detachTo(&retUnits[i]);
480	retScales[i] = (*it)->getScale();
481	retSequenceNumbers[i] = sequenceNumber;
482	retLengths[i] = length;
483	retIndices[i] = (ULONG)flatIndex;
484	flatIndex += length;
485	}
486
487	retNames.detachTo(ComSafeArrayOutArg(outMetricNames));
488	retObjects.detachTo(ComSafeArrayOutArg(outObjects));
489	retUnits.detachTo(ComSafeArrayOutArg(outUnits));
490	retScales.detachTo(ComSafeArrayOutArg(outScales));
491	retSequenceNumbers.detachTo(ComSafeArrayOutArg(outSequenceNumbers));
492	retIndices.detachTo(ComSafeArrayOutArg(outDataIndices));
493	retLengths.detachTo(ComSafeArrayOutArg(outDataLengths));
494	retData.detachTo(ComSafeArrayOutArg(outData));
495	return S_OK;
496	}
497
498	// public methods for internal purposes
499	///////////////////////////////////////////////////////////////////////////////
500
501	void PerformanceCollector::registerBaseMetric(pm::BaseMetric *baseMetric)
502	{
503	//LogFlowThisFuncEnter();
504	AutoCaller autoCaller(this);
505	if (!SUCCEEDED(autoCaller.rc())) return;
506
507	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
508	LogAleksey(("{%p} " LOG_FN_FMT ": obj=%p name=%s\n", this, __PRETTY_FUNCTION__, (void *)baseMetric->getObject(), baseMetric->getName()));
509	m.baseMetrics.push_back (baseMetric);
510	//LogFlowThisFuncLeave();
511	}
512
513	void PerformanceCollector::registerMetric(pm::Metric *metric)
514	{
515	//LogFlowThisFuncEnter();
516	AutoCaller autoCaller(this);
517	if (!SUCCEEDED(autoCaller.rc())) return;
518
519	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
520	LogAleksey(("{%p} " LOG_FN_FMT ": obj=%p name=%s\n", this, __PRETTY_FUNCTION__, (void *)metric->getObject(), metric->getName()));
521	m.metrics.push_back (metric);
522	//LogFlowThisFuncLeave();
523	}
524
525	void PerformanceCollector::unregisterBaseMetricsFor(const ComPtr<IUnknown> &aObject)
526	{
527	//LogFlowThisFuncEnter();
528	AutoCaller autoCaller(this);
529	if (!SUCCEEDED(autoCaller.rc())) return;
530
531	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
532	LogAleksey(("{%p} " LOG_FN_FMT ": before remove_if: m.baseMetrics.size()=%d\n", this, __PRETTY_FUNCTION__, m.baseMetrics.size()));
533	BaseMetricList::iterator it;
534	for (it = m.baseMetrics.begin(); it != m.baseMetrics.end();)
535	if ((*it)->associatedWith(aObject))
536	{
537	delete *it;
538	it = m.baseMetrics.erase(it);
539	}
540	else
541	++it;
542	LogAleksey(("{%p} " LOG_FN_FMT ": after remove_if: m.baseMetrics.size()=%d\n", this, __PRETTY_FUNCTION__, m.baseMetrics.size()));
543	//LogFlowThisFuncLeave();
544	}
545
546	void PerformanceCollector::unregisterMetricsFor(const ComPtr<IUnknown> &aObject)
547	{
548	//LogFlowThisFuncEnter();
549	AutoCaller autoCaller(this);
550	if (!SUCCEEDED(autoCaller.rc())) return;
551
552	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
553	LogAleksey(("{%p} " LOG_FN_FMT ": obj=%p\n", this, __PRETTY_FUNCTION__, (void *)aObject));
554	MetricList::iterator it;
555	for (it = m.metrics.begin(); it != m.metrics.end();)
556	if ((*it)->associatedWith(aObject))
557	{
558	delete *it;
559	it = m.metrics.erase(it);
560	}
561	else
562	++it;
563	//LogFlowThisFuncLeave();
564	}
565
566	void PerformanceCollector::suspendSampling()
567	{
568	AutoCaller autoCaller(this);
569	if (!SUCCEEDED(autoCaller.rc())) return;
570
571	int rc = RTTimerLRStop(m.sampler);
572	AssertRC(rc);
573	}
574
575	void PerformanceCollector::resumeSampling()
576	{
577	AutoCaller autoCaller(this);
578	if (!SUCCEEDED(autoCaller.rc())) return;
579
580	int rc = RTTimerLRStart(m.sampler, 0);
581	AssertRC(rc);
582	}
583
584
585	// private methods
586	///////////////////////////////////////////////////////////////////////////////
587
588	/* static */
589	void PerformanceCollector::staticSamplerCallback(RTTIMERLR hTimerLR, void *pvUser,
590	uint64_t iTick)
591	{
592	AssertReturnVoid (pvUser != NULL);
593	PerformanceCollector collector = static_cast <PerformanceCollector > (pvUser);
594	Assert(collector->mMagic == MAGIC);
595	if (collector->mMagic == MAGIC)
596	collector->samplerCallback(iTick);
597
598	NOREF (hTimerLR);
599	}
600
601	void PerformanceCollector::samplerCallback(uint64_t iTick)
602	{
603	Log4(("{%p} " LOG_FN_FMT ": ENTER\n", this, __PRETTY_FUNCTION__));
604	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
605
606	pm::CollectorHints hints;
607	uint64_t timestamp = RTTimeMilliTS();
608	BaseMetricList toBeCollected;
609	BaseMetricList::iterator it;
610	/* Compose the list of metrics being collected at this moment */
611	for (it = m.baseMetrics.begin(); it != m.baseMetrics.end(); it++)
612	if ((*it)->collectorBeat(timestamp))
613	{
614	(*it)->preCollect(hints, iTick);
615	toBeCollected.push_back(*it);
616	}
617
618	if (toBeCollected.size() == 0)
619	return;
620
621	/* Let know the platform specific code what is being collected */
622	m.hal->preCollect(hints, iTick);
623
624	/* Finally, collect the data */
625	std::for_each (toBeCollected.begin(), toBeCollected.end(),
626	std::mem_fun (&pm::BaseMetric::collect));
627	Log4(("{%p} " LOG_FN_FMT ": LEAVE\n", this, __PRETTY_FUNCTION__));
628	}
629
630	////////////////////////////////////////////////////////////////////////////////
631	// PerformanceMetric class
632	////////////////////////////////////////////////////////////////////////////////
633
634	// constructor / destructor
635	////////////////////////////////////////////////////////////////////////////////
636
637	PerformanceMetric::PerformanceMetric()
638	{
639	}
640
641	PerformanceMetric::~PerformanceMetric()
642	{
643	}
644
645	HRESULT PerformanceMetric::FinalConstruct()
646	{
647	LogFlowThisFunc(("\n"));
648
649	return S_OK;
650	}
651
652	void PerformanceMetric::FinalRelease()
653	{
654	LogFlowThisFunc(("\n"));
655
656	uninit ();
657	}
658
659	// public initializer/uninitializer for internal purposes only
660	////////////////////////////////////////////////////////////////////////////////
661
662	HRESULT PerformanceMetric::init(pm::Metric *aMetric)
663	{
664	m.name = aMetric->getName();
665	m.object = aMetric->getObject();
666	m.description = aMetric->getDescription();
667	m.period = aMetric->getPeriod();
668	m.count = aMetric->getLength();
669	m.unit = aMetric->getUnit();
670	m.min = aMetric->getMinValue();
671	m.max = aMetric->getMaxValue();
672	return S_OK;
673	}
674
675	HRESULT PerformanceMetric::init(pm::BaseMetric *aMetric)
676	{
677	m.name = aMetric->getName();
678	m.object = aMetric->getObject();
679	m.description = "";
680	m.period = aMetric->getPeriod();
681	m.count = aMetric->getLength();
682	m.unit = aMetric->getUnit();
683	m.min = aMetric->getMinValue();
684	m.max = aMetric->getMaxValue();
685	return S_OK;
686	}
687
688	void PerformanceMetric::uninit()
689	{
690	}
691
692	STDMETHODIMP PerformanceMetric::COMGETTER(MetricName)(BSTR *aMetricName)
693	{
694	/// @todo (r=dmik) why do all these getters not do AutoCaller and
695	/// AutoReadLock? Is the underlying metric a constant object?
696
697	m.name.cloneTo(aMetricName);
698	return S_OK;
699	}
700
701	STDMETHODIMP PerformanceMetric::COMGETTER(Object)(IUnknown **anObject)
702	{
703	m.object.queryInterfaceTo(anObject);
704	return S_OK;
705	}
706
707	STDMETHODIMP PerformanceMetric::COMGETTER(Description)(BSTR *aDescription)
708	{
709	m.description.cloneTo(aDescription);
710	return S_OK;
711	}
712
713	STDMETHODIMP PerformanceMetric::COMGETTER(Period)(ULONG *aPeriod)
714	{
715	*aPeriod = m.period;
716	return S_OK;
717	}
718
719	STDMETHODIMP PerformanceMetric::COMGETTER(Count)(ULONG *aCount)
720	{
721	*aCount = m.count;
722	return S_OK;
723	}
724
725	STDMETHODIMP PerformanceMetric::COMGETTER(Unit)(BSTR *aUnit)
726	{
727	m.unit.cloneTo(aUnit);
728	return S_OK;
729	}
730
731	STDMETHODIMP PerformanceMetric::COMGETTER(MinimumValue)(LONG *aMinValue)
732	{
733	*aMinValue = m.min;
734	return S_OK;
735	}
736
737	STDMETHODIMP PerformanceMetric::COMGETTER(MaximumValue)(LONG *aMaxValue)
738	{
739	*aMaxValue = m.max;
740	return S_OK;
741	}
742	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/PerformanceImpl.cpp@ 34927

Download in other formats: