[mirror_edk2.git] / PerformancePkg / Dp_App / DpTrace.c

/** @file\r
  * Trace reporting for the Dp utility.\r
  *\r
  * Copyright (c) 2009-2010, Intel Corporation. All rights reserved.<BR>\r
  * This program and the accompanying materials\r
  * are licensed and made available under the terms and conditions of the BSD License\r
  * which accompanies this distribution.  The full text of the license may be found at\r
  * http://opensource.org/licenses/bsd-license.php\r
  *\r
  * THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
  * WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
**/\r
\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/TimerLib.h>\r
#include <Library/PeCoffGetEntryPointLib.h>\r
#include <Library/PerformanceLib.h>\r
#include <Library/PrintLib.h>\r
#include <Library/HiiLib.h>\r
#include <Library/PcdLib.h>\r
\r
#include <Guid/Performance.h>\r
\r
#include "Dp.h"\r
#include "Literals.h"\r
#include "DpInternal.h"\r
\r
/** Collect verbose statistics about the logged performance measurements.\r
  *\r
  * General Summary information for all Trace measurements is gathered and\r
  * stored within the SummaryData structure.  This information is both\r
  * used internally by subsequent reporting functions, and displayed\r
  * at the end of verbose reports.\r
  *\r
  * @pre  The SummaryData and CumData structures must be initialized\r
  *       prior to calling this function.\r
  *\r
  * @post The SummaryData and CumData structures contain statistics for the\r
  *       current performance logs.\r
**/\r
VOID\r
GatherStatistics(\r
  VOID\r
)\r
{\r
  MEASUREMENT_RECORD        Measurement;\r
  UINT64                    Duration;\r
  UINTN                     LogEntryKey;\r
  UINTN                     TIndex;\r
\r
  LogEntryKey = 0;\r
  while ((LogEntryKey = GetPerformanceMeasurement (\r
                        LogEntryKey,\r
                        &Measurement.Handle,\r
                        &Measurement.Token,\r
                        &Measurement.Module,\r
                        &Measurement.StartTimeStamp,\r
                        &Measurement.EndTimeStamp)) != 0)\r
  {\r
    ++SummaryData.NumTrace;           // Count the number of TRACE Measurement records\r
    if (Measurement.EndTimeStamp == 0) {\r
      ++SummaryData.NumIncomplete;    // Count the incomplete records\r
      continue;\r
    }\r
\r
    if (Measurement.Handle != NULL) {\r
      ++SummaryData.NumHandles;       // Count the number of measurements with non-NULL handles\r
    }\r
\r
    if (IsPhase( &Measurement)) {\r
      ++SummaryData.NumSummary;       // Count the number of major phases\r
    }\r
    else {  // !IsPhase(...\r
      if(Measurement.Handle == NULL) {\r
        ++SummaryData.NumGlobal;\r
      }\r
    }\r
\r
    if (AsciiStrnCmp (Measurement.Token, ALit_PEIM, PERF_TOKEN_LENGTH) == 0) {\r
      ++SummaryData.NumPEIMs;         // Count PEIM measurements\r
    }\r
\r
    Duration = GetDuration (&Measurement);\r
    TIndex = GetCumulativeItem (&Measurement);\r
    if (TIndex >= 0) {\r
      CumData[TIndex].Duration += Duration;\r
      CumData[TIndex].Count++;\r
      if ( Duration < CumData[TIndex].MinDur ) {\r
        CumData[TIndex].MinDur = Duration;\r
      }\r
      if ( Duration > CumData[TIndex].MaxDur ) {\r
        CumData[TIndex].MaxDur = Duration;\r
      }\r
    }\r
  }\r
}\r
\r
/** Gather and print ALL Trace Records.\r
  *\r
  * Displays all "interesting" Trace measurements in order.<BR>\r
  * The number of records displayed is controlled by:\r
  *   - records with a duration less than mInterestThreshold microseconds are not displayed.\r
  *   - No more than Limit records are displayed.  A Limit of zero will not limit the output.\r
  *   - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not\r
  *     displayed.\r
  *\r
  * @pre    The mInterestThreshold global variable is set to the shortest duration to be printed.\r
  *         The mGaugeString and mUnicodeToken global arrays are used for temporary string storage.\r
  *         They must not be in use by a calling function.\r
  *\r
  * @param[in]    Limit       The number of records to print.  Zero is ALL.\r
  * @param[in]    ExcludeFlag TRUE to exclude individual Cumulative items from display.\r
  *\r
**/\r
VOID\r
DumpAllTrace(\r
  IN UINTN             Limit,\r
  IN BOOLEAN           ExcludeFlag\r
  )\r
{\r
  MEASUREMENT_RECORD        Measurement;\r
  UINT64                    ElapsedTime;\r
  UINT64                    Duration;\r
  const CHAR16              *IncFlag;\r
  UINTN                     LogEntryKey;\r
  UINTN                     Count;\r
  UINTN                     Index;\r
  UINTN                     TIndex;\r
\r
  EFI_HANDLE                *HandleBuffer;\r
  UINTN                     Size;\r
  EFI_HANDLE                TempHandle;\r
  EFI_STATUS                Status;\r
\r
  IncFlag = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_ALL), NULL);\r
  PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER),\r
              (IncFlag == NULL) ? ALit_UNKNOWN: IncFlag);\r
\r
  // Get Handle information\r
  //\r
  Size = 0;\r
  HandleBuffer = NULL;\r
  Status  = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, &TempHandle);\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    HandleBuffer = AllocatePool (Size);\r
    ASSERT (HandleBuffer != NULL);\r
    Status  = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, HandleBuffer);\r
  }\r
  if (EFI_ERROR (Status)) {\r
    PrintToken (STRING_TOKEN (STR_DP_HANDLES_ERROR), Status);\r
  }\r
  else {\r
    // We have successfully populated the HandleBuffer\r
    // Display ALL Measurement Records\r
    //    Up to Limit lines displayed\r
    //    Display only records with Elapsed times >= mInterestThreshold\r
    //    Display driver names in Module field for records with Handles.\r
    //\r
    PrintToken (STRING_TOKEN (STR_DP_ALL_HEADR) );\r
    PrintToken (STRING_TOKEN (STR_DP_DASHES) );\r
\r
    LogEntryKey = 0;\r
    Count = 0;\r
    Index = 0;\r
    while ( WITHIN_LIMIT(Count, Limit) &&\r
            ((LogEntryKey = GetPerformanceMeasurement (\r
                            LogEntryKey,\r
                            &Measurement.Handle,\r
                            &Measurement.Token,\r
                            &Measurement.Module,\r
                            &Measurement.StartTimeStamp,\r
                            &Measurement.EndTimeStamp)) != 0)\r
          )\r
    {\r
      ++Index;    // Count every record.  First record is 1.\r
      ElapsedTime = 0;\r
      if (Measurement.EndTimeStamp != 0) {\r
        Duration = GetDuration (&Measurement);\r
        ElapsedTime = DurationInMicroSeconds ( Duration );\r
        IncFlag = STR_DP_COMPLETE;\r
      }\r
      else {\r
        IncFlag = STR_DP_INCOMPLETE;  // Mark incomplete records\r
      }\r
      if ((ElapsedTime < mInterestThreshold)                 ||\r
          ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0))\r
         ) {      // Ignore "uninteresting" or excluded records\r
        continue;\r
      }\r
      if (Measurement.EndTimeStamp == 0) {\r
        ElapsedTime = Measurement.StartTimeStamp;\r
      }\r
      ++Count;    // Count the number of records printed\r
\r
      // If Handle is non-zero, see if we can determine a name for the driver\r
      AsciiStrToUnicodeStr (Measurement.Module, mGaugeString); // Use Module by default\r
      AsciiStrToUnicodeStr (Measurement.Token, mUnicodeToken);\r
      if (Measurement.Handle != NULL) {\r
        // See if the Handle is in the HandleBuffer\r
        for (TIndex = 0; TIndex < (Size / sizeof(HandleBuffer[0])); TIndex++) {\r
          if (Measurement.Handle == HandleBuffer[TIndex]) {\r
            GetNameFromHandle (HandleBuffer[TIndex]);\r
            break;\r
          }\r
        }\r
      }\r
      // Ensure that the argument strings are not too long.\r
      mGaugeString[31] = 0;\r
      mUnicodeToken[18] = 0;\r
\r
      PrintToken( STRING_TOKEN (STR_DP_ALL_STATS),\r
        Index,      // 1 based, Which measurement record is being printed\r
        IncFlag,\r
        Measurement.Handle,\r
        mGaugeString,\r
        mUnicodeToken,\r
        ElapsedTime\r
      );\r
    }\r
  }\r
  FreePool (HandleBuffer);\r
}\r
\r
/** Gather and print Raw Trace Records.\r
  *\r
  * All Trace measurements with a duration greater than or equal to\r
  * mInterestThreshold are printed without interpretation.\r
  *\r
  * The number of records displayed is controlled by:\r
  *   - records with a duration less than mInterestThreshold microseconds are not displayed.\r
  *   - No more than Limit records are displayed.  A Limit of zero will not limit the output.\r
  *   - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not\r
  *     displayed.\r
  *\r
  * @pre    The mInterestThreshold global variable is set to the shortest duration to be printed.\r
  *\r
  * @param[in]    Limit       The number of records to print.  Zero is ALL.\r
  * @param[in]    ExcludeFlag TRUE to exclude individual Cumulative items from display.\r
  *\r
**/\r
VOID\r
DumpRawTrace(\r
  IN UINTN          Limit,\r
  IN BOOLEAN        ExcludeFlag\r
  )\r
{\r
  MEASUREMENT_RECORD        Measurement;\r
  UINT64                    ElapsedTime;\r
  UINT64                    Duration;\r
  UINTN                     LogEntryKey;\r
  UINTN                     Count;\r
  UINTN                     Index;\r
\r
  EFI_STRING    StringPtr;\r
\r
  StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_RAWTRACE), NULL);\r
  PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER),\r
              (StringPtr == NULL) ? ALit_UNKNOWN: StringPtr);\r
\r
  PrintToken (STRING_TOKEN (STR_DP_RAW_HEADR) );\r
  PrintToken (STRING_TOKEN (STR_DP_RAW_DASHES) );\r
\r
  LogEntryKey = 0;\r
  Count = 0;\r
  Index = 0;\r
  while ( WITHIN_LIMIT(Count, Limit) &&\r
          ((LogEntryKey = GetPerformanceMeasurement (\r
                          LogEntryKey,\r
                          &Measurement.Handle,\r
                          &Measurement.Token,\r
                          &Measurement.Module,\r
                          &Measurement.StartTimeStamp,\r
                          &Measurement.EndTimeStamp)) != 0)\r
        )\r
  {\r
    ++Index;    // Count every record.  First record is 1.\r
    ElapsedTime = 0;\r
    if (Measurement.EndTimeStamp != 0) {\r
      Duration = GetDuration (&Measurement);\r
      ElapsedTime = DurationInMicroSeconds ( Duration );\r
    }\r
    if ((ElapsedTime < mInterestThreshold)                 ||\r
        ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0))\r
        ) { // Ignore "uninteresting" or Excluded records\r
      continue;\r
    }\r
    ++Count;    // Count the number of records printed\r
    PrintToken (STRING_TOKEN (STR_DP_RAW_VARS),\r
      Index,      // 1 based, Which measurement record is being printed\r
      Measurement.Handle,\r
      Measurement.StartTimeStamp,\r
      Measurement.EndTimeStamp,\r
      Measurement.Token,\r
      Measurement.Module\r
    );\r
  }\r
}\r
\r
/** Gather and print Major Phase metrics.\r
  *\r
  * @param[in]    Ticker      The timer value for the END of Shell phase\r
  *\r
**/\r
VOID\r
ProcessPhases(\r
  UINT64            Ticker\r
  )\r
{\r
  MEASUREMENT_RECORD        Measurement;\r
  UINT64                    BdsTimeoutValue = 0;\r
  UINT64                    SecTime         = 0;\r
  UINT64                    PeiTime         = 0;\r
  UINT64                    DxeTime         = 0;\r
  UINT64                    BdsTime         = 0;\r
  UINT64                    ShellTime       = 0;\r
  UINT64                    ElapsedTime;\r
  UINT64                    Duration;\r
  UINT64                    Total;\r
  EFI_STRING                StringPtr;\r
  UINTN                     LogEntryKey;\r
\r
  //\r
  // Get Execution Phase Statistics\r
  //\r
  StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_PHASES), NULL);\r
  PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER),\r
              (StringPtr == NULL) ? ALit_UNKNOWN: StringPtr);\r
\r
  LogEntryKey = 0;\r
  while ((LogEntryKey = GetPerformanceMeasurement (\r
                          LogEntryKey,\r
                          &Measurement.Handle,\r
                          &Measurement.Token,\r
                          &Measurement.Module,\r
                          &Measurement.StartTimeStamp,\r
                          &Measurement.EndTimeStamp)) != 0)\r
  {\r
    if (AsciiStrnCmp (Measurement.Token, ALit_SHELL, PERF_TOKEN_LENGTH) == 0) {\r
      Measurement.EndTimeStamp = Ticker;\r
    }\r
    if (Measurement.EndTimeStamp == 0) { // Skip "incomplete" records\r
      continue;\r
    }\r
    Duration = GetDuration (&Measurement);\r
    if (   Measurement.Handle != NULL\r
        && (AsciiStrnCmp (Measurement.Token, ALit_BdsTO, PERF_TOKEN_LENGTH) == 0)\r
       )\r
    {\r
      BdsTimeoutValue = Duration;\r
    } else if (AsciiStrnCmp (Measurement.Token, ALit_SEC, PERF_TOKEN_LENGTH) == 0) {\r
      SecTime     = Duration;\r
    } else if (AsciiStrnCmp (Measurement.Token, ALit_PEI, PERF_TOKEN_LENGTH) == 0) {\r
      PeiTime     = Duration;\r
    } else if (AsciiStrnCmp (Measurement.Token, ALit_DXE, PERF_TOKEN_LENGTH) == 0) {\r
      DxeTime      = Duration;\r
    } else if (AsciiStrnCmp (Measurement.Token, ALit_BDS, PERF_TOKEN_LENGTH) == 0) {\r
      BdsTime      = Duration;\r
    } else if (AsciiStrnCmp (Measurement.Token, ALit_SHELL, PERF_TOKEN_LENGTH) == 0) {\r
      ShellTime    = Duration;\r
    }\r
  }\r
\r
  Total = 0;\r
\r
  // print SEC phase duration time\r
  //\r
  if (SecTime > 0) {\r
    ElapsedTime = DurationInMicroSeconds ( SecTime );     // Calculate elapsed time in microseconds\r
    Total += DivU64x32 (ElapsedTime, 1000);   // Accumulate time in milliseconds\r
    PrintToken (STRING_TOKEN (STR_DP_SEC_PHASE), ElapsedTime);\r
  }\r
\r
  // print PEI phase duration time\r
  //\r
  if (PeiTime > 0) {\r
    ElapsedTime = DivU64x32 (\r
                    PeiTime,\r
                    (UINT32)TimerInfo.Frequency\r
                    );\r
    Total += ElapsedTime;\r
    PrintToken (STRING_TOKEN (STR_DP_PHASE_DURATION), ALit_PEI, ElapsedTime);\r
  }\r
\r
  // print DXE phase duration time\r
  //\r
  if (DxeTime > 0) {\r
    ElapsedTime = DivU64x32 (\r
                    DxeTime,\r
                    (UINT32)TimerInfo.Frequency\r
                    );\r
    Total += ElapsedTime;\r
    PrintToken (STRING_TOKEN (STR_DP_PHASE_DURATION), ALit_DXE, ElapsedTime);\r
  }\r
\r
  // print BDS phase duration time\r
  //\r
  if (BdsTime > 0) {\r
    ElapsedTime = DivU64x32 (\r
                    BdsTime,\r
                    (UINT32)TimerInfo.Frequency\r
                    );\r
    Total += ElapsedTime;\r
    PrintToken (STRING_TOKEN (STR_DP_PHASE_DURATION), ALit_BDS, ElapsedTime);\r
  }\r
\r
  if (BdsTimeoutValue > 0) {\r
    ElapsedTime = DivU64x32 (\r
                    BdsTimeoutValue,\r
                    (UINT32)TimerInfo.Frequency\r
                    );\r
    PrintToken (STRING_TOKEN (STR_DP_PHASE_BDSTO), ALit_BdsTO, ElapsedTime);\r
  }\r
\r
  // print SHELL phase duration time\r
  //\r
  if (ShellTime > 0) {\r
    ElapsedTime = DivU64x32 (\r
                    ShellTime,\r
                    (UINT32)TimerInfo.Frequency\r
                    );\r
    Total += ElapsedTime;\r
    PrintToken (STRING_TOKEN (STR_DP_PHASE_DURATION), ALit_SHELL, ElapsedTime);\r
  }\r
\r
  PrintToken (STRING_TOKEN (STR_DP_TOTAL_DURATION), Total);\r
}\r
\r
/** Gather and print Handle data.\r
  *\r
  * @param[in]    ExcludeFlag   TRUE to exclude individual Cumulative items from display.\r
  *\r
  * @return       Status from a call to gBS->LocateHandle().\r
**/\r
EFI_STATUS\r
ProcessHandles(\r
  IN BOOLEAN      ExcludeFlag\r
  )\r
{\r
  MEASUREMENT_RECORD        Measurement;\r
  UINT64                    ElapsedTime;\r
  UINT64                    Duration;\r
  EFI_HANDLE                *HandleBuffer;\r
  EFI_STRING                StringPtr;\r
  UINTN                     Index;\r
  UINTN                     LogEntryKey;\r
  UINTN                     Count;\r
  UINTN                     Size;\r
  EFI_HANDLE                TempHandle;\r
  EFI_STATUS                Status;\r
\r
  StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_DRIVERS), NULL);\r
  PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER),\r
              (StringPtr == NULL) ? ALit_UNKNOWN: StringPtr);\r
\r
  Size = 0;\r
  HandleBuffer = NULL;\r
  Status  = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, &TempHandle);\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    HandleBuffer = AllocatePool (Size);\r
    ASSERT (HandleBuffer != NULL);\r
    Status  = gBS->LocateHandle (AllHandles, NULL, NULL, &Size, HandleBuffer);\r
  }\r
  if (EFI_ERROR (Status)) {\r
    PrintToken (STRING_TOKEN (STR_DP_HANDLES_ERROR), Status);\r
  }\r
  else {\r
#if DP_DEBUG == 2\r
    Print (L"There are %,d Handles defined.\n", (Size / sizeof(HandleBuffer[0])));\r
#endif\r
\r
    PrintToken (STRING_TOKEN (STR_DP_HANDLE_GUID) );\r
    PrintToken (STRING_TOKEN (STR_DP_DASHES) );\r
\r
    LogEntryKey = 0;\r
    Count   = 0;\r
    while ((LogEntryKey = GetPerformanceMeasurement (\r
                            LogEntryKey,\r
                            &Measurement.Handle,\r
                            &Measurement.Token,\r
                            &Measurement.Module,\r
                            &Measurement.StartTimeStamp,\r
                            &Measurement.EndTimeStamp)) != 0)\r
    {\r
      Count++;\r
      Duration = GetDuration (&Measurement);\r
      ElapsedTime = DurationInMicroSeconds ( Duration );\r
      if ((ElapsedTime < mInterestThreshold)                 ||\r
          (Measurement.EndTimeStamp == 0)                    ||\r
          (Measurement.Handle == NULL)                       ||\r
          ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0))\r
         ) { // Ignore "uninteresting" or excluded records\r
        continue;\r
      }\r
      mGaugeString[0] = 0;    // Empty driver name by default\r
      AsciiStrToUnicodeStr (Measurement.Token, mUnicodeToken);\r
      // See if the Handle is in the HandleBuffer\r
      for (Index = 0; Index < (Size / sizeof(HandleBuffer[0])); Index++) {\r
        if (Measurement.Handle == HandleBuffer[Index]) {\r
          GetNameFromHandle (HandleBuffer[Index]); // Name is put into mGaugeString\r
          break;\r
        }\r
      }\r
      // Ensure that the argument strings are not too long.\r
      mGaugeString[31] = 0;\r
      mUnicodeToken[18] = 0;\r
      if (mGaugeString[0] != 0) {\r
        // Display the record if it has a valid handle.\r
        PrintToken (\r
          STRING_TOKEN (STR_DP_HANDLE_VARS),\r
          Count,      // 1 based, Which measurement record is being printed\r
          Index + 1,  // 1 based, Which handle is being printed\r
          mGaugeString,\r
          mUnicodeToken,\r
          ElapsedTime\r
        );\r
      }\r
    }\r
  }\r
  FreePool (HandleBuffer);\r
  return Status;\r
}\r
\r
/** Gather and print PEIM data.\r
  *\r
  * Only prints complete PEIM records\r
  *\r
**/\r
VOID\r
ProcessPeims(\r
  VOID\r
)\r
{\r
  MEASUREMENT_RECORD        Measurement;\r
  UINT64                    Duration;\r
  UINT64                    ElapsedTime;\r
  EFI_STRING                StringPtr;\r
  UINTN                     LogEntryKey;\r
  UINTN                     TIndex;\r
\r
\r
  StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_PEIMS), NULL);\r
  PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER),\r
              (StringPtr == NULL) ? ALit_UNKNOWN: StringPtr);\r
\r
  PrintToken (STRING_TOKEN (STR_DP_PEIM_SECTION));\r
  PrintToken (STRING_TOKEN (STR_DP_DASHES));\r
  TIndex  = 0;\r
  LogEntryKey = 0;\r
  while ((LogEntryKey = GetPerformanceMeasurement (\r
                          LogEntryKey,\r
                          &Measurement.Handle,\r
                          &Measurement.Token,\r
                          &Measurement.Module,\r
                          &Measurement.StartTimeStamp,\r
                          &Measurement.EndTimeStamp)) != 0)\r
  {\r
    TIndex++;\r
    if ((Measurement.EndTimeStamp == 0) ||\r
        (AsciiStrnCmp (Measurement.Token, ALit_PEIM, PERF_TOKEN_LENGTH) != 0)\r
       ) {\r
      continue;\r
    }\r
\r
    Duration = GetDuration (&Measurement);\r
    ElapsedTime = DurationInMicroSeconds ( Duration );  // Calculate elapsed time in microseconds\r
    if (ElapsedTime >= mInterestThreshold) {\r
      GetNameFromHandle (Measurement.Handle);           // Name placed in mGaugeString\r
      PrintToken (STRING_TOKEN (STR_DP_PEIM_STAT2),\r
            TIndex,   // 1 based, Which measurement record is being printed\r
            Measurement.Handle,\r
            mGaugeString,\r
            ElapsedTime\r
      );\r
    }\r
  }\r
}\r
\r
/** Gather and print global data.\r
  *\r
  * Strips out incomplete or "Execution Phase" records\r
  * Only prints records where Handle is NULL\r
  * Increment TIndex for every record, even skipped ones, so that we have an\r
  * indication of every measurement record taken.\r
  *\r
  *\r
**/\r
VOID\r
ProcessGlobal(\r
  VOID\r
)\r
{\r
  MEASUREMENT_RECORD        Measurement;\r
  UINT64                    Duration;\r
  UINT64                    ElapsedTime;\r
  EFI_STRING                StringPtr;\r
  UINTN                     LogEntryKey;\r
  UINTN                     Index;        // Index, or number, of the measurement record being processed\r
\r
  StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_GENERAL), NULL);\r
  PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER),\r
              (StringPtr == NULL) ? ALit_UNKNOWN: StringPtr);\r
\r
  PrintToken (STRING_TOKEN (STR_DP_GLOBAL_SECTION));\r
  PrintToken (STRING_TOKEN (STR_DP_DASHES));\r
\r
  Index = 1;\r
  LogEntryKey = 0;\r
\r
  while ((LogEntryKey = GetPerformanceMeasurement (\r
                          LogEntryKey,\r
                          &Measurement.Handle,\r
                          &Measurement.Token,\r
                          &Measurement.Module,\r
                          &Measurement.StartTimeStamp,\r
                          &Measurement.EndTimeStamp)) != 0)\r
  {\r
    AsciiStrToUnicodeStr (Measurement.Module, mGaugeString);\r
    AsciiStrToUnicodeStr (Measurement.Token, mUnicodeToken);\r
    if ( ! ( IsPhase( &Measurement)  ||\r
        (Measurement.Handle != NULL)      ||\r
        (Measurement.EndTimeStamp == 0)\r
        ))\r
    {\r
      Duration = GetDuration (&Measurement);\r
      ElapsedTime = DurationInMicroSeconds ( Duration );\r
      if (ElapsedTime >= mInterestThreshold) {\r
        PrintToken (\r
          STRING_TOKEN (STR_DP_FOUR_VARS_2),\r
          Index,\r
          mGaugeString,\r
          mUnicodeToken,\r
          ElapsedTime\r
          );\r
      }\r
    }\r
    Index++;\r
  }\r
}\r
\r
/** Gather and print cumulative data.\r
  *\r
  * Traverse the measurement records and:<BR>\r
  * For each record with a Token listed in the CumData array:<BR>\r
  *   - Update the instance count and the total, minimum, and maximum durations.\r
  * Finally, print the gathered cumulative statistics.\r
  *\r
**/\r
VOID\r
ProcessCumulative(\r
  VOID\r
)\r
{\r
  UINT64                    avgval;         // the computed average duration\r
  EFI_STRING                StringPtr;\r
  UINTN                     TIndex;\r
\r
\r
  StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_CUMULATIVE), NULL);\r
  PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER),\r
              (StringPtr == NULL) ? ALit_UNKNOWN: StringPtr);\r
\r
  PrintToken (STRING_TOKEN (STR_DP_CUMULATIVE_SECT_1));\r
  PrintToken (STRING_TOKEN (STR_DP_CUMULATIVE_SECT_2));\r
  PrintToken (STRING_TOKEN (STR_DP_DASHES));\r
\r
  for ( TIndex = 0; TIndex < NumCum; ++TIndex) {\r
    avgval = DivU64x32 (CumData[TIndex].Duration, CumData[TIndex].Count);\r
    PrintToken (STRING_TOKEN (STR_DP_CUMULATIVE_STATS),\r
                CumData[TIndex].Name,\r
                CumData[TIndex].Count,\r
                DurationInMicroSeconds(CumData[TIndex].Duration),\r
                DurationInMicroSeconds(avgval),\r
                DurationInMicroSeconds(CumData[TIndex].MinDur),\r
                DurationInMicroSeconds(CumData[TIndex].MaxDur)\r
               );\r
  }\r
}\r