Performance.h@ 11655

Last change on this file since 11655 was 11583, checked in by vboxsync, 16 years ago
PerfAPI: New attribute PerformanceMetric::description
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 11.6 KB

Line
1	/* $Id: Performance.h 11583 2008-08-22 19:05:15Z vboxsync $ */
2
3	/** @file
4	*
5	* VBox Performance Classes declaration.
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
25	#include <iprt/types.h>
26	#include <VBox/com/defs.h>
27	#include <VBox/com/ptr.h>
28	#include <list>
29	#include <string>
30
31	namespace pm
32	{
33	/* CPU load is measured in 1/1000 of per cent. */
34	const uint64_t PM_CPU_LOAD_MULTIPLIER = UINT64_C(100000);
35
36	/* Sub Metrics **********************************************************/
37	class CircularBuffer
38	{
39	public:
40	CircularBuffer() : mData(0), mLength(0), mEnd(0), mWrapped(false) {};
41	void init(ULONG length);
42	ULONG length();
43	void put(ULONG value);
44	void copyTo(ULONG *data);
45	private:
46	ULONG *mData;
47	ULONG mLength;
48	ULONG mEnd;
49	bool mWrapped;
50	};
51
52	class SubMetric : public CircularBuffer
53	{
54	public:
55	SubMetric(const char name, const char description)
56	: mName(name), mDescription(description) {};
57	void query(ULONG *data);
58	const char *getName() { return mName; };
59	const char *getDescription() { return mDescription; };
60	private:
61	const char *mName;
62	const char *mDescription;
63	};
64
65
66	/* Collector Hardware Abstraction Layer *********************************/
67	class CollectorHAL
68	{
69	public:
70	virtual int getHostCpuLoad(ULONG user, ULONG kernel, ULONG *idle);
71	virtual int getHostCpuMHz(ULONG *mhz);
72	virtual int getHostMemoryUsage(ULONG total, ULONG used, ULONG *available) = 0;
73	virtual int getProcessCpuLoad(RTPROCESS process, ULONG user, ULONG kernel);
74	virtual int getProcessMemoryUsage(RTPROCESS process, ULONG *used) = 0;
75
76	virtual int getRawHostCpuLoad(uint64_t user, uint64_t kernel, uint64_t *idle);
77	virtual int getRawProcessCpuLoad(RTPROCESS process, uint64_t user, uint64_t kernel, uint64_t *total);
78	};
79
80	/* Base Metrics *********************************************************/
81	class BaseMetric
82	{
83	public:
84	BaseMetric(CollectorHAL hal, const char name, ComPtr<IUnknown> object)
85	: mHAL(hal), mPeriod(0), mLength(0), mName(name), mObject(object), mLastSampleTaken(0), mEnabled(false) {};
86
87	virtual void init(ULONG period, ULONG length) = 0;
88	virtual void collect() = 0;
89	virtual const char *getUnit() = 0;
90	virtual ULONG getMinValue() = 0;
91	virtual ULONG getMaxValue() = 0;
92
93	void collectorBeat(uint64_t nowAt);
94
95	void enable() { mEnabled = true; };
96	void disable() { mEnabled = false; };
97
98	bool isEnabled() { return mEnabled; };
99	ULONG getPeriod() { return mPeriod; };
100	ULONG getLength() { return mLength; };
101	const char *getName() { return mName; };
102	ComPtr<IUnknown> getObject() { return mObject; };
103	bool associatedWith(ComPtr<IUnknown> object) { return mObject == object; };
104
105	protected:
106	CollectorHAL *mHAL;
107	ULONG mPeriod;
108	ULONG mLength;
109	const char *mName;
110	ComPtr<IUnknown> mObject;
111	uint64_t mLastSampleTaken;
112	bool mEnabled;
113	};
114
115	class HostCpuLoad : public BaseMetric
116	{
117	public:
118	HostCpuLoad(CollectorHAL hal, ComPtr<IUnknown> object, SubMetric user, SubMetric kernel, SubMetric idle)
119	: BaseMetric(hal, "CPU/Load", object), mUser(user), mKernel(kernel), mIdle(idle) {};
120	void init(ULONG period, ULONG length);
121
122	void collect();
123	const char *getUnit() { return "%"; };
124	ULONG getMinValue() { return 0; };
125	ULONG getMaxValue() { return PM_CPU_LOAD_MULTIPLIER; };
126
127	protected:
128	SubMetric *mUser;
129	SubMetric *mKernel;
130	SubMetric *mIdle;
131	};
132
133	class HostCpuLoadRaw : public HostCpuLoad
134	{
135	public:
136	HostCpuLoadRaw(CollectorHAL hal, ComPtr<IUnknown> object, SubMetric user, SubMetric kernel, SubMetric idle)
137	: HostCpuLoad(hal, object, user, kernel, idle), mUserPrev(0), mKernelPrev(0), mIdlePrev(0) {};
138
139	void collect();
140	private:
141	uint64_t mUserPrev;
142	uint64_t mKernelPrev;
143	uint64_t mIdlePrev;
144	};
145
146	class HostCpuMhz : public BaseMetric
147	{
148	public:
149	HostCpuMhz(CollectorHAL hal, ComPtr<IUnknown> object, SubMetric mhz)
150	: BaseMetric(hal, "CPU/MHz", object), mMHz(mhz) {};
151
152	void init(ULONG period, ULONG length);
153	void collect();
154	const char *getUnit() { return "MHz"; };
155	ULONG getMinValue() { return 0; };
156	ULONG getMaxValue() { return INT32_MAX; };
157	private:
158	SubMetric *mMHz;
159	};
160
161	class HostRamUsage : public BaseMetric
162	{
163	public:
164	HostRamUsage(CollectorHAL hal, ComPtr<IUnknown> object, SubMetric total, SubMetric used, SubMetric available)
165	: BaseMetric(hal, "RAM/Usage", object), mTotal(total), mUsed(used), mAvailable(available) {};
166
167	void init(ULONG period, ULONG length);
168	void collect();
169	const char *getUnit() { return "kB"; };
170	ULONG getMinValue() { return 0; };
171	ULONG getMaxValue() { return INT32_MAX; };
172	private:
173	SubMetric *mTotal;
174	SubMetric *mUsed;
175	SubMetric *mAvailable;
176	};
177
178	class MachineCpuLoad : public BaseMetric
179	{
180	public:
181	MachineCpuLoad(CollectorHAL hal, ComPtr<IUnknown> object, RTPROCESS process, SubMetric user, SubMetric *kernel)
182	: BaseMetric(hal, "CPU/Load", object), mProcess(process), mUser(user), mKernel(kernel) {};
183
184	void init(ULONG period, ULONG length);
185	void collect();
186	const char *getUnit() { return "%"; };
187	ULONG getMinValue() { return 0; };
188	ULONG getMaxValue() { return PM_CPU_LOAD_MULTIPLIER; };
189	protected:
190	RTPROCESS mProcess;
191	SubMetric *mUser;
192	SubMetric *mKernel;
193	};
194
195	class MachineCpuLoadRaw : public MachineCpuLoad
196	{
197	public:
198	MachineCpuLoadRaw(CollectorHAL hal, ComPtr<IUnknown> object, RTPROCESS process, SubMetric user, SubMetric *kernel)
199	: MachineCpuLoad(hal, object, process, user, kernel), mHostTotalPrev(0), mProcessUserPrev(0), mProcessKernelPrev(0) {};
200
201	void collect();
202	private:
203	uint64_t mHostTotalPrev;
204	uint64_t mProcessUserPrev;
205	uint64_t mProcessKernelPrev;
206	};
207
208	class MachineRamUsage : public BaseMetric
209	{
210	public:
211	MachineRamUsage(CollectorHAL hal, ComPtr<IUnknown> object, RTPROCESS process, SubMetric used)
212	: BaseMetric(hal, "RAM/Usage", object), mProcess(process), mUsed(used) {};
213
214	void init(ULONG period, ULONG length);
215	void collect();
216	const char *getUnit() { return "kB"; };
217	ULONG getMinValue() { return 0; };
218	ULONG getMaxValue() { return INT32_MAX; };
219	private:
220	RTPROCESS mProcess;
221	SubMetric *mUsed;
222	};
223
224	/* Aggregate Functions **************************************************/
225	class Aggregate
226	{
227	public:
228	virtual ULONG compute(ULONG *data, ULONG length) = 0;
229	virtual const char *getName() = 0;
230	};
231
232	class AggregateAvg : public Aggregate
233	{
234	public:
235	virtual ULONG compute(ULONG *data, ULONG length);
236	virtual const char *getName();
237	};
238
239	class AggregateMin : public Aggregate
240	{
241	public:
242	virtual ULONG compute(ULONG *data, ULONG length);
243	virtual const char *getName();
244	};
245
246	class AggregateMax : public Aggregate
247	{
248	public:
249	virtual ULONG compute(ULONG *data, ULONG length);
250	virtual const char *getName();
251	};
252
253	/* Metric Class *********************************************************/
254	class Metric
255	{
256	public:
257	Metric(BaseMetric baseMetric, SubMetric subMetric, Aggregate *aggregate) :
258	mName(subMetric->getName()), mBaseMetric(baseMetric), mSubMetric(subMetric), mAggregate(aggregate)
259	{
260	if (mAggregate)
261	{
262	mName += ":";
263	mName += mAggregate->getName();
264	}
265	}
266
267	~Metric()
268	{
269	delete mAggregate;
270	}
271	bool associatedWith(ComPtr<IUnknown> object) { return getObject() == object; };
272
273	const char *getName() { return mName.c_str(); };
274	ComPtr<IUnknown> getObject() { return mBaseMetric->getObject(); };
275	const char *getDescription()
276	{ return mAggregate ? "" : mSubMetric->getDescription(); };
277	const char *getUnit() { return mBaseMetric->getUnit(); };
278	ULONG getMinValue() { return mBaseMetric->getMinValue(); };
279	ULONG getMaxValue() { return mBaseMetric->getMaxValue(); };
280	ULONG getPeriod() { return mBaseMetric->getPeriod(); };
281	ULONG getLength()
282	{ return mAggregate ? 1 : mBaseMetric->getLength(); };
283	void query(ULONG *data, ULONG count);
284
285	private:
286	std::string mName;
287	BaseMetric *mBaseMetric;
288	SubMetric *mSubMetric;
289	Aggregate *mAggregate;
290	};
291
292	/* Metric Factories *****************************************************/
293	class MetricFactory
294	{
295	public:
296	MetricFactory() : mHAL(0) {};
297	~MetricFactory() { delete mHAL; };
298
299	virtual BaseMetric createHostCpuLoad(ComPtr<IUnknown> object, SubMetric user, SubMetric kernel, SubMetric idle);
300	virtual BaseMetric createHostCpuMHz(ComPtr<IUnknown> object, SubMetric mhz);
301	virtual BaseMetric createHostRamUsage(ComPtr<IUnknown> object, SubMetric total, SubMetric used, SubMetric available);
302	virtual BaseMetric createMachineCpuLoad(ComPtr<IUnknown> object, RTPROCESS process, SubMetric user, SubMetric *kernel);
303	virtual BaseMetric createMachineRamUsage(ComPtr<IUnknown> object, RTPROCESS process, SubMetric used);
304	protected:
305	CollectorHAL *mHAL;
306	};
307
308	class MetricFactorySolaris : public MetricFactory
309	{
310	public:
311	MetricFactorySolaris();
312	// Nothing else to do here (yet)
313	};
314
315	class MetricFactoryLinux : public MetricFactory
316	{
317	public:
318	MetricFactoryLinux();
319	// Nothing else to do here (yet)
320	};
321
322	class MetricFactoryWin : public MetricFactory
323	{
324	public:
325	MetricFactoryWin();
326	// Nothing else to do here (yet)
327	};
328
329	class MetricFactoryOS2 : public MetricFactory
330	{
331	public:
332	MetricFactoryOS2();
333	// Nothing else to do here (yet)
334	};
335
336	class MetricFactoryDarwin : public MetricFactory
337	{
338	public:
339	MetricFactoryDarwin();
340	// Nothing else to do here (yet)
341	};
342
343	class Filter
344	{
345	public:
346	Filter(ComSafeArrayIn(INPTR BSTR, metricNames),
347	ComSafeArrayIn(IUnknown * , objects));
348	static bool patternMatch(const char pszPat, const char pszName);
349	bool match(const ComPtr<IUnknown> object, const std::string &name) const;
350	private:
351	typedef std::pair<const ComPtr<IUnknown>, const std::string> FilterElement;
352	typedef std::list<FilterElement> ElementList;
353
354	ElementList mElements;
355
356	void processMetricList(const std::string &name, const ComPtr<IUnknown> object);
357	};
358	}
359

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

source: vbox/trunk/src/VBox/Main/include/Performance.h@ 11655

Download in other formats: