PerformanceImpl.cpp@ 24255

Last change on this file since 24255 was 22399, checked in by vboxsync, 15 years ago
Main: gcc-3.3 cruft
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.6 KB

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

Download in other formats: