function RegQueryValueEx(

    hKey: HKEY; // хэндл ключа реестра (HKEY_PERFORMANCE_DATA)

    lpValueName: PChar; // имя значения (набор счетчиков)

    lpReserved: Pointer; // Зарезервировано. Должно быть = 0

    lpType: PDWORD; //Указатель на переменную для типа возвращаемого

                    //значения. Может быть = nil, если не нужна

    lpData: PByte;  //Указатель на буфер для получения данных

    lpcbData: PDWORD //Указатель на переменную, содержащую размер буфера.

                     //После выполнения функции здесь содержится количество

                     //байтов, скопированных в буфер. Может быть = nil,

                     //только если lpData = nil

): Longint;

Для примера. Загрузка процессора процессом выдается в счетчике «% Processor Time», который имеет тип - PERF_100NSEC_TIMER. Чтобы получить реальное значение загрузки в процентах надо снять два последовательных значения счетчика и использовать формулу: 100*(X1-X0)/(Y1-Y0), где X0 и X1 – значения счетчика, а Y0 и Y1 – значения поля PERF_DATA_BLOCK.PerfTime100nSec во время получения данных счетчика.

function FillProcessesList(var slProcesses: TStringList): Boolean;

const

  INCREMENTAL_SIZE     = 32768; // Шаг увеличения буфера

  INITIAL_BUFFER_SIZE  = 65536; // Начальный размер буфера

  PROCESS_OBJECT_INDEX = 230;   // Индекс объекта Process

  PID_OBJECT_INDEX     = 784;   // Индекс счетчика ID Process (PID)

var

  buflen: DWORD; // текущий размер буфера

  PerfData: PPerfDataBlock; // PERF_DATA_BLOCK

  PerfObj: PPerfObjectType; // PERF_OBJECT_TYPE

  PerfCntr, CurCntr: PPerfCounterDefinition;  // PERF_COUNTER_DEFINITION

  PerfInst: PPerfInstanceDefinition;  // PERF_INSTANCE_DEFINITION

  PerfCntrBlk, PtrToCntr: PPerfCounterBlock;   // PERF_COUNTER_BLOCK

  i,k,j: Integer; // счетчики в циклах

  process_name: String; // выходная строка

  pData: PLargeInteger; // Указатель на данные счетчика

begin

  Result := False;

  buflen := INITIAL_BUFFER_SIZE;

  GetMem(PerfData, buflen); // Выделяем начальный буфер

  try

    // Пытаемся заполнить буфер данными

    while RegQueryValueEx(HKEY_PERFORMANCE_DATA,

                          PChar(IntToStr(PROCESS_OBJECT_INDEX)),

                          nil,nil,Pointer(PerfData), @buflen)

                          = ERROR_MORE_DATA do

    begin  // Если буфер маленький, то увеличиваем его и снова пытаемся

      inc(buflen,INCREMENTAL_SIZE);

      ReallocMem(PerfData, buflen);

    end;

    RegCloseKey(HKEY_PERFORMANCE_DATA); // Обязательно закрываем этот ключ.

    // Получаем указатель на первую структуру PERF_OBJECT_TYPE (первый инфоблок)

    PerfObj := PPerfObjectType(DWORD(PerfData) + PerfData.HeaderLength);

    // Перебираем все полученные типы объектов

    for i := 0 to PerfData.NumObjectTypes - 1 do

    begin

      // Ищем объект Process (индекс 230)

      if PerfObj.ObjectNameTitleIndex = PROCESS_OBJECT_INDEX then

      begin

        // Запоминаем расположение описаний счетчиков PERF_COUNTER_DEFINITION

        PerfCntr := PPerfCounterDefinition(DWORD(PerfObj) +

                    PerfObj.HeaderLength);

        // Получаем экземпляры объекта Process, если они есть

        if PerfObj.NumInstances > 0 then

        begin

          // Получаем указатель на первую структуру PERF_INSTANCE_DEFINITION

          PerfInst := PPerfInstanceDefinition(DWORD(PerfObj) +

                                              PerfObj.DefinitionLength);

          // Перебираем все экземпляры объекта

          for k := 0 to PerfObj.NumInstances - 1 do

          begin

            // Получаем имя текущего экземпляра (имя процесса)

            process_name := WideCharToString(PWideChar(DWORD(PerfInst) +

                                             PerfInst.NameOffset));

            // Если имя равно '_Total', то пропускаем этот экземпляр

            // т.к. это суммарные данные для всех процессов

            if process_name = '_Total' then Continue;

            // Получаем указатель на первый счетчик PERF_COUNTER_DEFINITION

            CurCntr := PerfCntr;

            // Получаем указатель на данные счетчиков текущего экземпляра

            // PERF_COUNTER_BLOCK

            PtrToCntr := PPerfCounterBlock(DWORD(PerfInst) +

                         PerfInst.ByteLength);

            //Перебираем все счетчики для каждого объекта

            for j := 0 to PerfObj.NumCounters - 1 do

            begin

              // Получаем указатель на данные счетчика

              pData := Pointer(DWORD(PtrToCntr) + CurCntr.CounterOffset);

              // Если счетчик - это ID Process, то читаем его и

              // добавляем в выходную строку

              if CurCntr.CounterNameTitleIndex = PID_OBJECT_INDEX then

              process_name := process_name +

                              '; PID = ' + IntToStr(Integer(pData^));

              // Получаем указатель на следующий счетчик

              CurCntr := PPerfCounterDefinition(DWORD(CurCntr) +

                         CurCntr.ByteLength);

            end; 

            // Добавляем выходную строку в TStringList

            slProcesses.Add(process_name);

            // Функция сработала успешно

            Result := True;

            // Получаем указатель на следующий экземпляр объекта

            // Он находится сразу за данными текущего экземпляра

            PerfCntrBlk := PPerfCounterBlock(DWORD(PerfInst) +

                                             PerfInst.ByteLength);

            PerfInst := PPerfInstanceDefinition(DWORD(PerfCntrBlk) +

                                                PerfCntrBlk.ByteLength);

          end;

        end;

      end;

      // Получаем указатель на следующий тип объекта

      PerfObj := PPerfObjectType(DWORD(PerfObj) + PerfObj.TotalByteLength);

    end;

  finally

    // В любом случае освобождаем память, занятую буфером

    FreeMem(PerfData);

  end;

end;

На самом деле все не так страшно

Ты наверное ужаснулся уже от объема работы, которую надо проделать, чтобы хоть что-то получить. Мелкомягкие программеры тоже так подумали, сжалились над нами и, начиная с Windows 2000, выпустили специальную библиотеку Performance Data Helper (pdh.dll) Кроме того есть механизм WMI (Windows Management Instrumentation), который больше подходит для .NET-платформы. Теперь получение данных о производительности получается уже несколько понятнее. Например окошко со списком счетчиком на самом первом рисунке создается с помощью функции PdhBrowseCounters, а индекс счетчика по его имени находится с помощью PdhLookupPerfIndexByName Вот так будет выгдядеть получение списка процессов с помощью PDH:

unit Sample3;

interface

uses Windows, Classes, SysUtils;

const

  // Уровни детализации

  PERF_DETAIL_NOVICE   = 100; // Новичок

  PERF_DETAIL_ADVANCED = 200; // Продвинутый

  PERF_DETAIL_EXPERT   = 300; // Эксперт

  PERF_DETAIL_WIZARD   = 400; // Максимальный

  PDH_MORE_DATA = -2147481646; //Все данные не помещаются в предоставленный буфер

function FillProcessesList(var slProcesses: TStringList): Boolean;

implementation

function PdhEnumObjectItems(szDataSource: PChar;

                             szMachineName: PChar;

                             szObjectName: PChar;

                             mszCounterList: PChar;

                             pcchCounterListLength: PDWORD;

                             mszInstanceList: PChar;

                             pcchInstanceListLength: PDWORD;

                             dwDetailLevel: DWORD;

                             dwFlags: DWORD

                             ): LongInt; stdcall; external 'PDH.DLL'

                             name 'PdhEnumObjectItemsA';

function FillProcessesList(var slProcesses: TStringList): Boolean;

var

  pdhStatus: LongInt; // Возвращаемое значение PDH-функций

  sObjectName: array [0..7] of Char; // Буфер для имени объекта "Process"

  pCounterList: PAnsiChar; // Буфер для списка счетчиков

  CounterListLength: DWORD; // Длина буфера для списка счетчиков

  pInstanceList: PAnsiChar; // Буфер для списка экземпляров (процессов), после

                            // заполнения здесь будет цепочка нультерминальных

                            // строк и в конце общий #0.

  InstanceListLength: DWORD;// Длина буфера для списка экземпляров

  pThisInstance: PAnsiChar; // Указатель на имя текущего экземпляра

begin

  Result := False;

  sObjectName := 'Process'; // Собираемся получить список процессов

  CounterListLength := 0; // Обнуляем длины буферов

  InstanceListLength := 0;

  // В первый вызов функции вместо буферов ставим nil и получаем длины буферов

  pdhStatus := PdhEnumObjectItems(nil, // информация реального времени

                                  nil, // локальная машина

                                  @sObjectName, // Имя объекта

                                  nil,

                                  @CounterListLength, // передаем 0

                                  nil,

                                  @InstanceListLength,// передаем 0

                                  PERF_DETAIL_WIZARD, //Максимальная детализация

                                  0);

  // PdhEnumObjectItems должна вернуть PDH_MORE_DATA, если нет - ошибка

  if pdhStatus = PDH_MORE_DATA then

  begin

    // Резервируем память под буферы

    GetMem(pCounterList, CounterListLength);

    GetMem(pInstanceList, InstanceListLength);

    try

      // Вторым вызовом функции получаем информацию

      pdhStatus := PdhEnumObjectItems(nil, // информация реального времени

                                      nil, // локальная машина

                                      @sObjectName, // Имя объекта

                                      pCounterList, // Буфер счетчиков

                                      @CounterListLength,

                                      pInstanceList, // Буфер имен

                                      @InstanceListLength,

                                      PERF_DETAIL_WIZARD,

                                      0);

      // Проверяем успешность выполнения функции PdhEnumObjectItems

      if pdhStatus = ERROR_SUCCESS then

        begin

          // Ставим указатель на начало буфера экземпляров

          pThisInstance := pInstanceList;

          // Крутим цикл пока не кончатся имена (в конце буфера стоит #0)

          while pThisInstance^ <> #0 do

          begin

            // Пропускаем экземпляр с общими данными

            if pThisInstance <> '_Total' then

              // Добавляем имя процесса к списку

              slProcesses.Add(pThisInstance);

            // Перемещаем указатель на следующее имя

            inc(pThisInstance, Length(pThisInstance)+1);

          end;

          // Фунция сработала успешно, если досюда дошло

          Result := True;

        end;

    finally

      // В любом случае освобождаем память буферов

      FreeMem(pCounterList);

      FreeMem(pInstanceList);

    end;

  end;

end;

end.

// my_perfproc.cpp

// Переходник для perfproc.dll

#include "stdafx.h"

#include <windows.h>

typedef DWORD (CALLBACK* pRealOpen)(LPWSTR);

typedef DWORD (WINAPI* pRealClose)();

typedef DWORD (WINAPI* pRealCollect)(LPWSTR,LPVOID,LPDWORD,LPDWORD);

pRealClose   pCloseSysProcessObject;

pRealOpen    pOpenSysProcessObject;

pRealCollect pCollectSysProcessObjectData;

HMODULE      hRealDll = NULL;

BOOL APIENTRY DllMain( HANDLE hModule, DWORD  dwReason, LPVOID lpReserved)

{

       char sExeName[MAX_PATH];

switch (dwReason)

       {

        case DLL_PROCESS_ATTACH:

             GetModuleFileName(NULL, sExeName, MAX_PATH);

             MessageBox(0,sExeName,"EXE Module",0);

             break;

        case DLL_THREAD_ATTACH:

             break;

        case DLL_THREAD_DETACH:

             break;

        case DLL_PROCESS_DETACH:

             break;

       }

    return TRUE;

}

DWORD WINAPI CloseSysProcessObject()

{

       DWORD ret = pCloseSysProcessObject();

       FreeLibrary(hRealDll);

       return 0;

}

DWORD CALLBACK OpenSysProcessObject(LPWSTR lpDeviceNames)

{

       if (!hRealDll) hRealDll = LoadLibrary("perfproc.dll");

       if (!hRealDll) return GetLastError();

       pOpenSysProcessObject = (pRealOpen) GetProcAddress(hRealDll,

                                                            "OpenSysProcessObject");

       pCloseSysProcessObject = (pRealClose) GetProcAddress(hRealDll,

                                                             "CloseSysProcessObject");

       pCollectSysProcessObjectData = (pRealCollect) GetProcAddress(hRealDll,

                                                             "CollectSysProcessObjectData");

       if (! pOpenSysProcessObject ||

           !pCloseSysProcessObject ||  

           !pCollectSysProcessObjectData)

       {

           FreeLibrary(hRealDll);

           hRealDll = NULL;

           return ERROR_INVALID_DATA;

       }

       DWORD ret = pOpenSysProcessObject(lpDeviceNames);

       return ret;

}

DWORD WINAPI CollectSysProcessObjectData(LPWSTR lpwszValue,

                                    LPVOID *lppData,

                                    LPDWORD lpcbBytes,

                                    LPDWORD lpcObjectTypes)

{  

       DWORD dwDataSize = *lpcbBytes;

       DWORD dwNumObjects = 0;

       void* p = *lppData;

       DWORD ret = pCollectSysProcessObjectData(lpwszValue,&p,&dwDataSize,&dwNumObjects);

       *lpcbBytes      = dwDataSize;

       *lpcObjectTypes = dwNumObjects;

       *lppData        = (char*)(*lppData) + dwDataSize;

       return ret;

}