![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to winperf.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / h / strict|
Return to winperf.h CVS log | Up to [WindowsNT SDKs] / mstools / h / strict |
1.1 root 1: #ifndef _WINPERF_INCLUDED_
2: #define _WINPERF_INCLUDED_
3: //
4: // winperf.h - Header file for the Performance Monitor data
5: //
6: //
7: //
8: //
9:
10:
11: //
12: // This file contains the definitions of the data structures returned
13: // by the Configuration Registry in response to a request for
14: // performance data. This file is used by both the Configuration
15: // Registry and the Performance Monitor to define their interface.
16: // The complete interface is described here, except for the name
17: // of the node to query in the registry. It is
18: //
19: // HKEY_PERFORMANCE_DATA.
20: //
21: // By querying that node with a subkey of "GLOBAL" the caller will
22: // retrieve the structures described here.
23: //
24: // There is no need to RegOpenKey the reserved handle HKEY_PERFORMANCE_DATA,
25: // but the caller should RegCloseKey the handle so that network transports
26: // and drivers can be removed or installed (which cannot happen while
27: // they are open for monitoring.)
28: //
29: //
30:
31:
32: /*****************************************************************************\
33:
34: The basic layout of the data block returned is a header followed by a
35: data area for each type of object under measurement. Typical object
36: types are processor, disk, and memory. The system being observed
37: defines what objects are under measurement. Naturally, different
38: systems may measure different types of objects.
39:
40:
41: +-----------------------------------------+
42: | |
43: | PERF_DATA_BLOCK |
44: | - - - - - - - - - - - - - - - - - - - - |
45: | NumObjectTypes |
46: | - - - - - - - - - - - - - - - - - - - - |
47: |-----------------------------------------|
48: | |
49: | |
50: | PERF_OBJECT_TYPE 0 |
51: | |
52: | |
53: |-----------------------------------------|
54: | |
55: | |
56: | PERF_OBJECT_TYPE 1 |
57: | |
58: | |
59: |-----------------------------------------|
60: | |
61: | |
62: | PERF_OBJECT_TYPE 2 |
63: | |
64: | |
65: |-----------------------------------------|
66: | . |
67: | . |
68: | . |
69: |-----------------------------------------|
70: | |
71: | |
72: | PERF_OBJECT_TYPE NumObjectTypes-1 |
73: | |
74: | |
75: +-----------------------------------------+
76: Note that from one call to the next, there may be different object types
77: defined, meaning that PERF_DATA_BLOCK.NumObjectTypes will vary. As will
78: become clear shortly, the size of the area for each object type may also
79: vary. You cannot count on the locations of the object type areas from
80: one call to the system to the next. To help to accomodate this, offsets
81: have been included to help naviagte the structure. Such offsets are
82: !always! relative to the !beginning! of the structure which contains them.
83:
84: +-----------------------------------------+
85: | PERF_DATA_BLOCK |
86: | - - - - - - - - - - - - - - - - - - - - |
87: | TotalByteLength *--------*
88: | - - - - - - - - - - - - - - - - - - - - | |
89: | HeaderLength *----* |
90: | - - - - - - - - - - - - - - - - - - - - | | |
91: | | | |
92: | | | |
93: |-----------------------------------------| | |
94: | PERF_OBJECT_TYPE 0 |<---* |
95: | - - - - - - - - - - - - - - - - - - - - | |
96: | TotalByteLength *----* |
97: | - - - - - - - - - - - - - - - - - - - - | | |
98: | | | |
99: | | | |
100: |-----------------------------------------| | |
101: | PERF_OBJECT_TYPE 1 |<---* |
102: | - - - - - - - - - - - - - - - - - - - - | |
103: | TotalByteLength *----* |
104: | - - - - - - - - - - - - - - - - - - - - | | |
105: | | | |
106: | | | |
107: | | | |
108: | | | |
109: |-----------------------------------------| | |
110: | PERF_OBJECT_TYPE 2 |<---* |
111: | - - - - - - - - - - - - - - - - - - - - | |
112: | TotalByteLength *----* |
113: | - - - - - - - - - - - - - - - - - - - - | | |
114: | | | |
115: | | | |
116: |-----------------------------------------| | |
117: | . |<---* |
118: | . | .
119: | . |. . . .
120: |-----------------------------------------| . .
121: | PERF_OBJECT_TYPE NumObjectTypes-1 |<---* |
122: | | |
123: | | |
124: | | |
125: | | |
126: +-----------------------------------------+<-------*
127:
128: Each PERF_OBJECT_TYPE definition is followed by the definitions of all the
129: counters which are defined for that object. Typical counters for the
130: object of type processor are Processor Time, Interrupts, and Page Faults.
131:
132: +-----------------------------------------+
133: | PERF_OBJECT_TYPE i |
134: | |
135: | - - - - - - - - - - - - - - - - - - - - |
136: | DefinitionLength *----------*
137: | - - - - - - - - - - - - - - - - - - - - | |
138: | HeaderLength *-----* |
139: | - - - - - - - - - - - - - - - - - - - - | | |
140: | NumCounters | | |
141: | - - - - - - - - - - - - - - - - - - - - | | |
142: | | | |
143: | | | |
144: |-----------------------------------------| | |
145: | PERF_COUNTER_DEFINITION 0 |<----* |
146: | | |
147: | | |
148: |-----------------------------------------| |
149: | PERF_COUNTER_DEFINITION 1 | |
150: | | |
151: | | |
152: |-----------------------------------------| |
153: | PERF_COUNTER_DEFINITION 2 | |
154: | | |
155: | | |
156: |-----------------------------------------| |
157: | . | |
158: | . | |
159: | . | |
160: |-----------------------------------------| |
161: | PERF_COUNTER_DEFINITION NumCounters-1 | |
162: | | |
163: | | |
164: |-----------------------------------------| |
165: | . |<---------*
166: | . |
167: | . |
168: +-----------------------------------------+
169:
170: Following the counter definitions for the object type are the Instances for
171: that object type. In a multiprocessor system, for example, there are by
172: definition multiple instances of the object type processor. The number
173: of instances for an object type like threads may not be the same from
174: one call to get data to the next.
175:
176: +-----------------------------------------+
177: | PERF_OBJECT_TYPE i |
178: | |
179: | - - - - - - - - - - - - - - - - - - - - |
180: | TotalByteLength *---------------*
181: | - - - - - - - - - - - - - - - - - - - - | |
182: | DefinitionLength *----------* |
183: | - - - - - - - - - - - - - - - - - - - - | | |
184: | HeaderLength *-----* | |
185: | - - - - - - - - - - - - - - - - - - - - | | | |
186: | NumCounters | | | |
187: | - - - - - - - - - - - - - - - - - - - - | | | |
188: | NumInstances | | | |
189: | - - - - - - - - - - - - - - - - - - - - | | | |
190: | | | | |
191: | | | | |
192: |-----------------------------------------| | | |
193: | PERF_COUNTER_DEFINITION 0 |<----* | |
194: | | | |
195: | | | |
196: |-----------------------------------------| | |
197: | PERF_COUNTER_DEFINITION 1 | | |
198: | | | |
199: | | | |
200: |-----------------------------------------| | |
201: | . | | |
202: | . | | |
203: | . | | |
204: |-----------------------------------------| | |
205: | PERF_COUNTER_DEFINITION NumCounters-1 | | |
206: | | | |
207: | | | |
208: |-----------------------------------------| | |
209: | PERF_INSTANCE_DEFINITION 0 |<---------* |
210: | | |
211: | | |
212: |-----------------------------------------| |
213: | PERF_INSTANCE_DEFINITION 1 | |
214: | | |
215: | | |
216: |-----------------------------------------| |
217: | PERF_INSTANCE_DEFINITION 2 | |
218: | | |
219: | | |
220: |-----------------------------------------| |
221: | . | |
222: | . | |
223: | . | |
224: |-----------------------------------------| |
225: | PERF_INSTANCE_DEFINITION NumInstances-1 | |
226: | | |
227: | | |
228: +-----------------------------------------+<--------------*
229: Each instance definition is followed by the counter data for that instance.
230: This is the actual data for each counter defined for the object type of
231: which the instance is a member. There are PERF_OBJECT_TYPE.NumCounters
232: such counters for !each! instance.
233:
234: The size of the various instance definitions is not constant, since each
235: instance definition structure is followed by the null-terminated name of
236: the instance. Therefore the instance definition contains an offset to
237: its first counter data item, and also to its name.
238:
239: +-----------------------------------------+
240: | PERF_INSTANCE_DEFINITION j |
241: | |
242: | - - - - - - - - - - - - - - - - - - - - |
243: | ByteLength *-----------*
244: | - - - - - - - - - - - - - - - - - - - - | |
245: | | |
246: | | |
247: | - - - - - - - - - - - - - - - - - - - - | |
248: | NameOffset *-----* |
249: | - - - - - - - - - - - - - - - - - - - - | | |
250: | | | |
251: | | | |
252: | - - - - - - - - - - - - - - - - - - - - | | |
253: | Name of PERF_INSTANCE_DEFINITION j |<----* |
254: | | |
255: | | |
256: | | |
257: | ...padded to 4 byte boundary| |
258: |-----------------------------------------| |
259: | PERF_COUNTER_BLOCK |<----------*
260: | - - - - - - - - - - - - - - - - - - - - |
261: | ByteLength *-----*
262: | - - - - - - - - - - - - - - - - - - - - | |
263: | Data for Counter 0 | |
264: | - - - - - - - - - - - - - - - - - - - - | |
265: | Data for Counter 1 | |
266: | - - - - - - - - - - - - - - - - - - - - | |
267: | Data for Counter 2 | |
268: | | |
269: | - - - - - - - - - - - - - - - - - - - - | |
270: | . | |
271: | . | |
272: | . | |
273: | - - - - - - - - - - - - - - - - - - - - | |
274: | Data for Counter NumCounters-1 | |
275: | | |
276: +-----------------------------------------+<----*
277:
278: \*****************************************************************************/
279:
280: // Data structure definitions.
281:
282: // In order for data to be returned through the Configuration Registry
283: // in a system-independent fashion, it must be self-describing.
284:
285: // In the following, all offsets are in bytes.
286:
287: //
288: // Data is returned through the Configuration Registry in a
289: // a data block which begins with a _PERF_DATA_BLOCK structure.
290: //
291:
292: #define PERF_DATA_VERSION 1
293: #define PERF_DATA_REVISION 0
294:
295:
296: typedef struct _PERF_DATA_BLOCK {
297: WCHAR Signature[4]; // Signature: Unicode "PERF"
298: DWORD LittleEndian; // 0 = Big Endian, 1 = Little Endian
299: DWORD Version; // Version of these data structures
300: // starting at 1
301: DWORD Revision; // Revision of these data structures
302: // starting at 0 for each Version
303: DWORD TotalByteLength; // Total length of data block
304: DWORD HeaderLength; // Length of this structure
305: DWORD NumObjectTypes; // Number of types of objects
306: // being reported
307: DWORD DefaultObject; // Index starting at 0 of default
308: // object to display when data from
309: // this system is retireved (-1 =
310: // none, but this is not expected to
311: // be used)
312: SYSTEMTIME SystemTime; // Time at the system under
313: // measurement
314: LARGE_INTEGER PerfTime; // Performance counter value
315: // at the system under measurement
316: LARGE_INTEGER PerfFreq; // Performance counter frequency
317: // at the system under measurement
318: LARGE_INTEGER PerfTime100nSec; // Performance counter time in 100 nsec
319: // units at the system under measurement
320: DWORD SystemNameLength; // Length of the system name
321: DWORD SystemNameOffset; // Offset, from beginning of this
322: // structure, to name of system
323: // being measured
324: } PERF_DATA_BLOCK, *PPERF_DATA_BLOCK;
325:
326:
327: //
328: // The _PERF_DATA_BLOCK structure is followed by NumObjectTypes of
329: // data sections, one for each type of object measured. Each object
330: // type section begins with a _PERF_OBJECT_TYPE structure.
331: //
332:
333:
334: typedef struct _PERF_OBJECT_TYPE {
335: DWORD TotalByteLength; // Length of this object definition
336: // including this structure, the
337: // counter defintions, and the
338: // instance definitions and the
339: // counter blocks for each instance:
340: // This is the offset from this
341: // structure to the next object, if
342: // any
343: DWORD DefinitionLength; // Length of object definition,
344: // which includes this structure
345: // and the counter definition
346: // structures for this object: this
347: // is the offset of the first
348: // instance or of the counters
349: // for this object if there is
350: // no instance
351: DWORD HeaderLength; // Length of this structure: this
352: // is the offset to the first
353: // counter definition for this
354: // object
355: DWORD ObjectNameTitleIndex;
356: // Index to name in Title Database
357: LPWSTR ObjectNameTitle; // Initially NULL, for use by
358: // analysis program to point to
359: // retrieved title string
360: DWORD ObjectHelpTitleIndex;
361: // Index to Help in Title Database
362: LPWSTR ObjectHelpTitle; // Initially NULL, for use by
363: // analysis program to point to
364: // retrieved title string
365: DWORD DetailLevel; // Object level of detail (for
366: // controlling display complexity);
367: // will be min of detail levels
368: // for all this object's counters
369: DWORD NumCounters; // Number of counters in each
370: // counter block (one counter
371: // block per instance)
372: DWORD DefaultCounter; // Default counter to display when
373: // this object is selected, index
374: // starting at 0 (-1 = none, but
375: // this is not expected to be used)
376: DWORD NumInstances; // Number of object instances
377: // for which counters are being
378: // returned from the system under
379: // measurement
380: DWORD CodePage; // 0 if instance strings are in
381: // UNICODE, else the Code Page of
382: // the instance names
383: } PERF_OBJECT_TYPE, *PPERF_OBJECT_TYPE;
384:
385: //
386: // The following types of counters are currently defined.
387: //
388:
389: #define PERF_COUNTER_COUNTER 1 // 32-bit Counter. Divide delta
390: // by delta time.
391:
392: // Display suffix: "/sec"
393: #define PERF_COUNTER_TIMER 2 // 64-bit Timer. Divide delta by
394: // delta time.
395: // Display suffix: "%"
396:
397: #define PERF_COUNTER_QUEUELEN 3 // Queue Length Space-Time Product.
398: // Divide delta by delta time.
399: // No Display Suffix.
400:
401: #define PERF_COUNTER_BULK_COUNT 4 // 64-bit Counter. Divide delta by
402: // delta time.
403: // Display Suffix: "/sec"
404:
405: #define PERF_COUNTER_TEXT 5 // Indicates the counter is not a
406: // counter but rather Unicode text
407: // Display as text.
408:
409: #define PERF_COUNTER_RAWCOUNT 6 // Indicates the data is a
410: // counter which should not be
411: // time averaged on display (such as
412: // an error counter on a serial line)
413: // Display as is. No Display Suffix.
414:
415: #define PERF_SAMPLE_FRACTION 7 // A count which is either 1 or 0 on
416: // each sampling interrupt (% busy)
417: // Divide delta by delta base.
418: // Display Suffix: "%"
419:
420: #define PERF_SAMPLE_COUNTER 8 // A count which is sampled on each
421: // sampling interrupt (queue length)
422: // Divide delta by delta time.
423: // No Display Suffix.
424:
425: #define PERF_COUNTER_NODATA 9 // A label: no data is associated
426: // with this counter (it has 0 length)
427: // Do not display.
428:
429: #define PERF_COUNTER_TIMER_INV 10 // 64-bit Timer inverse (e.g., idle
430: // is measured, but display busy %)
431: // Display 100 - delta divided by
432: // delta time. Display suffix: "%"
433:
434: #define PERF_SAMPLE_BASE 11 // The divisor for a sample, used with
435: // the previous counter to form a
436: // sampled %. You must check for >0
437: // before dividing by this! This
438: // counter will directly follow the
439: // numerator counter. It should not
440: // be displayed to the user.
441:
442: #define PERF_AVERAGE_TIMER 12 // A timer which, when divided by
443: // an average base, produces a time
444: // in seconds which is the average
445: // time of some operation. This
446: // timer times total operations, and
447: // the base is the number of opera-
448: // tions. Display Suffix: "sec"
449:
450: #define PERF_AVERAGE_BASE 13 // Used as the denominator in the
451: // computation of time or count
452: // averages. Must directly follow
453: // the numerator counter. Not dis-
454: // played to the user.
455:
456: #define PERF_AVERAGE_BULK 14 // A bulk count which, when divided
457: // (typically) by the number of
458: // operations, gives (typically) the
459: // number of bytes per operation.
460: // No Display Suffix.
461:
462: #define PERF_100NSEC_TIMER 15 // 64-bit Timer in 100 nsec units.
463: // Display delta divided by
464: // delta time. Display suffix: "%"
465:
466: #define PERF_100NSEC_TIMER_INV 16 // 64-bit Timer inverse (e.g., idle
467: // is measured, but display busy %)
468: // Display 100 - delta divided by
469: // delta time. Display suffix: "%"
470:
471: #define PERF_COUNTER_MULTI_TIMER 17 // 64-bit Timer. Divide delta by
472: // delta time. Display suffix: "%"
473: // Timer for multiple instances, so
474: // result can exceed 100%.
475:
476: #define PERF_COUNTER_MULTI_TIMER_INV \
477: 18 // 64-bit Timer inverse (e.g., idle
478: // is measured, but display busy %)
479: // Display 100 * _MULTI_BASE -
480: // delta divided by delta time.
481: // Display suffix: "%" Timer for
482: // multiple instances, so result
483: // can exceed 100%. Followed by
484: // a counter of type _MULTI_BASE.
485:
486: #define PERF_COUNTER_MULTI_BASE 19 // Number of instances to which the
487: // preceeding _MULTI_..._INV counter
488: // applies. Used as a factor to get
489: // the percentage.
490:
491: #define PERF_100NSEC_MULTI_TIMER 20 // 64-bit Timer in 100 nsec units.
492: // Display delta divided by
493: // delta time. Display suffix: "%"
494: // Timer for multiple instances, so
495: // result can exceed 100%.
496:
497: #define PERF_100NSEC_MULTI_TIMER_INV \
498: 21 // 64-bit Timer inverse (e.g., idle
499: // is measured, but display busy %)
500: // Display 100 * _MULTI_BASE -
501: // delta divided by delta time.
502: // Display suffix: "%" Timer for
503: // multiple instances, so result
504: // can exceed 100%. Followed by
505: // a counter of type _MULTI_BASE.
506:
507: //
508: // The following counter type can be used with the preceeding types to
509: // define a reange of values to be displayed in a histogram.
510: //
511:
512: #define PERF_COUNTER_HISTOGRAM 0x80000000
513: // Counter begins or ends a histogram
514:
515: //
516: // The following are used to determine the level of detail associated
517: // with the counter. The user will be setting the level of detail
518: // that should be displayed at any given time.
519: //
520:
521: #define PERF_DETAIL_NOVICE 100 // The uninformed can understand it
522: #define PERF_DETAIL_ADVANCED 200 // For the advanced user
523: #define PERF_DETAIL_EXPERT 300 // For the expert user
524: #define PERF_DETAIL_WIZARD 400 // For the system designer
525:
526:
527: //
528: // There is one of the following for each of the
529: // PERF_OBJECT_TYPE.NumCounters. The Unicode names in this structure MUST
530: // come from a message file.
531: //
532:
533: typedef struct _PERF_COUNTER_DEFINITION {
534: DWORD ByteLength; // Length in bytes of this structure
535: DWORD CounterNameTitleIndex;
536: // Index of Counter name into
537: // Title Database
538: LPWSTR CounterNameTitle; // Initially NULL, for use by
539: // analysis program to point to
540: // retrieved title string
541: DWORD CounterHelpTitleIndex;
542: // Index of Counter Help into
543: // Title Database
544: LPWSTR CounterHelpTitle; // Initially NULL, for use by
545: // analysis program to point to
546: // retrieved title string
547: DWORD DefaultScale; // Power of 10 by which to scale
548: // chart line if vertical axis is 100
549: // 0 ==> 1, 1 ==> 10, -1 ==>1/10, etc.
550: DWORD DetailLevel; // Counter level of detail (for
551: // controlling display complexity)
552: DWORD CounterType; // Type of counter
553: DWORD CounterSize; // Size of counter in bytes
554: DWORD CounterOffset; // Offset from the start of the
555: // PERF_COUNTER_BLOCK to the first
556: // byte of this counter
557: } PERF_COUNTER_DEFINITION, *PPERF_COUNTER_DEFINITION;
558:
559:
560: //
561: // There is one of the following for each of the
562: // PERF_DATA_BLOCK.NumInstances.
563: //
564:
565: #define PERF_NO_UNIQUE_ID -1
566:
567: typedef struct _PERF_INSTANCE_DEFINITION {
568: DWORD ByteLength; // Length in bytes of this structure,
569: // including the subsequent name
570: DWORD ParentObjectTitleIndex;
571: // Title Index to name of "parent"
572: // object (e.g., if thread, then
573: // process is parent object type);
574: // if logical drive, the physical
575: // drive is parent object type
576: DWORD ParentObjectInstance;
577: // Index to instance of parent object
578: // type which is the parent of this
579: // instance.
580: DWORD UniqueID; // A unique ID used instead of
581: // matching the name to identify
582: // this instance, -1 = none
583: DWORD NameOffset; // Offset from beginning of
584: // this struct to the Unicode name
585: // of this instance
586: DWORD NameLength; // Length in bytes of name; 0 = none
587:
588: } PERF_INSTANCE_DEFINITION, *PPERF_INSTANCE_DEFINITION;
589:
590:
591: //
592: // If .ParentObjectName is 0, there
593: // is no parent-child hierarcy for this object type. Otherwise,
594: // the .ParentObjectInstance is an index, starting at 0, into the
595: // instances reported for the parent object type. It is only
596: // meaningful if .ParentObjectName is not 0. The purpose of all this
597: // is to permit reporting/summation of object instances like threads
598: // within processes, and logical drives within physical drives.
599: //
600: //
601: // The PERF_INSTANCE_DEFINITION will be followed by a PERF_COUNTER_BLOCK.
602: //
603:
604: typedef struct _PERF_COUNTER_BLOCK {
605: DWORD ByteLength; // Length in bytes of this structure,
606: // including the following counters
607: } PERF_COUNTER_BLOCK, *PPERF_COUNTER_BLOCK;
608:
609: //
610: // The PERF_COUNTER_BLOCK is followed by PERF_OBJECT_TYPE.NumCounters
611: // number of counters.
612: //
613:
614: #endif // _WINPERF_INCLUDED_
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.