windows-nt-4.0/private/ntos/ndis/testprot/tpctl/cpuperf.c

//
//  Include files
//
// #include <ntos.h>

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <ntexapi.h>

#include <windows.h>

extern   VOID printf(UCHAR *,...);
// extern   LARGE_INTEGER KeQueryPerformanceCounter(PLARGE_INTEGER);

#define  MAX_CPUS 64                   // supports maximum of 64 cpus...

// #include "tpdefs.h"
// #include "media.h"
// #include "tpprocs.h"
// #include "string.h"

PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION pStartData;
PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION pEndData;
ULONG                                     NumCpus;
ULONG                                     ProcessorBufSize;
PULONG                                    pKernelPercent;
DWORD                                     StartTestTime;

// --------------------------------------------------
//
// Function:  TpPerfInitCpuUsage
//
// Arguments: none
//
// Returns:   none
//
// Descript:  This function allocates and initializes all the structures
//            necessary for finding the %cpu usage during performance tests
//
// --------------------------------------------------


VOID
CpuUsageInit(VOID)
{
   if (!NumCpus)                       // if NumCpus is zero, need to do first pass initializations
   {                                   // (allocate all buffers, set NumCpus)

      SYSTEM_BASIC_INFORMATION                  BasicInfo;

      //
      // First get the number of processors...
      //

      NtQuerySystemInformation(SystemBasicInformation,
                               &BasicInfo,
                               sizeof(SYSTEM_BASIC_INFORMATION),
                               NULL);

      NumCpus = BasicInfo.NumberOfProcessors;
      if ( (NumCpus < 1) || (NumCpus > MAX_CPUS) )
      {
         printf("CpuUsageInit:  Illegal number of cpus\n");
         goto init_abort;
      }

      //
      // get the memory for the processor instance data
      //

      ProcessorBufSize = NumCpus * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);

      if ( (pStartData = GlobalAlloc(GMEM_FIXED, ProcessorBufSize)) == NULL)
      {
         printf("CpuUsageInit: unable to allocate pStartData buffer\n");
         goto init_abort;
      }

      if ( (pEndData = GlobalAlloc(GMEM_FIXED, ProcessorBufSize)) == NULL)
      {
         printf("CpuUsageInit: unable to allocate pEndData buffer\n");
         goto init_abort;
      }

      if ( (pKernelPercent = GlobalAlloc(GMEM_FIXED , (NumCpus + 1) * sizeof(ULONG))) == NULL)
      {
         printf("CpuUsageInit: unable to allocate pKernelPercent buffer\n");
init_abort:
         if (pStartData)
         {
            GlobalFree(pStartData);
//            pStartData = NULL;
         }
         if (pEndData)
         {
            GlobalFree(pEndData);
//            pEndData = NULL
         }
         if (pKernelPercent)
         {
            GlobalFree(pKernelPercent);
//            pKernelPercent = NULL;
         }
         NumCpus = 0;
         return;
      }
   }

   NtQuerySystemInformation(SystemProcessorPerformanceInformation,
                            pStartData,
                            ProcessorBufSize,
                            NULL);
   StartTestTime = GetTickCount();

}


// ------------------------------------------------
//
// Function:   TpPerfGetCpuUsage
//
// Arguments:  oldptr -- cpu processor performance data from time 0
//             ProcessorTime -- place to put processor times
//             KernelTime    -- place to put kernel times
//
// Returns:    number of processors--0 if error
//
// Descript:   This function reads the performance counters
//             at the end of the test, stored them in an appropriate
//             location, and then cleans up the structures and exits
//
// -------------------------------------------------


ULONG
CpuUsageGetData(PULONG  *ppKernPC,
                ULONG   TestTime)
{
   SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION *pOldProcessorInformation;
   SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION *pNewProcessorInformation;
   ULONG          CurProc;
   LARGE_INTEGER  TotalProcessorTime;
   LARGE_INTEGER  TotalKernelTime;
   LARGE_INTEGER  TempUser;
   LARGE_INTEGER  TempKern;
   LARGE_INTEGER  TempIdle;
   LARGE_INTEGER  trash;
   LARGE_INTEGER  WholeTestTime;
   DWORD          EndTestTime;
   ULONG          flag;

   if (!NumCpus)
   {
      printf("CpuUsageGetData:  called before initialization\n");
      return 0;
   }


   NtQuerySystemInformation(SystemProcessorPerformanceInformation,
                            pEndData,
                            ProcessorBufSize,
                            NULL);
   //
   // find the total time in milliseconds
   //
   EndTestTime = GetTickCount();
//   if (EndTestTime > StartTestTime)
//   {
       WholeTestTime.LowPart = EndTestTime - StartTestTime;
//   }
//   else
//   {
//
//   }
//   WholeTestTime.LowPart  = GetTickCount() - StartTestTime;
   WholeTestTime.HighPart = 0;
//   printf("Kludge factor = %d/%d\n", TestTime, WholeTestTime.LowPart);

   TotalProcessorTime.HighPart = 0;
   TotalProcessorTime.LowPart  = 0;
   TotalKernelTime.HighPart    = 0;
   TotalKernelTime.LowPart     = 0;

   //
   // Total time = UserTime + KernelTime
   // KernelTime = IdleTime + Priviledged time
   // We need total time and priviledged time
   //

   pOldProcessorInformation = pStartData;
   pNewProcessorInformation = pEndData;

   for ( CurProc = 0; CurProc < NumCpus; CurProc++ )
   {
// DEBUG
//         printf("\nCpuUsageGetData:  processor %d\n", CurProc);
//         printf("Initial Idletime = %08x%08x\n",   pOldProcessorInformation->IdleTime.HighPart,
//                                                   pOldProcessorInformation->IdleTime.LowPart);
//         printf("Initial Usertime = %08x%08x\n",   pOldProcessorInformation->UserTime.HighPart,
//                                                   pOldProcessorInformation->UserTime.LowPart);
//         printf("Initial Kerntime = %08x%08x\n\n", pOldProcessorInformation->KernelTime.HighPart,
//                                                   pOldProcessorInformation->KernelTime.LowPart);
//
//         printf("Final   Idletime = %08x%08x\n",   pNewProcessorInformation->IdleTime.HighPart,
//                                                   pNewProcessorInformation->IdleTime.LowPart);
//         printf("Final   Usertime = %08x%08x\n",   pNewProcessorInformation->UserTime.HighPart,
//                                                   pNewProcessorInformation->UserTime.LowPart);
//         printf("Final   Kerntime = %08x%08x\n\n", pNewProcessorInformation->KernelTime.HighPart,
//                                                   pNewProcessorInformation->KernelTime.LowPart);
// END DEBUG

      // first, find all the deltas...

      TempUser = RtlLargeIntegerSubtract(pNewProcessorInformation->UserTime,
                                         pOldProcessorInformation->UserTime);
      TempKern = RtlLargeIntegerSubtract(pNewProcessorInformation->KernelTime,
                                         pOldProcessorInformation->KernelTime);
      TempIdle = RtlLargeIntegerSubtract(pNewProcessorInformation->IdleTime,
                                         pOldProcessorInformation->IdleTime);
      // check for wrapping
//      if (pOldProcessor->UserTime.HighPart > pNewProcessorInformation->UserTime.HighPart)
//      {
//
//      }

//      printf("Delta IdleTime = %08x%08x\n", TempIdle.HighPart, TempIdle.LowPart);
//      printf("Delta UserTime = %08x%08x\n", TempUser.HighPart, TempUser.LowPart);
//      printf("Delta KernTime = %08x%08x\n", TempKern.HighPart, TempKern.LowPart);

      // now find the total processor time = UserTime + KernelTime

      TempUser = RtlLargeIntegerAdd(TempUser, TempKern);

//      printf("Total ProcTime = %08x%08x\n", TempUser.HighPart, TempUser.LowPart);

      // adjust by kludge factor -- TestTime/WholeTestTime

      TempUser = RtlExtendedIntegerMultiply(TempUser, TestTime);
      TempUser = RtlLargeIntegerDivide(TempUser, WholeTestTime, &trash);

      if ((TempUser.HighPart == 0) && (TempUser.LowPart < 10))    // sanity check
      {
          flag = 0;
          printf("Kludge factor = %d/%d\n", TestTime, WholeTestTime.LowPart);
          printf("Adjusted ProcTime = %08x%08x\n", TempUser.HighPart, TempUser.LowPart);
      }
      else
      {
          flag = 1;
      }

      TotalProcessorTime = RtlLargeIntegerAdd(TotalProcessorTime, TempUser);

      // now find the true kernel time = KernelTime - IdleTime

      TempKern = RtlLargeIntegerSubtract(TempKern, TempIdle);

//      printf("True KernTime = %08x%08x\n", TempKern.HighPart, TempKern.LowPart);

      if (TempKern.HighPart < 0)
      {
         TempKern.HighPart = 0;
         TempKern.LowPart  = 0;
      }
      TotalKernelTime = RtlLargeIntegerAdd(TotalKernelTime, TempKern);

      //
      // finally, calc the percent kernel is of total
      //

      if (flag)
      {
         TempKern = RtlExtendedIntegerMultiply(TempKern, 1000);
         TempKern = RtlLargeIntegerDivide(TempKern, TempUser, &trash);
      }
      else
      {
         TempKern.LowPart = 0;
      }
      pKernelPercent[CurProc+1] = TempKern.LowPart;

      // move to info for next processor

      pNewProcessorInformation++;
      pOldProcessorInformation++;
   }

   //
   // last of all,  calc the percent kernel is of total
   //
   if ((TotalProcessorTime.HighPart == 0) && (TotalProcessorTime.LowPart < 10))
   {
      TempKern.LowPart = 0;
   }
   else
   {
      TempKern = RtlExtendedIntegerMultiply(TotalKernelTime, 1000);
      TempKern = RtlLargeIntegerDivide(TempKern, TotalProcessorTime, &trash);
   }
   pKernelPercent[0]    = TempKern.LowPart;

   *ppKernPC = pKernelPercent;

   return NumCpus;
}