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