# Performance dashboards

You can access performance dashboards for boot time, system benchmarks, memory map, and product segment key performance indicators (KPIs) on the Qualcomm^®^ Linux^®^ reference devices.
The following subsections describe the performance dashboards and measurement procedures for QCS6490, QCS5430, and Qualcomm Dragonwing^™^ IQ-615.

For Qualcomm Dragonwing^™^ IQ-9075 and Qualcomm Dragonwing^™^ IQ-8275 performance dashboards and measurement procedures, see the corresponding addendum. The following guides provide supplementary information and these guides are available to licensed users with authorized access:

- [Qualcomm Linux Performance Guide - Addendum for Qualcomm Dragonwing IQ-9075](https://docs.qualcomm.com/bundle/resource/topics/80-80020-10A/overview.html)
- [Qualcomm Linux Performance Guide - Addendum for Qualcomm Dragonwing IQ-8275](https://docs.qualcomm.com/bundle/resource/topics/80-80020-10B/overview.html)

Tab QCS6490
Tab QCS5430
Tab Qualcomm Dragonwing IQ-615

- *class* tabincludedirective

    - - *class* tabincludedirective

    - 

## Boot time

The boot time is the duration from device power-on until the initialization of the recorder service.

The following table lists the measured boot time (values in seconds) on QCS6490:

| Use case | Score |
| --- | --- |
| Total boot time till recorder initialization | 8.05 |
| systemd boot time | 18.9<br><br><br><br>> <br>> <br>> Note<br>> <br>> <br>> About 5 to 6 seconds increase in userspace time is observed for android-tools-adbd.service. This limitation is documented in the software release notes. |

Note

A lower boot time score is better.

For information about the measurement procedure, see [Boot time measurement](https://docs.qualcomm.com/doc/80-80022-10/topic/46-performance-dashboard.html#boot-time-measurement-procedure).

### System benchmarks

Geekbench is a utility for measuring CPU performance. It provides the
following CPU benchmark scores on QCS6490:

| Benchmark | Version | Benchmark score |
| --- | --- | --- |
| Geekbench ST | 6.1.0 | 1181 |
| Geekbench MT | 6.1.0 | 3035 |

For information about the measurement procedure, see [System benchmark measurement](https://docs.qualcomm.com/doc/80-80022-10/topic/46-performance-dashboard.html#system-benchmark-measurement-procedure).

Note

A higher system benchmark score is better.

### Memory map

The following table lists the memory consumption (values in MB) for each partition,
such as non-Linux, kernel static, and applications. It also lists the
total free memory available to the system after device boot and during use cases such as 4k resolution encoding at 30 fps.

| Memory partitions | After boot |
| --- | --- |
| Total RAM | 6144 |
| Non-Linux | 624 |
| Kernel static | 214 |
| Applications + framework | 733 |
| Total free memory | 4573 |

For information about the measurement procedure, see [Memory map measurement](https://docs.qualcomm.com/doc/80-80022-10/topic/46-performance-dashboard.html#memory-map-measurement-procedure).

Note

A higher total free memory value is better for the system performance.

### Use case KPIs

The following table lists the camera latency measurement data (values in
seconds) for various QCS6490 camera use cases:

| Use case | Latency definition | Latency |
| --- | --- | --- |
| 4K first snapshot latency | First time after boot, time taken from capturing an image to<br>creating a snapshot | 0.34 |

Note

A lower camera latency value is better.

For information about the measurement procedure, see [Camera recording/snapshot latency measurement](https://docs.qualcomm.com/doc/80-80022-10/topic/46-performance-dashboard.html#camera-recording-snapshot-latency).

- *class* tabincludedirective

    - - *class* tabincludedirective

    - 

## Boot time

> 
> 
> The boot time is the duration from device power-on until the
> initialization of the recorder service.
> 
> 
> The following table lists the measured boot time (values in seconds) on
> QCS5430:
> 
> 
> 
> 
> 
> 
> | Use case | FP 1 score |
> | --- | --- |
> | systemd boot time | 21<br><br><br>Note<br><br><br>About 5 to 6 seconds increase in userspace time is observed for android-tools-adbd.service. This limitation is documented in the software release notes. |
> 
> 
> 
> Note
> 
> 
> A lower boot time score is better.
> 
> 
> For information about the measurement procedure, see [Boot time measurement](https://docs.qualcomm.com/doc/80-80022-10/topic/46-performance-dashboard.html#boot-time-measurement-procedure).

### System benchmarks

Geekbench is a utility for measuring CPU performance. It provides the
following CPU benchmark scores on QCS5430:

| Benchmark | Version | Benchmark score for FP 1 |
| --- | --- | --- |
| Geekbench ST | 6.1.0 | 977 |
| Geekbench MT | 6.1.0 | 2193 |

For information about the measurement procedure, see [System benchmark measurement](https://docs.qualcomm.com/doc/80-80022-10/topic/46-performance-dashboard.html#system-benchmark-measurement-procedure).

Note

A higher system benchmark score is better.

### Memory map

The following table lists the memory consumption (values in MB) for each partition such
as non-Linux, kernel static, and applications. It also lists the total
free memory available to the system after device boot and during use cases such as 4k resolution encoding at 30 fps.

| Memory partitions | After boot |
| --- | --- |
| Total RAM | 6144 |
| Non-Linux | 624 |
| Kernel static | 214 |
| Applications + framework | 638 |
| Total free memory | 4669 |

For information about the measurement procedure, see [Memory map measurement](https://docs.qualcomm.com/doc/80-80022-10/topic/46-performance-dashboard.html#memory-map-measurement-procedure).

Note

A higher total free memory value is better for the system performance.

### Use case KPIs

The KPIs for camera latency measurement data across various QCS5430 camera use cases will be provided in a future release.

For information about the measurement procedure, see [Camera recording/snapshot latency measurement](https://docs.qualcomm.com/doc/80-80022-10/topic/46-performance-dashboard.html#camera-recording-snapshot-latency).

- *class* tabincludedirective

    - - *class* tabincludedirective

    - 

## Boot time

The boot time is the duration from device power-on until the initialization of the recorder service.

The following table lists the measured boot time (values in seconds) on Dragonwing IQ-615:

| Use case | Score |
| --- | --- |
| systemd boot time | 18.2<br><br><br><br>> <br>> <br>> Note<br>> <br>> <br>> About 5 to 6 seconds increase in userspace time is observed for android-tools-adbd.service. This limitation is documented in the software release notes. |

Note

A lower boot time score is better.

For information about the measurement procedure, see [Boot time measurement](https://docs.qualcomm.com/doc/80-80022-10/topic/46-performance-dashboard.html#boot-time-measurement-procedure).

### System benchmarks

Geekbench is a utility for measuring CPU performance. It provides the
following CPU benchmark scores on Dragonwing IQ-615:

| Benchmark | Version | Benchmark score |
| --- | --- | --- |
| Geekbench ST | 6.1.0 | 656 |
| Geekbench MT | 6.1.0 | 1658 |

For information about the measurement procedure, see [System benchmark measurement](https://docs.qualcomm.com/doc/80-80022-10/topic/46-performance-dashboard.html#system-benchmark-measurement-procedure).

Note

A higher system benchmark score is better.

### Memory map

The following table lists the memory consumption (values in MB) for each partition, such as non-Linux, kernel static, and applications. It also lists the
total free memory available to the system after device boot and during use cases such as 4k resolution encoding at 30 fps.

| Memory partitions | After boot |
| --- | --- |
| Total RAM | 4096 |
| Non-Linux | 377 |
| Kernel static | 173 |
| Applications + framework | 626 |
| Total free memory | 2920 |

For information about the measurement procedure, see [Memory map measurement](https://docs.qualcomm.com/doc/80-80022-10/topic/46-performance-dashboard.html#memory-map-measurement-procedure).

Note

A higher total free memory value is better for the system performance.

### Use case KPIs

The following table lists the camera latency measurement data (values in
seconds) for various Dragonwing IQ-615 camera use cases:

| Use case | Latency definition | Latency |
| --- | --- | --- |
| 720p30 encode – first camera latency | The time taken, during the first instance after boot, from GStreamer connect to the first encoded video frame. | 0.61 |

Note

A lower camera latency value is better.

For information about the measurement procedure, see [Camera recording/snapshot latency measurement](https://docs.qualcomm.com/doc/80-80022-10/topic/46-performance-dashboard.html#camera-recording-snapshot-latency).

## Measurement procedures

The measurement procedures include KPIs, such as boot time, system
benchmark, record latency, and snapshot latency.

### Boot time measurement

The boot time is the duration from device power-on to the initialization
of the recorder service.

> 
> 
> To measure boot time, do the following:
> 
> 1. Collect serial logs during the device power-on process, focusing on
> the boot loader time. To collect the serial logs on a Linux host, do
> the following:
> 
>     1. Connect a serial cable between the device and the Linux host PC.
>     2. Connect to the UART terminal to obtain serial logs. To set up the
> UART terminal, see [Connect to a UART
> shell](https://docs.qualcomm.com/bundle/publicresource/topics/80-80020-254/how_to.html#connect-to-a-uart-shell).
>     3. Power-off the device.
>     4. Power-on the device.
>     5. Save the serial logs from the terminal.
> 2. After the device boots up and stabilizes, run the following commands on the device to collect logs:
> 
> 
> journalctl --output=short-monotonic -b --no-pager -l > /var/lib/journalctl.txt
>         Copy to clipboard
> 
> 
> systemd-analyze time > /var/lib/systemd-time.txt
>         Copy to clipboard
> 
> 
> 
> For more information about the systemd-analyze tool, see [Analyze performance with tools](https://docs.qualcomm.com/doc/80-80022-10/topic/13-performance_tools.html#performance-tools).
> 
> 
> The following table describes the boot time (values in seconds)
> measurement procedure with log markers for boot time KPI:
> 
> 
> 
> 
> 
> 
> | Boot time stages | Logs | Log markers for start and end point | Calculation |
> | --- | --- | --- | --- |
> | PBL+XBL | Serial logs | `UEFI Start` | `UEFI Start [1818]` |
> | Core UEFI | Serial logs | `UEFI Total` | `UEFI Total: 1071 milliseconds` |
> | Kernel loader | Serial logs | `Exit EBS [3469] UEFI End` | `Exit EBS – (Core UEFI + PBL+XBL)` |
> | Kernel total time | systemd-analyze | `Kernel init time` | `Start-up finished in 3.300 seconds (kernel) + 2 min 6.300 seconds (user space) = 2 min 9.600 seconds multi-user.target reached after 2 min 6.280 seconds in user space` |
> | Kernel init time | journalctl.txt | `enforcing=1 old_enforcing=0` | `1980-01-06T00:00:01.538918+00:00 qcm6490 kernel: [1.854242][T77] audit: type=1404 audit(5.003:2): enforcing=1 old_enforcing=0 auid=4294967295 ses=4294967295 enabled=1 old-enabled=1 lsm=selinux res=1` |
> | Recorder init time | journalctl.txt | `Recorder time: Spectra camera driver initialized`<br>`kernel init time: enforcing=1 old_enforcing=0`<br>`Recorder init time = recorder time - kernel init time` | `1980-01-06T00:02:00.431978+00:00 qcm6490 kernel: [6.493781][T551] CAM_INFO: CAM-UTIL: camera_init: 297 Spectra camera driver initialized.` |
> | Total time until recorder init | Not applicable | Not applicable | `PBL+XBL + Core UEFI + Kernel Loader + Kernel total Time + (recorder init time – kernel init)` |

### System benchmark measurement

Geekbench is a tool used to measure system performance against
the established benchmarks.

To measure system performance using Geekbench, do the following:

1. To download Geekbench from the Linux/ARM section from upstream, see [Geekbench](https://www.geekbench.com/preview/).

Note

The Geekbench 6 for Linux/AArch64 is a preview build. The Geekbench versions may change and the steps mentioned in this section are for your reference. The preview builds require an active Internet connection and automatically upload benchmark results to the Geekbench browser.
2. To measure a CPU benchmark using Geekbench, do the following:

    1. Unzip the Geekbench file and push it from the host into the device, use SCP or a similar tool. Ensure that you specify the target IP address in the first command. The following are the example commands:

scp -r Geekbench-6.3.0-LinuxARMPreview root@10.92.174.66:/var/cache/
            Copy to clipboard

cd /var/cache
            Copy to clipboard

chmod 777 Geekbench-6.3.0-LinuxARMPreview/*
            Copy to clipboard
    2. To run Geekbench, run the following commands on the device:

cd Geekbench-6.3.0-LinuxARMPreview
            Copy to clipboard

./geekbench_aarch64
            Copy to clipboard

### Memory map measurement

A memory map provides information on how memory is allocated for
different processes. A memory map measurement allows you to monitor a
mapped process and troubleshoot any memory issues.

To calculate the memory map, boot the device and stabilize it. Then, run
the following commands to collect logs from the device:

cat /proc/meminfo
    Copy to clipboard

cat /proc/iomem
    Copy to clipboard

cat /proc/vmstat
    Copy to clipboard

### Non-Linux memory

Use the following formula to calculate the non-Linux memory:

Non-Linux = Total RAM size − Total Linux

Run the following command to calculate the total RAM size:

cat /proc/meminfo | grep -i "MemTotal"
    Copy to clipboard

MemTotal is 5512456 kB, which corresponds to approximately 6 GB of RAM.

To calculate the total Linux memory from `iomem`, run the following
command:

cat /proc/iomem | grep System
    Copy to clipboard

The following is an output of the command:

83600000-839fffff : System RAM

9c700000-9d08dfff : System RAM

9d096000-9d0a0fff : System RAM

9d0a9000-9d4ccfff : System RAM

9d4dc000-9d58efff : System RAM

9d598000-9e813fff : System RAM

9e833000-9e87dfff : System RAM

9e887000-9e890fff : System RAM

9e899000-9ed52fff : System RAM

9edcb000-9f7fbfff : System RAM

9f800000-9f9fffff : System RAM

9fc00000-a00cffff : System RAM

e3400000-1ffffffff: System RAM

The total Linux memory is the sum of the differences in the system RAM
addresses.

For example:

839fffff − 83600000 = 4194303 bytes = 3.99 MB

### Kernel static

Use the following formula to calculate the kernel static:

Kernel static = Total Linux − MemTotal

MemTotal is available in meminfo as follows:

MemTotal: 4513944 kB

### Application + framework memory calculation

Use the following formula to calculate the memory used by the applications and framework:

Application + framework = MemTotal − Free memory

### Free memory calculation

Use the following formula to calculate the free memory:

Free memory = MemFree + (Cached − shmem) + buffer + ION cache

To obtain the free memory details, run the following command:

cat /proc/meminfo
    Copy to clipboard

The following is an output of the command:

MemTotal:     4513944 kB
    MemFree:      3471436 kB
    MemAvailable: 3816716 kB
    Buffers:      9216 kB
    Cached:       574856 kB
    Shmem:        24776 kB
    Copy to clipboard

To check the vmstat logs for ION cache, run the following command:

cat /proc/vmstat
    nr_kernel_misc_reclaimable 16217
    Copy to clipboard

Here, 16217 pages represent approximately 63.3 MB. The calculation is as
follows:

16217 pages × 4 kB/page = 64,868 kB (since 1 kB = 1024 bytes)

To convert to megabytes (MB), calculate the ION cache as follows:

64,868 kB ÷ 1024 = 63.3 MB.

### Camera recording/snapshot latency measurement

This topic describes the camera recording/snapshot latency measurement
procedure.

To complete the prerequisites on every reboot, run the following commands on the
device:

mount -t debugfs none /sys/kernel/debug
    Copy to clipboard

setprop persist.qmmf.kpi.debug 2
    Copy to clipboard

### First record latency

To capture the logs, follow these steps:

1. Boot the device and wait for it to stabilize.
2. In one shell, run the following command:

cat /sys/kernel/debug/tracing/trace_pipe > trace.log
        Copy to clipboard
3. In another shell, run the use case.
4. Stop the trace log.
5. See the reference table
to measure the record latency.

### First snapshot latency

1. Boot the device.
2. After the device stabilizes, in one shell, run the following command:

cat /sys/kernel/debug/tracing/trace_pipe > trace.log
        Copy to clipboard
3. In another shell, run the use case.
4. Stop the trace log.
5. See the reference
table
to measure snapshot latency.

### Reference table for measurement

| Use cases | Log marker | Calculation |
| --- | --- | --- |
| Record latency | `273.082629: tracing_mark_write: B|Connect`<br><br><br>`273.119992: tracing_mark_write: B|StartCamera`<br><br><br>`276.722946: tracing_mark_write: B|CreateVideoTrack`<br><br><br>`276.731158: tracing_mark_write: B|StartVideoTrack`<br><br><br>`277.306283: tracing_mark_write: E|FirstVidFrame|1` | `Connect to Start Camera = StartCamera − Connect`<br><br><br>`StartCamera to CreateVideoTrack = CreateVideoTrack − StartCamera`<br><br><br>`CreateVideoTrack to StartVideoTrack = StartVideoTrack −<br>CreateVideoTrack`<br><br><br>`StartVideoTrack to FirstVidFrame = FirstVidFrame − StartVideoTrack`<br><br><br>`Rec latency = sum of above all` |
| Snapshot latency | `303.975067: tracing_mark_write: S|FirstCapImg|0`<br><br><br>`304.544265: tracing_mark_write: S|SnapShot-Shot|0` | `Snapshot latency = snapshot − FirstCapimg` |

Last Published: May 20, 2026

[Previous Topic
Troubleshoot performance issues](https://docs.qualcomm.com/bundle/publicresource/80-80022-10/topics/24-debug.md) [Next Topic
References](https://docs.qualcomm.com/bundle/publicresource/80-80022-10/topics/56-references.md)