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.

To enable performance measurements in Patina, add the Performance component and provide a PerfConfig using configs(mut add: Add<Config>) in your platform's ComponentInfo implementation. For example:

use patina_performance::component::Performance;
use patina_performance::component::performance_config_provider::PerformanceConfigurationProvider;
use patina_dxe_core::*;

impl ComponentInfo for ExamplePlatform {
    fn configs(mut add: Add<Config>) {
        add.config(patina_performance::config::PerfConfig {
            enable_component: true,
            enabled_measurements: {
                patina::performance::Measurement::DriverBindingStart
                | patina::performance::Measurement::DriverBindingStop
                | patina::performance::Measurement::DriverBindingSupport
                | patina::performance::Measurement::LoadImage
                | patina::performance::Measurement::StartImage
            }
        });
    }

    fn components(mut add: Add<Component>) {
        // Add your other components as needed, e.g.:
        // add.component(AdvancedLoggerComponent::<YourUartType>::new(&LOGGER));
        add.component(PerformanceConfigurationProvider);
        add.component(Performance);
    }
}

Note: The PerformanceConfigurationProvider component is optional. Include it if you want to allow runtime configuration of performance measurements via a HOB. If you only want static configuration, you can omit it.

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:

# extern crate mu_rust_helpers;
# extern crate patina;
use patina::performance::{
   logging::perf_function_begin,
   measurement::create_performance_measurement,
};
use mu_rust_helpers::guid::CALLER_ID;

perf_function_begin("foo", &CALLER_ID, create_performance_measurement);

Example of measurement from outside the core:

# extern crate mu_rust_helpers;
# extern crate patina;
# let bs = patina::boot_services::StandardBootServices::new_uninit();
use mu_rust_helpers::guid::CALLER_ID;
use patina::{
   boot_services::BootServices,
   performance::logging::perf_function_begin,
   uefi_protocol::performance_measurement::EdkiiPerformanceMeasurement,
};

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.