Sorry, you need to enable JavaScript to visit this website.

Intel® Dynamic Platform and Thermal Framework (DPTF) for Chromium OS

Intel ® Dynamic Platform and Thermal Framework (Intel® DPTF) is a solution to help enable thin, quiet, and cool platform designs. Intel DPTF hosts various platform level power and thermal management technologies that help with this goal. Intel DPTF provides mechanisms for platform components and devices to be exposed to individual technologies in a consistent and modular fashion thus enabling a coordinated control of the platform to achieve the power and thermal management goals. This project supports the Chromium operating system.

Introduction

Intel® Dynamic Platform and Thermal Framework (Intel® DPTF) utilizes a few high level concepts to perform it's basic operation. These include the DPTF Framework Manager, Policies, and Participants. Their descriptions are below:

  • DPTF Framework (Manager)
    • The manager is responsible for all communication into the user space code. It serves as the one way in, and the one way back out into the code running in the lower Eco-System Independent Framework (ESIF) layer (the description of ESIF can be found below). It manages events and notifications to and from the ESIF layer. It also handles threads and queues to perform work as requested by the policies. The manager provides a key capability of arbitration that is required when multiple policies attempt to effect specific control knobs within each participant. Without the manager, policies would compete with each other and would cause undesirable effects in the platform.
  • Policies
    • Respond to platform or OS events based on various criteria (temperatures, power source change, etc.).  The policies are the "brains" of Intel DPTF in that they are designed to address a specific platform problem.  For example, the Critical Policy is designed to respond to critical temperature condition that would cause system damage if not addressed.  The Passive Policy is designed to try and gain control of a warming system by adjusting component power/performance (e.g. processor power levels, frequency, etc.).  The Active Policy accomplises the same task as Passive except with active components (e.g. fan control).
  • Participants
    • Participants are represented as a set of telemetry and controls that are exposed to the manager and policies.  These controls can range from the current operating frequency of the processor, to the number of active cores currently available to the OS, etc.  A participant is presented to the policies as a whole set of controls that the policy can operate on.  An example of a participant would be the CPU which exposes performance controls (CPU frequency) and power controls.  Another example would be memory which could also expose power controls.

The high level design of Intel DPTF can be split into two major code partitions as shown in the block diagram below.

  • Intel DPTF Framework and Policies in user space (ring 3): This is where various platform power and thermal management technologies and algorithms are implemented and enabled as desired by the platform. 
  • Abstraction Layer called as Eco-System Independent Framework (ESIF) in user space and Linux Thermal Framework Drivers (ring 0): ESIF implements the platform and OS agnostic capabilities of Intel DPTF. It is designed to allow hosting not only the user mode Intel DPTF framework, but also potentially other "applications" in the future that might require platform and OS agnostic capabilities. ESIF also provides interfaces for an OS agnostic presentation layer that is based on web standards (e.g. HTML-5, etc.). On Linux derived OSes such as Chromium OS and Android, ESIF interfaces with the kernel drivers through sysfs and /dev/acpi_thermal_rel. The Linux thermal framework drivers are responsible for creating such interfaces to enable thermal status reporting and to expose control knobs that can be used by ESIF/DPTF. 

         

DPTF

As shown in the figure above ESIF is a container for Intel DPTF to operate inside of on Linux and Linux derived OS's. Intel DPTF can run as a daemon in userspace and interfaces with ESIF that provides the OS and Platform abstraction and hardware interaction.

ESIF

The Eco-System Independent Framework (ESIF) enables seamless and efficient development for a cross platform and cross OS capable Intel DPTF while keeping a powerful feature set.

ESIF enables Intel DPTF to become cross platform by moving as much functionality as possible to a portable main trunk of code. A data driven model is used to port DPTF to new platforms. The design is scalable and open to extension.

 

Code Organization and Structure

 

Intel DPTF code can be classified as follows.

User Space

  • Language: C/C++
  • DPTF framework is written in C++
  • ESIF Upper Framework (ESIF_UF) is wrtten in C

Kernel Code

  • All kernel modules/drivers are from Linux upstream and as of this writing are based on Linux 4.0 kernel.

Agnostic or Common Code

  • Code target will determine the personality of this code. Examples are Linux vs. Windows on user space memory allocation, timer creation/management, etc. All Windows specific implementation code are trimmed before the Chromium OS implementation is uploaded to GitHub though.
  • Language: C since this would allow maximum re-use across different OSes/platforms.

 

Understandng The Code Structure

The code posted on GitHub is organized with three major folders: DPTF, ESIF Products and ESIF Packages.  The ESIF Products folder contains all of the source code that is necessary to build ESIF.  The ESIF Packages folder contains supporting files necessary to run the compiled ESIF binaries.  A more detailed description of the subfolders is below.

  • DPTF - The userspace control plane containing all policies and logic
    • Linux - Contains Linux build scripts
    • Sources
      • Manager - Contains the Intel DPTF manager that is responsible for managing and arbitrating policies/participants.
      • Policies - Contains the Intel DPTF policies
        • ActivePolicy - Thermal management via active devices (e.g. fan control)
        • CriticalPolicy - Thermal management via "Critical" actions (shut down, sleep, or hibernate the platform)
        • PassivePolicy - Thermal management via passive devices (e.g. power or performance control)
      • PolicyLib - Common code for Intel DPTF policies
      • Resources - Contains XSLT information on how to render Intel DPTF content in the UI
      • SharedLib - Common code for all of the user space code
      • ThirdParty - Contains third party tools utilized in Intel DPTF
      • UnifiedParticipant - Contains the participant related code as well as all of the control knobs necessary to construct a participant.
  • ESIF/Products
    • ESIF_CM - Common code that is agnostic between kernel and user space
    • ESIF_LIB - Library code such as the OS Agnostic Data Vault for configuration management/storage
    • ESIF_UF - Upper Framework contains the code necessary to build the ESIF_UF (user space application or daemon [future])
    • ESIF_WS - Contains an embedded websocket server for DPTF UI/Presentation Layer
  • ESIF/Packages - Support Packages for Intel DPTF/ESIF