# Performance dashboards for QCS6490
Performance dashboards for boot time, system benchmarks, memory map, and product
segment key performance indicators (KPIs) are available for the Qualcomm Linux reference
devices.
## Boot time
Source: [https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html)
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 |
| --- | --- |
| Boot time (log-based) | 6.43 |
Note: A lower value is better.
For measurement procedure, see [Boot time measurement](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html#_29-boot-time-measurement-procuedure).
## System benchmarks
Source: [https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html)
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 | 1173 |
| Geekbench MT | 6.1.0 | 3053 |
For measurement procedure, see [System benchmark measurement](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html#_30-system-benchmark-measurement-procedure).
Note: A higher value is
better.
## Memory map
Source: [https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html)
The following table lists the memory consumption for each partition, such as
non-Linux, kernel static, and applications. It also lists the total free memory available to
the system after device bootup and during the use case such as 4k resolution encoding at
30 fps.
| Memory partitions | After boot | 4K30 encode | 4K30720p30 encode | 4K30 encode sHDRv2 | 4K30 encode sHDRv3 |
| --- | --- | --- | --- | --- | --- |
| Total RAM | 6144 MB | 6144 MB | 6144 MB | 6144 MB | 6144 MB |
| Non-Linux | 611 MB | 611 MB | 611 MB | 611 MB | 611 MB |
| Kernel static | 151 MB | 151 MB | 151 MB | 151 MB | 151 MB |
| Applications + framework | 490 MB | 1188 MB | 1243 MB | 1434 MB | 1536 MB |
| Total free memory | 4892 MB | 4194 MB | 4139 MB | 3948 MB | 3846 MB |
For measurement procedure, see [Memory map measurement](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html#_31-memory-map-measurement-procedure).
Note: A higher value is better for
free memory.
## Use case KPIs
Source: [https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html)
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
creating a snapshot | 0.388 |
| 4K subsequent snapshot latency | Time taken from capturing an image to creating a snapshot
(and subsequent snapshots) | 0.365 |
| 4K30 encoding first record latency | First time after boot, time taken from GStreamer Connect to
the first video‑encoded frame | 3.077 |
| 4K30 encoding subsequent record latency | Time taken from GStreamer Connect to the subsequent
video‑encoded frame | 0.303 |
| 4K30 sHDRv2 encoding first record latency | First time after boot, time taken from GStreamer Connect to
the first video‑encoded frame for 4K30 sHDRv2 | 3.415 |
| 4K30 sHDRv2 encoding subsequent record latency | Time taken from GStreamer Connect to the subsequent
video‑encoded frame for 4K30 sHDRv2 | 0.442 |
| 4K30 sHDRv3 encoding first record latency | First time after boot, time taken from GStreamer Connect to
the first video‑encoded frame for 4K30 sHDRv3 | 3.456 |
| 4K30 sHDRv3 encoding subsequent record latency | Time taken from GStreamer Connect to the subsequent
video‑encoded frame for 4K30 sHDRv3 | 0.416 |
| 4K30 G2G (Glass to Glass) preview | Time taken from the sensor to output the frame until the
frame is previewed on the external display | 0.2 |
Note: A lower value is
better.
For measurement procedure, see [Camera recording/snapshot latency measurement](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html#_32-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
Source: [https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html)
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 a 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-70015-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, collect the following logs from the
device:
cat /var/log/syslog > /var/lib/syslog.txt
systemd-analyze time > /var/lib/systemd-time.txtCopy to clipboard
For more information on the systemd-analyze tool, see [Analysis tools](https://docs.qualcomm.com/doc/80-70015-10/topic/13-performance_tools.html).
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 | Boot time |
| --- | --- | --- | --- | --- |
| PBL+XBL | Serial logs | UEFI Start | `UEFI Start [1818]` | 1.818 |
| Core UEFI | Serial logs | UEFI Total | `UEFI Total: 1071 milliseconds` | 1.071 |
| Kernel loader | Serial logs | Exit EBS [3469] UEFI End | `Exit EBS – (Core UEFI + PBL+XBL)` | 3.469 - (1.071 + 1.818 ) = 0.580 |
| Kernel total time | systemd-analyze | Kernel 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` | 3.300 |
| User space | Syslogs | 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` | 1.854 |
| Recorder init time | Syslog.txt | Spectra camera driver initialized | `1980-01-06T00:02:00.431978+00:00 qcm6490 kernel:
[6.493781][T551] CAM_INFO: CAM-UTIL: camera_init: 297
Spectra camera driver initialized.` | 6.494 |
| Total time until recorder init | – | – | `PBL+XBL + Core UEFI + Kernel Loader + Kernel total Time +
(recorder init time – user space)` | 11.409 |
### System benchmark measurement
Source: [https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html)
Geekbench is a tool used to measure system performance against established
benchmarks.
To measure system performance using Geekbench, do the following:
1. Download Geekbench for the [Linux/ARM](https://cdn.geekbench.com/Geekbench-5.5.1-LinuxARMPreview.tar.gz) architecture from upstream
[https://www.geekbench.com/preview/](https://www.geekbench.com/preview/).
Note: The Geekbench 6 for Linux/AArch64 is a preview build. 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 into the device from the host, use SCP
or a similar tool. Ensure to 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/cacheCopy 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-LinuxARMPreviewCopy to clipboard
./geekbench_aarch64Copy to clipboard
### Memory map measurement
Source: [https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html)
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/meminfoCopy to clipboard
cat /proc/iomemCopy to clipboard
cat /proc/vmstatCopy to clipboard
### Non-Linux memory
Non-Linux memory is calculated using the following formula:
Non-Linux = Total RAM size − Total Linux
The total RAM size can be calculated from `cat /proc/meminfo | grep -i
"MemTotal"`.
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 SystemCopy to clipboard
The
following is an output of the command:
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
The kernel static is calculated using the following formula:
Kernel static = Total Linux − MemTotal
MemTotal is available in meminfo.
MemTotal: 4513944 kB
### Application + framework memory calculation
The memory used by the applications and framework is calculated using the following
formula:
Application + framework = MemTotal − Free memory
### Free memory calculation
Free memory is calculated using the following formula:
Free memory = MemFree + (Cached − shmem) + buffer + ION cache
To obtain the free memory details, run the following command:
cat /proc/meminfoCopy to clipboard
The following is an output of the command:
To check the vmstat logs for ION cache, run the following
command:
cat /proc/vmstat
nr_kernel_misc_reclaimable 16217Copy 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), the ION cache is calculated as follows:
64,868 kB ÷ 1024 = 63.3 MB.
### Camera recording/snapshot latency measurement
Source: [https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html)
This topic describes the camera recording/snapshot latency measurement
procedure.
To perform presetting on every reboot, run the following commands on the
device:
mount -t debugfs none /sys/kernel/debugCopy to clipboard
setprop persist.qmmf.kpi.debug 2Copy to clipboard
### First record latency
To capture the logs, follow these steps:
1. Boot a device and wait for it to stabilize.
2. In one shell, run the following
command:
cat /sys/kernel/debug/tracing/trace_pipe > trace.logCopy to clipboard
3. In another shell, run the use case.
4. Stop the trace log.
5. See the [reference table](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html#_32-camera-recording-snapshot-latency__table_idg_qqv_s1c_caharris_03-14-24-231-58-990) to measure the record latency.
### Subsequent record latency
1. Boot a device.
2. After the device is stabilized, run the use case.
3. Stop the use case.
4. In one shell, run the following command:
cat /sys/kernel/debug/tracing/trace_pipe > trace.logCopy to clipboard
5. In another shell, run the use case.
6. Stop the trace log.
7. See the [reference table](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html#_32-camera-recording-snapshot-latency__table_idg_qqv_s1c_caharris_03-14-24-231-58-990) to measure the record latency.
### First snapshot latency
1. Boot a device.
2. After the device stabilizes, in one shell, run the following command:
cat /sys/kernel/debug/tracing/trace_pipe > trace.logCopy to clipboard
3. In another shell, run the use case.
4. Stop the trace log.
5. See the [reference table](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html#_32-camera-recording-snapshot-latency__table_idg_qqv_s1c_caharris_03-14-24-231-58-990) to measure snapshot latency.
### Subsequent snapshot latency
1. Boot a device.
2. After the device stabilizes, run the use case in another shell.
3. Stop the use case.
4. In one shell, run the following
command:
cat /sys/kernel/debug/tracing/trace_pipe > trace.logCopy to clipboard
5. Run the use case.
6. Stop the trace log.
7. See the [reference table](https://docs.qualcomm.com/doc/80-70015-10/topic/46-performance-dashbaord.html#_32-camera-recording-snapshot-latency__table_idg_qqv_s1c_caharris_03-14-24-231-58-990) to measure snapshot latency.
### Glass to glass preview latency
1. Start a camera preview.
2. Start a stopwatch timer on any display and face the camera sensor on timer.
3. Connect the external display.
4. Capture a photo of the external display preview and stopwatch timer window in
the same capture using an external camera.
5. Note the time difference of a stopwatch timer and external display preview.
### Reference table for measurement
| Use cases | Log marker | Calculation | Latency |
| --- | --- | --- | --- |
| Record latency | 273.082629: tracing\_mark\_write: B|Connect
273.119992: tracing\_mark\_write: B|StartCamera
276.722548: tracing\_mark\_write: B|CreateSession
276.722946: tracing\_mark\_write: B|CreateVideoTrack
276.731158: tracing\_mark\_write: B|StartSession
277.306283: tracing\_mark\_write: E|FirstVidFrame|1 | Connect to Start Camera = StartCamera − Connect
StartCamera to CreateSession = CreateSession −
StartCamera
CreateSession to CreateVideoTrack = CreateVideoTrack −
CreateSession
CreateVideoTrack to StartSession = StartSession −
CreateVideoTrack
StartSession to FirstVidFrame = FirstVidFrame −
StartSession
Rec latency = sum of above all | Connect to Start Camera = 273.120 − 273.083 = 0.037
StartCamera to CreateSession = 276.722 − 273.120 = 3.602
CreateSession to CreateVideoTrack = 276.723 − 276.722 = 0.001
CreateVideoTrack to StartSession =
276.731 − 276.723 = 0.008
StartSession to FirstVidFrame = 277.306 − 276.731 = 0.575
Record latency = 4.223 |
| Snapshot latency | 303.975067: tracing\_mark\_write: S|FirstCapImg|0
304.544265: tracing\_mark\_write: S|SnapShot-Shot|0 | Snapshot latency = snapshot − FirstCapimg | Snapshot latency = 304.544 − 303.975 = 569 |
Last Published: Oct 14, 2024
[Previous Topic
Troubleshooting](https://docs.qualcomm.com/bundle/publicresource/80-70015-10/topics/24-debug.md) [Next Topic
Performance dashboards for QCS5430](https://docs.qualcomm.com/bundle/publicresource/80-70015-10/topics/46-performance-dashboard-qcs5430.md)