[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
/** \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
  INTN                      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
/** \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 = &TempHandle;\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
    if (HandleBuffer == NULL) {\r
      return;\r
    }\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
  if (HandleBuffer != &TempHandle) {\r
    FreePool (HandleBuffer);\r
  }\r
}\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
/** \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;\r
  UINT64                    SecTime;\r
  UINT64                    PeiTime;\r
  UINT64                    DxeTime;\r
  UINT64                    BdsTime;\r
  UINT64                    ShellTime;\r
  UINT64                    ElapsedTime;\r
  UINT64                    Duration;\r
  UINT64                    Total;\r
  EFI_STRING                StringPtr;\r
  UINTN                     LogEntryKey;\r
\r
  BdsTimeoutValue = 0;\r
  SecTime         = 0;\r
  PeiTime         = 0;\r
  DxeTime         = 0;\r
  BdsTime         = 0;\r
  ShellTime       = 0;   \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
/** \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 = &TempHandle;\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
    if (HandleBuffer == NULL) {\r
      return;\r
    }\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
  if (HandleBuffer != &TempHandle) {\r
    FreePool (HandleBuffer);\r
  }\r
  return Status;\r
}\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 ((EFI_HANDLE) 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
/** \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
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
/** \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