pdh.pas

在delphi中实现windows核心编程.原书光盘代码核心编程.原书光盘代码

{******************************************************************}
{                                                       	   }
{       Borland Delphi Runtime Library                  	   }
{       Performance Data Helper interface unit                     }
{ 								   }
{ Portions created by Microsoft are 				   }
{ Copyright (C) 1995-1999 Microsoft Corporation. 		   }
{ All Rights Reserved. 						   }
{ 								   }
{ The original file is: Pdh.pas, released 3 Dec 1999. 	           }
{ The original Pascal code is: Pdh.pas, released 3 Dec 1999.       }
{ The initial developer of the Pascal code is Marcel van Brakel    }
{ ([e-mail]).                      			   }
{ 								   }
{ Portions created by Marcel van Brakel are			   }
{ Copyright (C) 1999 Marcel van Brakel.				   }
{ 								   }
{ Obtained through:                               	           }
{ Joint Endeavour of Delphi Innovators (Project JEDI)              }
{								   }
{ You may retrieve the latest version of this file at the Project  }
{ JEDI home page, located at http://delphi-jedi.org                }
{								   }
{ The contents of this file are used with permission, subject to   }
{ the Mozilla Public License Version 1.1 (the "License"); you may  }
{ not use this file except in compliance with the License. You may }
{ obtain a copy of the License at                                  }
{ http://www.mozilla.org/NPL/NPL-1_1Final.html 	                   }
{                                                                  }
{ Software distributed under the License is distributed on an 	   }
{ "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or   }
{ implied. See the License for the specific language governing     }
{ rights and limitations under the License. 			   }
{ 								   }
{******************************************************************}

unit Pdh;

{$WEAKPACKAGEUNIT}

interface

{$HPPEMIT ''}
{$HPPEMIT '#include "pdh.h"'}
{$HPPEMIT ''}

uses
  Windows, WinPerf;

type
  DWORD_PTR = DWORD;

  PDH_STATUS = Longint;
  {$EXTERNALSYM PDH_STATUS}

const

// version info

  PDH_CVERSION_WIN40 = DWORD($0400);
  {$EXTERNALSYM PDH_CVERSION_WIN40}
  PDH_CVERSION_WIN50 = DWORD($0500);
  {$EXTERNALSYM PDH_CVERSION_WIN50}

// v1.1 revision of PDH -- basic log functions
// v1.2 of the PDH -- adds variable instance counters
// v1.3 of the PDH -- adds log service control & stubs for NT5/PDH v2 fn's
// v2.0 of the PDH -- is the NT v 5.0 B2 version

  PDH_VERSION        = DWORD((PDH_CVERSION_WIN50) + $0003);
  {$EXTERNALSYM PDH_VERSION}

// define severity masks

function IsSuccessSeverity(ErrorCode: Longint): Boolean;
{$EXTERNALSYM IsSuccessSeverity}
function IsInformationalSeverity(ErrorCode: Longint): Boolean;
{$EXTERNALSYM IsInformationalSeverity}
function IsWarningSeverity(ErrorCode: Longint): Boolean;
{$EXTERNALSYM IsWarningSeverity}
function IsErrorSeverity(ErrorCode: Longint): Boolean;
{$EXTERNALSYM IsErrorSeverity}

type

// data type definitions

  HCOUNTER = THandle;
  {$EXTERNALSYM HCOUNTER}
  HQUERY = THandle;
  {$EXTERNALSYM HQUERY}
  HLOG = THandle;
  {$EXTERNALSYM HLOG}

  PPdhRawCounter = ^TPdhRawCounter;
  _PDH_RAW_COUNTER = record
    CStatus: DWORD;
    TimeStamp: TFileTime;
    FirstValue: LONGLONG;
    SecondValue: LONGLONG;
    MultiCount: DWORD;
  end;
  {$EXTERNALSYM _PDH_RAW_COUNTER}
  TPdhRawCounter = _PDH_RAW_COUNTER;

  PPdhRawCounterItemA = ^TPdhRawCounterItemA;
  PPdhRawCounterItemW = ^TPdhRawCounterItemW;
  PPdhRawCounterItem = PPdhRawCounterItemA;
  _PDH_RAW_COUNTER_ITEM_A = record
    szName: PAnsiChar;
    RawValue: TPdhRawCounter;
  end;
  {$EXTERNALSYM _PDH_RAW_COUNTER_ITEM_A}
  _PDH_RAW_COUNTER_ITEM_W = record
    szName: PWideChar;
    RawValue: TPdhRawCounter;
  end;
  {$EXTERNALSYM _PDH_RAW_COUNTER_ITEM_W}
  _PDH_RAW_COUNTER_ITEM_ = _PDH_RAW_COUNTER_ITEM_A;
  TPdhRawCounterItemA = _PDH_RAW_COUNTER_ITEM_A;
  TPdhRawCounterItemW = _PDH_RAW_COUNTER_ITEM_W;
  TPdhRawCounterItem = TPdhRawCounterItemA;

  PPdhFmtCounterValue = ^TPdhFmtCounterValue;
  _PDH_FMT_COUNTERVALUE = record
    CStatus: DWORD;
    case Longint of
      1: (longValue: Longint);
      2: (doubleValue: Double);
      3: (largeValue: LONGLONG);
      4: (AnsiStringValue: LPSTR);
      5: (WideStringValue: LPWSTR);
  end;
  {$EXTERNALSYM _PDH_FMT_COUNTERVALUE}
  TPdhFmtCounterValue = _PDH_FMT_COUNTERVALUE;

  PPdhFmtCounterValueItemA = ^TPdhFmtCounterValueItemA;
  PPdhFmtCounterValueItemW = ^TPdhFmtCounterValueItemW;
  PPdhFmtCounterValueItem = PPdhFmtCounterValueItemA;
  _PDH_FMT_COUNTERVALUE_ITEM_A = record
    szName: PAnsiChar;
    FmtValue: TPdhFmtCounterValue;
  end;
  {$EXTERNALSYM _PDH_FMT_COUNTERVALUE_ITEM_A}
  _PDH_FMT_COUNTERVALUE_ITEM_W = record
    szName: PWideChar;
    FmtValue: TPdhFmtCounterValue;
  end;
  {$EXTERNALSYM _PDH_FMT_COUNTERVALUE_ITEM_W}
  _PDH_FMT_COUNTERVALUE_ITEM_ = _PDH_FMT_COUNTERVALUE_ITEM_A;
  TPdhFmtCounterValueItemA = _PDH_FMT_COUNTERVALUE_ITEM_A;
  TPdhFmtCounterValueItemW = _PDH_FMT_COUNTERVALUE_ITEM_W;
  TPdhFmtCounterValueItem = TPdhFmtCounterValueItemA;

  PPdhStatistics = ^TPdhStatistics;
  _PDH_STATISTICS = record
    dwFormat: DWORD;
    Count: DWORD;
    min: TPdhFmtCounterValue;
    max: TPdhFmtCounterValue;
    mean: TPdhFmtCounterValue;
  end;
  {$EXTERNALSYM _PDH_STATISTICS}
  TPdhStatistics = _PDH_STATISTICS;

  PPdhCounterPathElementsA = ^TPdhCounterPathElementsA;
  PPdhCounterPathElementsW = ^TPdhCounterPathElementsW;
  PPdhCounterPathElements = PPdhCounterPathElementsA;
  _PDH_COUNTER_PATH_ELEMENTS_A = record
    szMachineName: PAnsiChar;
    szObjectName: PAnsiChar;
    szInstanceName: PAnsiChar;
    szParentInstance: PAnsiChar;
    dwInstanceIndex: DWORD;
    szCounterName: PAnsiChar;
  end;
  {$EXTERNALSYM _PDH_COUNTER_PATH_ELEMENTS_A}
  _PDH_COUNTER_PATH_ELEMENTS_W = record
    szMachineName: PWideChar;
    szObjectName: PWideChar;
    szInstanceName: PWideChar;
    szParentInstance: PWideChar;
    dwInstanceIndex: DWORD;
    szCounterName: PWideChar;
  end;
  {$EXTERNALSYM _PDH_COUNTER_PATH_ELEMENTS_W}
  _PDH_COUNTER_PATH_ELEMENTS_ = _PDH_COUNTER_PATH_ELEMENTS_A;
  TPdhCounterPathElementsA = _PDH_COUNTER_PATH_ELEMENTS_A;
  TPdhCounterPathElementsW = _PDH_COUNTER_PATH_ELEMENTS_W;
  TPdhCounterPathElements = TPdhCounterPathElementsA;

  PPdhDataItemPathElementsA = ^TPdhDataItemPathElementsA;
  PPdhDataItemPathElementsW = ^TPdhDataItemPathElementsW;
  PPdhDataItemPathElements = PPdhDataItemPathElementsA;
  _PDH_DATA_ITEM_PATH_ELEMENTS_A = record
    szMachineName: PAnsiChar;
    ObjectGUID: TGUID;
    dwItemId: DWORD;
    szInstanceName: PAnsiChar;
  end;
  {$EXTERNALSYM _PDH_DATA_ITEM_PATH_ELEMENTS_A}
  _PDH_DATA_ITEM_PATH_ELEMENTS_W = record
    szMachineName: PWideChar;
    ObjectGUID: TGUID;
    dwItemId: DWORD;
    szInstanceName: PWideChar;
  end;
  {$EXTERNALSYM _PDH_DATA_ITEM_PATH_ELEMENTS_W}
  _PDH_DATA_ITEM_PATH_ELEMENTS_ = _PDH_DATA_ITEM_PATH_ELEMENTS_A;
  TPdhDataItemPathElementsA = _PDH_DATA_ITEM_PATH_ELEMENTS_A;
  TPdhDataItemPathElementsW = _PDH_DATA_ITEM_PATH_ELEMENTS_W;
  TPdhDataItemPathElements = TPdhDataItemPathElementsA;

  PPdhCounterInfoA = ^TPdhCounterInfoA;
  PPdhCounterInfoW = ^TPdhCounterInfoW;
  PPdhCounterInfo = PPdhCounterInfoA;
  _PDH_COUNTER_INFO_A = record
    dwLength: DWORD;
    dwType: DWORD;
    CVersion: DWORD;
    CStatus: DWORD;
    lScale: Longint;
    lDefaultScale: Longint;
    dwUserData: DWORD_PTR;
    dwQueryUserData: DWORD_PTR;
    szFullPath: PAnsiChar;
    Union: record
      case Longint of
        1: (DataItemPath: TPdhDataItemPathElementsA);
        2: (CounterPath: TPdhCounterPathElementsA);
        3: (szMachineName: PAnsiChar;
            szObjectName: PAnsiChar;
            szInstanceName: PAnsiChar;
            szParentInstance: PAnsiChar;
            dwInstanceIndex: DWORD;
            szCounterName: PAnsiChar);
    end;
    szExplainText: PAnsiChar;
    DataBuffer: array[0..0] of DWORD;
  end;
  {$EXTERNALSYM _PDH_COUNTER_INFO_A}
  _PDH_COUNTER_INFO_W = record
    dwLength: DWORD;
    dwType: DWORD;
    CVersion: DWORD;
    CStatus: DWORD;
    lScale: Longint;
    lDefaultScale: Longint;
    dwUserData: DWORD_PTR;
    dwQueryUserData: DWORD_PTR;
    szFullPath: PWideChar;
    Union: record
      case Longint of
        1: (DataItemPath: TPdhDataItemPathElementsW);
        2: (CounterPath: TPdhCounterPathElementsW);
        3: (szMachineName: PWideChar;
            szObjectName: PWideChar;
            szInstanceName: PWideChar;
            szParentInstance: PWideChar;
            dwInstanceIndex: DWORD;
            szCounterName: PWideChar);
    end;
    szExplainText: PWideChar;
    DataBuffer: array[0..0] of DWORD;
  end;
  {$EXTERNALSYM _PDH_COUNTER_INFO_W}
  _PDH_COUNTER_INFO_ = _PDH_COUNTER_INFO_A;
  TPdhCounterInfoA = _PDH_COUNTER_INFO_A;
  TPdhCounterInfoW = _PDH_COUNTER_INFO_W;
  TPdhCounterInfo = TPdhCounterInfoA;

  PPdhTimeInfo = ^TPdhTimeInfo;
  _PDH_TIME_INFO = record
    StartTime: LONGLONG;
    EndTime: LONGLONG;
    SampleCount: DWORD;
  end;
  {$EXTERNALSYM _PDH_TIME_INFO}
  TPdhTimeInfo = _PDH_TIME_INFO;

  PPdhRawLogRecord = ^TPdhRawLogRecord;
  _PDH_RAW_LOG_RECORD = record
    dwStructureSize: DWORD;
    dwRecordType: DWORD;
    dwItems: DWORD;
    RawBytes: array[0..0] of UCHAR;
  end;
  {$EXTERNALSYM _PDH_RAW_LOG_RECORD}
  TPdhRawLogRecord = _PDH_RAW_LOG_RECORD;

  PPdhLogServiceQueryInfoA = ^TPdhLogServiceQueryInfoA;
  PPdhLogServiceQueryInfoW = ^TPdhLogServiceQueryInfoW;
  PPdhLogServiceQueryInfo = PPdhLogServiceQueryInfoA;
  _PDH_LOG_SERVICE_QUERY_INFO_A = record
    dwSize: DWORD;
    dwFlags: DWORD;
    dwLogQuota: DWORD;
    szLogFileCaption: PAnsiChar;
    szDefaultDir: PAnsiChar;
    szBaseFileName: PAnsiChar;
    dwFileType: DWORD;
    dwReserved: DWORD;
    Union: record
      case Longint of
      1: (PdlAutoNameInterval: DWORD;
          PdlAutoNameUnits: DWORD;
          PdlCommandFilename: PAnsiChar;
          PdlCounterList: PAnsiChar;
          PdlAutoNameFormat: DWORD;
          PdlSampleInterval: DWORD;
          PdlLogStartTime: TFileTime;
          PdlLogEndTime: TFileTime);
      2: (TlNumberOfBuffers: DWORD;
          TlMinimumBuffers: DWORD;
          TlMaximumBuffers: DWORD;
          TlFreeBuffers: DWORD;
          TlBufferSize: DWORD;
          TlEventsLost: DWORD;
          TlLoggerThreadId: DWORD;
          TlBuffersWritten: DWORD;
          TlLogHandle: DWORD;
          TlLogFileName: PAnsiChar);
    end;
  end;
  {$EXTERNALSYM _PDH_LOG_SERVICE_QUERY_INFO_A}
  _PDH_LOG_SERVICE_QUERY_INFO_W = record
    dwSize: DWORD;
    dwFlags: DWORD;
    dwLogQuota: DWORD;
    szLogFileCaption: PWideChar;
    szDefaultDir: PWideChar;
    szBaseFileName: PWideChar;
    dwFileType: DWORD;
    dwReserved: DWORD;
    Union: record
      case Longint of
      1: (PdlAutoNameInterval: DWORD;
          PdlAutoNameUnits: DWORD;
          PdlCommandFilename: PWideChar;
          PdlCounterList: PWideChar;
          PdlAutoNameFormat: DWORD;
          PdlSampleInterval: DWORD;
          PdlLogStartTime: TFileTime;
          PdlLogEndTime: TFileTime);
      2: (TlNumberOfBuffers: DWORD;
          TlMinimumBuffers: DWORD;
          TlMaximumBuffers: DWORD;
          TlFreeBuffers: DWORD;
          TlBufferSize: DWORD;
          TlEventsLost: DWORD;
          TlLoggerThreadId: DWORD;
          TlBuffersWritten: DWORD;