Copy to clipboard

# Features 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 has added a feature called PerfHAL to enhance performance of the Qualcomm Linux software. ## CPU scheduler The CPU scheduler manages how the CPU time is distributed among the processes running on Linux systems. It uses the earliest eligible virtual deadline first (EEVDF) scheduler, a feature provided by the Linux kernel. The EEVDF CPU scheduler uses per entity load tracking (PELT) to monitor the task load. For more information, see: - [An EEVDF CPU scheduler for Linux](https://lwn.net/Articles/925371/) - [Per-entity load tracking \[LWN.net\]](https://lwn.net/Articles/531853/) Utilization clamping (UCLAMP or util clamp) is a scheduler feature that helps manage performance requirements for tasks. For more information, see: - [https://docs.kernel.org/scheduler/sched-util-clamp.html](https://docs.kernel.org/scheduler/sched-util-clamp.html) - [Customize CPU scheduler](https://docs.qualcomm.com/doc/80-70017-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, a feature provided by the Linux kernel. This governor increases the 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: - [https://www.kernel.org/doc/Documentation/cpu-freq/governors.txt](https://www.kernel.org/doc/Documentation/cpu-freq/governors.txt) - [Configure CPU](https://docs.qualcomm.com/doc/80-70017-10/topic/14-configure.html#cpu) - [Customize CPU frequency governor](https://docs.qualcomm.com/doc/80-70017-10/topic/18-customize.html#cpu-frequency-governer) ## 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-70017-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: - [\[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-70017-10/topic/18-customize.html#section-qxs-4ps-51c-caharris-03-20-24-2007-2-926) ## PerfHAL PerfHAL is a Qualcomm proprietary service that offers added functionality by making perflock APIs accessible. It is beneficial when you need short-term performance enhancements or power savings. Perflocks help in modifying system behavior to manage intermittent workloads. For example, if a specific code segment must run at a higher CPU frequency for a certain duration, perflocks can be used within that code to boost the CPU frequency. PerfHAL efficiently handles concurrent perflock requests from multiple clients. When several requests are aimed at the same resource, PerfHAL aggregates them to achieve the optimal performance level needed by the device. When a perflock of a client is no longer active, PerfHAL releases all the perflocks associated with that client. ### Perflock APIs Perflock APIs are designed to allow applications to adjust system parameters for specific use cases, helping them meet their performance and power objectives. User space applications use the `perf_lock_acq()` and `perf_lock_rel()` APIs to request specific values of system tunable parameters for both, a set time period or an indefinite time period. ### Acquire perflock The `perf_lock_acq()` function is used to acquire a perflock with the necessary optimizations. The syntax for this function is as follows: `int perf_lock_acq(int handle, int duration, int list[], int numArgs)` Table : perf_lock_acq API parameters | Parameter | Description | | --- | --- | | `handle` | Identifies the client request. | | `duration` |

Indicates the maximum timeout period that a perflock must
be held, in milliseconds.

duration parameter can be set for a definite time or
for an indefinite time (0).
- Definite perflocks require a positive integer value to
  specify the maximum timeout period. A timer is created
  and the perflock is released when the timer expires.
- Indefinite perflocks are held until the client calls
  the release function. To manually release a perflock
  that has been set for an indefinite duration, use the
  perf_lock_rel() function.

| | `list` | An array of resource opcodes and value pairs. Opcodes
indicate a system parameter (resource) and the value to set
it (level). | | `numArgs` | Number of elements in the list array. | Table : perf_lock_acq API returns and result | Returns | Result | | --- | --- | | A non-zero integer | Success | | -1 | Failure | ### Perflock release The `perf_lock_rel()` function is used to release a perflock that is held by the `perf_lock_acq()` API. This function is used only for the perflocks that are set for an indefinite time period. The syntax for this function is as follows: `int perf_lock_rel(int handle)` Table : perf_lock_rel API parameters | Parameter | Description | | --- | --- | | `handle` |

Tracks unique requests

Passes the same handle that perf_lock_acq() returns to release the lock

| Table : perf_lock_rel API returns and result | Returns | Result | | --- | --- | | A non-zero integer | Success | | -1 | Failure | ### Resource opcodes Perflock uses a combination of opcodes and their corresponding values to perform specific operations on a perflock resource. To know the supported opcodes on QCS9075 and QCS8275, see the corresponding addendum. The following guides are available to licensed users with authorized access: - [Qualcomm Linux Performance Guide - Addendum for QCS9075](https://docs.qualcomm.com/bundle/resource/topics/80-70017-10A/overview.html) - [Qualcomm Linux Performance Guide - Addendum for QCS8275](https://docs.qualcomm.com/bundle/resource/topics/80-70017-10B/overview.html) The following table lists the supported opcodes: Table : Supported opcodes | Opcode | Purpose | Sysnode on device | | --- | --- | --- | | 0x44000000 | Sets the minimum acceptable performance level for individual
tasks and task groups. | `/proc/sys/kernel/sched_util_clamp_min` | | 0x44004000 | Sets the maximum acceptable performance level for individual
tasks and task groups. | `/proc/sys/kernel/sched_util_clamp_max` | | 0x44008100 | Sets the minimum frequency of the Silver cluster. | `/sys/devices/system/cpu/cpufreq/policy0/scaling_min_freq` | | 0x44008000 | Sets the minimum frequency of the Gold cluster. | `/sys/devices/system/cpu/cpufreq/policy4/scaling_min_freq` | | 0x44008200 | Sets the minimum frequency of the Prime cluster. | `/sys/devices/system/cpu/cpufreq/policy7/scaling_min_freq` | | 0x4400C100 | Sets the maximum frequency of the Silver cluster. | `/sys/devices/system/cpu/cpufreq/policy0/scaling_max_freq` | | 0x4400C000 | Sets the maximum frequency of the Gold cluster. | `/sys/devices/system/cpu/cpufreq/policy4/scaling_max_freq` | | 0x4400C200 | Sets the maximum frequency of the Prime cluster. | `/sys/devices/system/cpu/cpufreq/policy7/scaling_max_freq` | The following are some examples of the resource opcodes: - 0x44008100, 1958400: This pair of opcode and value indicates that the minimum frequency of the Silver cluster must be set to 1958400 KHz. - 0x44008100, 1958400, 0x4400C100, 2100000: This pair of opcode and value indicates that the minimum frequency of the Silver cluster must be set to 1958400 KHz. The maximum frequency of the Silver cluster must be set to 2100000 KHz. For more information on how to use and debug perflock, see [Customize perflock](https://docs.qualcomm.com/doc/80-70017-10/topic/18-customize.html#customize-perlocks). ## Memory RAM is used for all memory allocations made by the Qualcomm Linux software. Effective management of RAM is crucial to meet performance requirements and ensure the smooth functioning of applications. ![../../_images/partitioning-memory.png](data:image/png;base64,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) **Figure : Memory partitioning** 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 understand the memory usage of the slab, run the following
command:
```
cat /proc/meminfo | grep -i slab
```

To understand the breakup of various slabs and their
usage, enable CONFIG_SLUB_DEBUG in the kernel
configuration, and then run the following command:
```
cat /proc/slabinfo
```

The kernel stack stores the call stack of every process.

To understand the memory usage of the kernel stack, run the
following command:
```
cat /proc/meminfo | grep -i kernelstack
```

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

To understand the memory usage of PageTables, run the
following command:
```
cat /proc/meminfo | grep -i PageTables
```

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:
```
cat /proc/modules
```

Used to allocate contiguous memory.

To understand the Vmalloc memory breakup, run the following command:
```
cat /proc/vmallocinfo
```

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

To understand the cached memory usage, run the following
command:
```
cat /proc/meminfo | grep -i cached
```

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

To understand the buffer memory usage, run the following
command:
```
cat /proc/meminfo | grep -i Buffers
```

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

To understand the shared memory usage, run the following
command:
```
cat /proc/meminfo | grep -i shmem
```

A physically continuous memory is typically mapped to
other IPs, such as video and display, however it is
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 cannot be
used for the kernel allocations.

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

To understand the ANON memory breakup for a process, run the
following command:
```
cat /proc/<pid>/smaps
```

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

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

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

mount -t debugfs none /sys/kernel/debug

cat /sys/kernel/debug/dma_buf/bufinfo | grep bytes

Memory allocated by the graphics driver.

To understand the overall kernel graphics support layer (KGSL)
memory usage, run the following command:
```
cat /sys/class/kgsl/kgsl/page_alloc
```

To understand the process level breakup, run the following
command:
```
cat /sys/class/kgsl/kgsl/proc/<pid>/kernel
```

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

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

| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ## Real-time kernel Real-time (RT) Linux is an optional feature that is not enabled by default on Qualcomm Linux. It can be enabled based on the product requirements. RT Linux is designed to offer deterministic and predictable behavior for applications that are time‑sensitive. ### Set up workspace In Qualcomm Linux, the RT Linux kernel recipes are referred to as follows: - Base BSP: `linux-qcom-base-rt` - Custom BSP: `linux-qcom-custom-rt` The Qualcomm Linux kernel supports long-term support (LTS) RT kernel 6.6 version, which is maintained through the Yocto recipe in the `meta-qcom-realtime` layer at the following paths in the source code: - Base BSP: `recipes-kernel/linux/linux-kernel-base-rt_6.6.bb` - Custom BSP: `recipes-kernel/linux/linux-kernel-custom-rt_6.6.bb` For more information on how to clone the workspace and acquire all the meta layers to use Qualcomm RT Linux kernel, see [Sync and build with real-time Linux](https://docs.qualcomm.com/bundle/publicresource/topics/80-70017-254/how_to.html#sync-and-build-with-real-time-linux). ### Enable RT kernel The RT kernel is enabled using the RT Linux kernel recipe. This recipe fetches the kernel, downloads pre-empt RT patches and applies them to the kernel. It also enables a fully pre-emptible kernel with: `CONFIG_PREEMPT_RT=y` For more information, see [Qualcomm Linux Kernel Guide](https://docs.qualcomm.com/bundle/publicresource/topics/80-70017-3/overview.html). ### Verify kernel type After booting, verify the kernel type by running the following command on the device: uname -v Copy to clipboard The following is an output of the command: SMP PREMPT\_RT ### Test RT Linux kernel The RT Linux kernel test helps to obtain the following information: - Real-time performance of the RT Linux kernel - RT Linux kernel latencies and key performance indicators (KPIs) Note This section is only applicable for QCS6490. Caution Ensure that the system is not rebooted during the RT Linux kernel test because this test approximately runs for more than 24 hours. ### Cyclictest Cyclictest tool is used for benchmarking the RT Linux kernel systems. It is used to evaluate the relative performance of the real-time systems. The cyclictest tool is included in the Qualcomm Linux build. For more information, see [https://wiki.linuxfoundation.org/realtime/documentation/howto/tools/cyclictest/start/](https://wiki.linuxfoundation.org/realtime/documentation/howto/tools/cyclictest/start/). The following cyclictests are described in this guide: - Cyclictest with no-load: This test is performed without adding any system load. - Cyclictest with stress-ng (next-generation): This test is performed by adding a specific percentage of load to measure the worst case system latencies. For more information on stress-ng, see [Kernel/Reference/stress-ng - Ubuntu Wiki](https://wiki.ubuntu.com/Kernel/Reference/stress-ng/). #### Presetting > > > Ensure to complete the following presetting before you run a cyclictest: 1. Configure and isolate the CPU core 1 to core 3 for the RT tasks. You may configure any other CPU cores depending on your requirement. For example, you can configure the RT CPUs in the source code at the following path: `layers/meta-qcom-realtime/recipes-kernel/images/linux-qcom-uki.bbappend` For example, configure the CPU as follows: KERNEL_CMDLINE_EXTRA:qcm6490 = "root=/dev/disk/by-partlabel/system rw rootwait ${CONSOLE_CMDLINE} pcie_pme=nomsi net.ifnames=0 pci=noaer kpti=off kasan=off kasan.stacktrace=off swiotlb=128 ${DBG_CMDLINE} mitigations=auto kernel.sched_pelt_multiplier=4 rcupdate.rcu_expedited=1 rcu_nocbs=1-3 **isolcpus=1-3 irqaffinity=4-7** nohz_full=1-3 no-steal-acc vfio_iommu_type1.allow_unsafe_interrupts=1" Copy to clipboard 2. Run the following commands on the RT Linux kernel: > > > echo 0 > /sys/kernel/tracing/tracing_on > Copy to clipboard > > > echo E0 > /sys/devices/virtual/workqueue/kgsl-workqueue/cpumask > Copy to clipboard > > > echo E0 > /sys/devices/virtual/workqueue/scsi_tmf_0/cpumask > Copy to clipboard > > > echo E0 > /sys/devices/virtual/workqueue/writeback/cpumask > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu0/cpuidle/state1/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu0/cpuidle/state2/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu1/cpuidle/state2/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu1/cpuidle/state1/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu2/cpuidle/state1/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu2/cpuidle/state2/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu3/cpuidle/state2/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu3/cpuidle/state1/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu4/cpuidle/state1/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu4/cpuidle/state2/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu5/cpuidle/state2/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu5/cpuidle/state1/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu6/cpuidle/state1/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu6/cpuidle/state2/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu7/cpuidle/state2/disable > Copy to clipboard > > > echo 1 > /sys/devices/system/cpu/cpu7/cpuidle/state1/disable > Copy to clipboard > > > echo 2707200 > /sys/devices/system/cpu/cpufreq/policy7/scaling_min_freq > Copy to clipboard > > > echo 1958400 > /sys/devices/system/cpu/cpufreq/policy0/scaling_min_freq > Copy to clipboard > > > echo 2400000 > /sys/devices/system/cpu/cpufreq/policy4/scaling_min_freq > Copy to clipboard > > > echo performance > /sys/devices/system/cpu/cpufreq/policy7/scaling_governor > Copy to clipboard > > > echo performance > /sys/devices/system/cpu/cpufreq/policy4/scaling_governor > Copy to clipboard > > > echo performance > /sys/devices/system/cpu/cpufreq/policy0/scaling_governor > Copy to clipboard > > > mkdir /sys/fs/cgroup/cpuset/core1-3/ > Copy to clipboard > > > echo 0 > /sys/fs/cgroup/cpuset/core1-3/cpuset.mems > Copy to clipboard > > > echo 1-3 > /sys/fs/cgroup/cpuset/core1-3/cpuset.cpus > Copy to clipboard > > > - Cyclictest with no-load > - To run a cyclictest with no-load, follow these steps: > > 1. Complete the [presetting](https://docs.qualcomm.com/doc/80-70017-10/topic/2-performance-features.html#presetting). > 2. Run the following command to start cyclictest: > > > > > > > > > cgexec -g cpuset:core1-3 cyclictest -a 1-3 -t 3 -m -l 100000000 -i 1000 -p 99 -h 800 --mainaffinity 4 --spike 100 > > Copy to clipboard > > > > > > The command parameters are described in the following table: > > > > > > > > > > > > > > | Command parameter | Description | > > | --- | --- | > > | `cgexec -g cpuset:core1-3` | This part of the command uses cgexec to run a command in a control group (cgroup). The `-g cpuset:core1-3` specifies the cgroup to use, in this case, a cpuset cgroup named `core1-3`, which restricts the execution to CPU cores 1 through 3. | > > | `-a 1-3` | This option specifies the CPU affinity for the threads created by cyclictest, which means, it runs on CPU cores 1 through 3. | > > | `-t 3` | This sets the number of threads to 3. | > > | `-m` | This option locks the memory, preventing the test from being swapped out to disk. | > > | `-l 100000000` | This sets the number of test loops to 100,000,000. | > > | `-i 1000` | This sets the interval between test cycles to 1000 microseconds (1 millisecond). | > > | `-p 99` | This sets the priority of the test threads to 99, which is a high priority in real-time scheduling. | > > | `-h 800` | This sets the histogram size to 800, which is used for measuring the latency. | > > | `--mainaffinity 4` | This sets the CPU affinity for the main thread to the CPU core 4. | > > | `--spike 100` | This option introduces a spike of 100 microseconds to simulate a load. | > 3. Note the latencies. > > - Cyclictest with stress-ng > - To run a cyclictest with stress-ng, follow these steps: > > > > 1. Complete the [presetting](https://docs.qualcomm.com/doc/80-70017-10/topic/2-performance-features.html#presetting). > 2. Open a shell and run the following command to run stress-ng. In the following example command, the CPU is loaded with 60% load: > > > > > > > > > mkdir /tmp/temp-path > > Copy to clipboard > > > > > > > > > stress-ng --cpu 5 --cpu-load 60 --temp-path /tmp/temp-path --sched fifo --sched-prio 1 -t 2d > > Copy to clipboard > > > > This procedure is completed in approximately 48 hours. In this example, CPU 5 is loaded. > 3. Run the following command to start cyclictest in another terminal to run the cyclictest and stress-ng simultaneously: > > > > > > > > > cgexec -g cpuset:core1-3 cyclictest -a 1-3 -t 3 -m -l 100000000 -i 1000 -p 99 -h 800 --mainaffinity 4 --spike 100 > > Copy to clipboard > 4. Press Ctrl + C to stop stress-ng. > 5. Note the worst-case latencies. ### RT Linux kernel KPIs The following tables describe the cyclictests KPIs: > > > KPIs for cyclictest with no-load > > > | RT cores | Core1 | Core2 | Core3 | > | --- | --- | --- | --- | > | Minimum latencies (in microseconds) | 00008 | 00009 | 00009 | > | Maximum latencies (in microseconds) | 00061 | 00019 | 00040 | > > > > > KPIs for cyclictest with stress-ng > > > | RT cores | Core1 | Core2 | Core3 | > | --- | --- | --- | --- | > | Minimum latencies (in microseconds) | 00008 | 00009 | 00009 | > | Maximum latencies (in microseconds) | 00055 | 00037 | 00027 | Last Published: Dec 27, 2024 [Previous Topic Getting started](https://docs.qualcomm.com/bundle/publicresource/80-70017-10/topics/get-started.md) [Next Topic Analysis tools](https://docs.qualcomm.com/bundle/publicresource/80-70017-10/topics/13-performance_tools.md) Source: [https://docs.qualcomm.com/doc/80-70017-10/topic/2-performance-features.html](https://docs.qualcomm.com/doc/80-70017-10/topic/2-performance-features.html)