Patina Performance Component

The Patina performance component maintains the infrastructure to report firmware performance information.

Responsibilities

• Initialize the FBPT and seed it with any measurements passed in performance data HOBs from prior boot phases.
• Track the current performance measurement mask and load-image count so event producers can filter their output.
• Publish performance properties through a configuration table and expose the measurement protocol (EdkiiPerformanceMeasurement) for C drivers that need to log performance data.
• Optionally merge Management Mode (MM) performance records when an MM communication region is available.
• Publish the FBPT so the operating system can consume it later.

Configuration

• PerfConfig.enable_component must be set to enable the component.
• PerfConfig.enabled_measurements carries the bitmask of patina::performance::Measurement values that should be recorded.
• Platforms that need runtime configuration can include the PerformanceConfigurationProvider component, which reads a PerformanceConfigHob and locks the PerfConfig values for the session.

Enabling Performance Measurements

Enabling performance in Patina is done by adding the Performance component to the Patina DXE Core build.

// ...

Core::default()
 // ...
 .with_component(patina_performance::Performance)
 .start()
 .unwrap();

// ...

Note: Performance measurements for a given platform may need to be enabled. For example, if building in patina-qemu, this build variable should be set to true: BLD_*_PERF_TRACE_ENABLE=TRUE.

The Patina performance component uses a feature mask in its configuration to control how performance is measured.

// ...

Core::default()
 // ...
 .with_config(patina_performance::config::PerfConfig {
     enable_component: true,
     enabled_measurements: {
        patina::performance::Measurement::DriverBindingStart         // Adds driver binding start measurements.
        | patina::performance::Measurement::DriverBindingStop        // Adds driver binding stop measurements.
        | patina::performance::Measurement::DriverBindingSupport     // Adds driver binding support measurements.
        | patina::performance::Measurement::LoadImage                // Adds load image measurements.
        | patina::performance::Measurement::StartImage               // Adds start image measurements.
     }
 })
 .with_component(patina_performance::component::Performance))
 .start()
 .unwrap();

// ...

Enabling Performance Measurements During Boot

A component called PerformanceConfigurationProvider is used to enable performance measurements during the boot process. This component depends on a PerformanceConfigHob HOB to be produced during boot to determine whether the performance component should be enabled and which measurements should be active.

If a platform needs to use a single Patina DXE Core and support firmware builds where performance measurements can be enabled or disabled, it should produce a PerformanceConfigHob HOB during the boot process and include the PerformanceConfigurationProvider component in the DXE Core build. The HOB can be populated by any platform-specific logic, such as a PCD value or a build variable.

Note: PerformanceConfigurationProvider will override the enabled measurements based on the HOB value.

API

Logging Performance Measurements

The method to record performance measurements varies according to whether it is performed from within the core or an external component.

Example of measurement from within the core:

use mu_rust_helpers::guid::CALLER_ID;

perf_function_begin("foo" &CALLER_ID, create_performance_measurement);

Example of measurement from outside the core:

use mu_rust_helpers::guid::CALLER_ID;

let create_performance_measurement = unsafe { bs.locate_protocol::<EdkiiPerformanceMeasurement>(None) }
 .map_or(None, |p| Some(p.create_performance_measurement));

create_performance_measurement.inspect(|f| perf_function_begin("foo", &CALLER_ID, *f));

Performance Component Overview

The Performance Component provides an API for logging performance measurements during firmware execution. This API includes:

• Utility functions to log specific events.
• A function to create performance measurements.

If the measurement is initiated from the core, use the create_performance_measurement function within the utility function. Otherwise, use the function returned by the EdkiiPerformanceMeasurement protocol.

Initialization and Setup

Upon initialization, the component performs the following steps:

1. Initialize the Firmware Performance Data Table (FBPT)

   • Sets up the FBPT data structure to store performance records.

2. Populate FBPT with Pre-DXE Data

   • Retrieves performance data from Hand-Off Blocks (HOBs) generated during the pre-DXE phase and adds them to the FBPT.

3. Install the EdkiiPerformanceMeasurement Protocol

   • Enables external modules to log performance data using the component API.

4. Register Events

   • One event collects performance records logged in Management Mode (MM).
   • Another event publishes the FBPT to allocate the table in reserved memory at the end of the DXE phase.

5. Install Performance Properties

   • Exposes performance-related properties through a configuration table for use by other components.

Scope and Limitations

This component only publishes the FBPT, as it specifically manages the additional record fields within it. Other tables, such as the Firmware Performance Data Table (FPDT), are published by separate components.