Copy to clipboard

# Features impacting performance The Qualcomm^®^ Linux^®^ kernel includes features such as the CPU scheduler, CPU frequency governor, dynamic voltage and frequency scaling (DVFS), and memory management. This guide provides an overview of each feature and related reference links. Additionally, Qualcomm uses a feature called Userspace Resource Manager (URM) to enhance the performance of Qualcomm Linux. ## CPU scheduler The CPU scheduler manages how the CPU time is distributed among the processes running on Linux systems. The CPU scheduler uses [An earliest eligible virtual deadline first (EEVDF) CPU scheduler for Linux](https://lwn.net/Articles/925371/), which is provided by the Linux kernel. The EEVDF CPU scheduler uses [Per-entity load tracking \[LWN.net\]](https://lwn.net/Articles/531853/) to monitor the task load. [Utilization clamping (UCLAMP or util clamp)](https://docs.kernel.org/scheduler/sched-util-clamp.html) is a scheduler that helps manage performance requirements for tasks. For more information, see [Customize CPU scheduler](https://docs.qualcomm.com/doc/80-80020-10/topic/18-customize.html#customize-scheduler). ## CPU frequency governor A CPU frequency governor adjusts the CPU frequency based on the task load. The CPU scheduler provides the necessary inputs for this process. Qualcomm Linux uses the `schedutil` governor, provided by the Linux kernel. This governor increases the CPU frequency when the system is heavily loaded and reduces it when the load is low, ensuring an optimal balance between power consumption and performance. For more information, see the following: - [CPU frequency and voltage scaling code in the Linux kernel](https://www.kernel.org/doc/Documentation/cpu-freq/governors.txt) - [Configure CPU](https://docs.qualcomm.com/doc/80-80020-10/topic/14-configure.html#cpu) - [Customize the CPU frequency governor](https://docs.qualcomm.com/doc/80-80020-10/topic/18-customize.html#cpu-frequency-governor) ## DVFS governors DVFS governors control the frequencies of CPU caches (L3), the last level cache controller (LLCC), and the DDR based on the system workload. These governors increase the frequency when the workload is high and decrease it when the workload is low, ensuring an optimal balance between power consumption and performance. Qualcomm Linux supports the following two types of DVFS governors for L3 cache: - LLCC - DDR ### Static map DVFS governor This governor aligns the frequencies of the CPU L3 cache and the DDR with the current CPU frequency to balance the power and the performance requirements. For example, if the CPU frequency is at its maximum, the L3 cache and DDR frequencies must also be at their maximum levels. The static mapping is available in the source code at `arch/arm64/boot/dts/qcom/.dtsi`. For customization options, see [Customize static map DVFS governor](https://docs.qualcomm.com/doc/80-80020-10/topic/18-customize.html#section-u1x-jps-51c-caharris-03-20-24-2005-37-832). ### BWMON governor The bandwidth monitoring (BWMON) governor dynamically adjusts the frequencies of the LLCC and DDR based on the measured traffic flow from the CPU to the LLCC and then to the DDR. The BWMON hardware block measures this traffic. It monitors the data throughput between memory and the other subsystems within a specified sampling window and uses this information to scale the LLCC and DDR frequencies to meet the required bandwidth. The BWMON governor driver is available in the source code at `drivers/soc/qcom/icc-bwmon.c`. For more information, see the following: - [\[PATCH v3 0/4\] soc/arm64: qcom: Add initial version of bwmon](https://lwn.net/ml/linux-kernel/20220531105137.110050-1-krzysztof.kozlowski@linaro.org/) - [Customize BWMON governor](https://docs.qualcomm.com/doc/80-80020-10/topic/18-customize.html#section-qxs-4ps-51c-caharris-03-20-24-2007-2-926) ## Userspace Resource Manager The Userspace Resource Manager (URM) is an open-source, lightweight, and extensible framework designed to intelligently manage and provision system resources from user space. Modern workloads vary significantly across segments such as servers, compute, XR, mobile, and IoT, with each use case exhibiting distinct characteristics. Some workloads demand high CPU frequencies, others require sustained GPU throughput, while many depend on efficient caching or increased memory bandwidth. At the same time, these workloads run on a wide range of hardware platforms with varying capabilities, power envelopes, and user expectations. Consequently, a uniform tuning approach is insufficient to meet the diverse performance and power requirements of such environments. URM addresses these challenges by providing the following capabilities: - Enabling application-level tuning - Enabling use case and workload-level tuning - Providing signal and tuning APIs URM automatically detects use cases and applies tuning parameters specified in per-application or use case YAML configuration files. Use case detection can be customized through extensions. URM can also modify system behavior to efficiently manage intermittent workloads. The Signal API or Tune API can be invoked within specific code segments to temporarily boost or limit system resources. For example, a critical code path can be executed at a higher CPU frequency for a defined duration. URM efficiently handles concurrent requests from multiple clients. When multiple requests target the same resource, URM aggregates them to determine and apply the optimal performance level required by the device. For more information, see [Userspace Resource Manager Extensions](https://qualcomm.github.io/userspace-resource-manager/). ## Memory RAM is used for all memory allocations made by Qualcomm Linux. RAM must be managed to meet performance requirements and ensure smooth application behavior. The following figure shows memory partitioning: **Figure : Memory partitioning** The figure shows RAM allocation in systems supporting both Linux and non-Linux environments. - System RAM is partitioned between non-Linux and Linux components. - Non-Linux section includes a large block labeled Reserved, indicating memory allocated for non-Linux operations. - Linux section is divided into four blocks under Memory total (system RAM): - Kernel static - Kernel dynamic - User space process - Free memory Certain sections of RAM are managed independent of the Linux system. For example, firmware such as modem, video, and audio run from these specific RAM partitions. The Linux kernel manages all other RAM partitions. The Linux kernel features its own memory management subsystem, which includes: - Implementation of virtual memory and demand paging - Allocation of memory to both kernel internal structures and user space programs - Mapping of files into the address space of the processes - Other memory management operations ### RAM memory partitioning The following table describes various types of memory allocations. Note The commands specified in the following table should be run on the device. | RAM classification | Memory segment | Allocation types | Description | | --- | --- | --- | --- | | Non-Linux | – | – |

Memory is reserved in the form of carveouts by various
subsystems other than Linux.

These carveouts are specified in the respective DTSI
files.

The kernel reserves this memory at boot time for its own
usage.

Vmlinux is the memory used to store the vmlinux image.

The size and breakdown of the vmlinux image can be
obtained from the dmesg logs at boot:

Memory: 3061872K/4134912K available (28800K kernel code, 2090K rwdata, 10688K rodata, 3072K init, 969K bss, 679824K reserved, 393216K cma-reserved)

Kernel code + rwdata + rodata + init +bss indicates vmlinux kernel image size (28800k + 2090k + 10688k + 3072k + 969k)

The kernel page structure is the memory used by the
kernel to maintain page structures for every page of RAM.
This is calculated as 16 MB per GB of RAM size.

The slab is used by the kernel for faster and more
efficient memory usage of frequently used data
structures.

To check the memory usage of the slab, run the following
command:

cat /proc/meminfo | grep -i slab
Copy to clipboard

To check the breakup of various slabs and their
usage, enable CONFIG_SLUB_DEBUG in the kernel
configuration, and then run the following command:

The kernel stack stores the call stack of every process.

To check the memory usage of the kernel stack, run the
following command:

The kernel uses memory to store PageTables that map
virtual addresses to physical addresses.

To check the memory usage of PageTables, run the
following command:

Represents the kernel entities that are dynamically
loaded into the kernel in the form of kernel modules.

To display the list of loaded kernel modules and their
memory usage, run the following command:

Used to allocate contiguous memory.

To check the Vmalloc memory breakup, run the following command:

The amount of file-backed memory that resides in RAM.

To check the cached memory usage, run the following
command:

Buffers are of fixed size and contain blocks of
information either read from disk or written to disk.

To check the buffer memory usage, run the following
command:

Shared memory is a common block of memory that's mapped
into the address spaces of two or more processes.

To check the shared memory usage, run the following
command:

A contiguous physical memory is typically mapped to
other IPs such as video and display. However, it's
allocated to the runtime.

The free memory that the system can use is reduced with
the usage of more CMA reservations. Only the movable
allocations, such as user space process allocations can
use the CMA reserved free memory. However, it can't be
used for the kernel allocations.

Memory that user space applications allocate using
malloc() or new() function calls.

To check the ANON memory breakup for a process, run the
following command:

ION memory allows sharing buffers between hardware IPs
such as video, camera, and Qualcomm Linux.

ION manages one or more memory pools, which can be set
aside at boot time to combat fragmentation.

To check the ION memory usage, run the following
commands:

Memory allocated by the graphics driver.

To check the overall kernel graphics support layer (KGSL)
memory usage, run the following command:

>
>
> cat /sys/class/kgsl/kgsl/page_alloc
> Copy to clipboard

To check the process level breakup, run the following
command:

Free memory is the memory that's not yet used and is
available for any allocation.

To check the available memory, run the following command:
```
cat /proc/meminfo | grep -i MemFree
```

| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ## Real-time kernel [Real-time (RT) Linux](https://realtime-linux.org/) isn't enabled by default on Qualcomm Linux. You can enable RT Linux based on the product requirements. RT Linux is designed to offer deterministic and predictable behavior for applications that are time‑sensitive. For information about preempt RT kernel configuration setup and RT kernel test procedure, see [Learn Real-time (RT) kernel](https://docs.qualcomm.com/bundle/publicresource/topics/80-80020-3/real_time_kernel_overview.html). ## Next steps - [Customize for performance tuning](https://docs.qualcomm.com/doc/80-80020-10/topic/18-customize.html#customize) - [Analyze performance with tools](https://docs.qualcomm.com/doc/80-80020-10/topic/13-performance_tools.html#performance-tools) Last Published: Mar 09, 2026 [Previous Topic Get started with performance tuning and optimization](https://docs.qualcomm.com/bundle/publicresource/80-80020-10/topics/get-started.md) [Next Topic Analyze performance with tools](https://docs.qualcomm.com/bundle/publicresource/80-80020-10/topics/13-performance_tools.md) Source: [https://docs.qualcomm.com/doc/80-80020-10/topic/2-performance-features.html](https://docs.qualcomm.com/doc/80-80020-10/topic/2-performance-features.html)