> ## Documentation Index
> Fetch the complete documentation index at: https://dragonwingdocs-staging.qualcomm.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Performance dashboards

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

<Tabs>
  <Tab title="QCS6490">
    ## **Boot time**

    The following boot time KPIs indicate system readiness at different stages:

    * `Init/systemd process` : The time elapsed from power-on until the system's first user-space process (PID 1, typically systemd) starts executing. This includes the time taken by Firmware, Loader and Kernel+InitramFS.
    * `Camera driver init finish` :  Indicates that the camera hardware has completed initialization and is ready for use.
    * `Sysinit.target`: The time from power-on until sysinit.target is reached — the point where all essential system initialization services (file systems mounted, kernel modules loaded, basic hardware configured) have completed.

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

    | **Use case** | **UEFI** | **Uboot** |
    | - | - | - |
    | `Boot time till Init/systemd process` | 4.26 | 4.16 |
    | `Boot time till Camera driver init finish` | 7.73 | Not Available |
    | `Boot time till Sysinit.target` | 8.01 | 7.90 |

    <Note>
      **Note**

      The boot time values specified in the table are measured on Config #2. Config #1 also yielding comparable numbers with a deviation of 5%.
    </Note>

    <Note>
      A lower boot time score is better.
    </Note>

    **Config #1**
    Config #1: A fully upstream configuration that combines upstream graphics, video, camera, and audio components to build a pure upstream Linux image.

    **Config #2**
    Config #2: A configuration that uses downstream graphics, video, camera, audio, sensors, and vision components to generate a Qualcomm multimedia proprietary image.

    For more information on configurations, see [Use overlay configurations to derive image recipes](https://dragonwingdocs.qualcomm.com/archives/2.0/Key-Documents/Migration-Guide/use-overlay-configurations-to-derive-image-recipes).

    For information about the measurement procedure, see [Measure boot time](#measure-boot-time).

    ## **System benchmarks**

    This section outlines how system performance is measured using a set of standard benchmarks. The following tables list the CPU, memory, storage, and graphics benchmark scores on QCS6490.

    **Geekbench**

    | **Benchmark** | **Version** | **Benchmark score** |
    | :-: | :-: | :-: |
    | Geekbench ST | 6.5.0 | 1152 |
    | Geekbench MT | 6.5.0 | 2997 |

    **CoreMark**

    | **Benchmark** | **Score (Iterations/sec)** |
    | - | - |
    | CoreMark | 26219.192 |

    **Tiotest**

    | **Test** | **Configuration** | **Score** |
    | - | - | - |
    | Sequential read | 256 MB/thread at 512 KiB blocks (MB/second) | 497.9 |
    | Sequential write | 256 MB/thread at 512 KiB blocks (MB/second) | 949.0 |
    | Random read | 64 MB/thread at 4 KiB blocks (IOPS) | 52284 |
    | Random write | 64 MB/thread at 4 KiB blocks (IOPS) | 50752 |

    **GLmark2**

    | **Benchmark** | **Score** |
    | - | - |
    | GLmark2 | 1124 |
    | GLmark2 1920 × 1080 | 1036 |
    | GLmark2 offscreen | 496 |
    | GLmark2 offscreen 1920 × 1080 | 384 |

    **Sysbench**

    | **Benchmark** | **Score** |
    | - | - |
    | CPU total time (second) | 3.1892 |
    | Memory bandwidth (MB/second) | 4438.11 |
    | Thread total time (second) | 3.4808 |
    | Mutex total time (second) | 0.0043 |

    For information about the measurement procedure, see [Measure system benchmarks](#measure-system-benchmarks).

    <Note>
      A higher system benchmark score is better, except for CPU total time, thread total time, and Mutex total time where a lower value is better.
    </Note>

    ## **Memory map**

    The following tables list 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.

    **Config #1**

    | **Memory partitions** | **After boot** |
    | - | - |
    | Total RAM | 6144 |
    | Non-Linux | 594 |
    | Kernel static | 152 |
    | Applications + framework | 513 |
    | Total free memory | 4884 |

    **Config #2**

    | **Memory partitions** | **After boot** |
    | - | - |
    | Total RAM | 6144 |
    | Non-Linux | 594 |
    | Kernel static | 153 |
    | Applications + framework | 563 |
    | Total free memory | 4834 |

    For information about the measurement procedure, see [Measure memory map](#measure-memory-map).

    <Note>
      A higher total free memory value is better for the system performance.
    </Note>

    ## **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 creating a snapshot | 0.34 |

    <Note>
      A lower camera latency value is better.
    </Note>

    For information about the measurement procedure, see [Measure camera recording and snapshot latency](#measure-camera-recording-and-snapshot-latency).
  </Tab>

  <Tab title="QCS5430">
    ## **Boot time**

    The following boot time KPIs indicate system readiness at different stages:

    * `Init/systemd process` : The time elapsed from power-on until the system's first user-space process (PID 1, typically systemd) starts executing. This includes the time taken by Firmware, Loader and Kernel+InitramFS.
    * `Camera driver init finish` :  Indicates that the camera hardware has completed initialization and is ready for use.
    * `Sysinit.target` : The time from power-on until sysinit.target is reached — the point where all essential system initialization services (file systems mounted, kernel modules loaded, basic hardware configured) have completed.

    The following table lists the measured boot time (values in seconds) on QCS5430.

    | **Use case** | **UEFI** | **Uboot** |
    | - | - | - |
    | `Boot time till Init/systemd process` | 5.98 | Not Available |
    | `Boot time till Camera driver init finish` | 9.95 | Not Available |
    | `Boot time till Sysinit.target` | 10.38 | Not Available |

    <Note>
      **Note**

      The boot time values specified in the table are measured on Config #2. Config #1 also yielding comparable numbers with a deviation of 5%.
    </Note>

    <Note>
      A lower boot time score is better.
    </Note>

    **Config #1**
    Config #1: A fully upstream configuration that combines upstream graphics, video, camera, and audio components to build a pure upstream Linux image.

    **Config #2**
    Config #2: A configuration that uses downstream graphics, video, camera, audio, sensors, and vision components to generate a Qualcomm multimedia proprietary image.

    For more information on configurations, see [Use overlay configurations to derive image recipes](https://dragonwingdocs.qualcomm.com/archives/2.0/Key-Documents/Migration-Guide/use-overlay-configurations-to-derive-image-recipes).

    For information about the measurement procedure, see [Measure boot time](#measure-boot-time).

    ## **System benchmarks**

    This section outlines how system performance is measured using a set of standard benchmarks. The following tables list the CPU, memory, storage, and graphics benchmark scores on QCS5430.

    **Geekbench**

    The following Geekbench scores are measured on QCS5430 FP1.

    | **Benchmark** | **Version** | **Benchmark score** |
    | :-: | :-: | :-: |
    | Geekbench ST | 6.1.0 | 930 |
    | Geekbench MT | 6.1.0 | 2106 |

    For information about the measurement procedure, see [Measure system benchmarks](#measure-system-benchmarks).

    <Note>
      A higher system benchmark score is better, except for CPU total time, thread total time, and Mutex total time where a lower value is better.
    </Note>

    ## **Memory map**

    The following tables list 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.

    **Config #1**

    | **Memory partitions** | **After boot** |
    | - | - |
    | Total RAM | 6144 |
    | Non-Linux | 594 |
    | Kernel static | 152 |
    | Applications + framework | 501 |
    | Total free memory | 4897 |

    **Config #2**

    | **Memory partitions** | **After boot** |
    | - | - |
    | Total RAM | 6144 |
    | Non-Linux | 594 |
    | Kernel static | 153 |
    | Applications + framework | 561 |
    | Total free memory | 4836 |

    For information about the measurement procedure, see [Measure memory map](#measure-memory-map).

    <Note>
      A higher total free memory value is better for the system performance.
    </Note>

    ## **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 [Measure camera recording and snapshot latency](#measure-camera-recording-and-snapshot-latency).
  </Tab>

  <Tab title="IQ-615">
    ## **Boot time**

    The following boot time KPIs indicate system readiness at different stages:

    * `Init/systemd process` : The time elapsed from power-on until the system's first user-space process (PID 1, typically systemd) starts executing. This includes the time taken by Firmware, Loader and Kernel+InitramFS.
    * `Camera driver init finish` :  Indicates that the camera hardware has completed initialization and is ready for use.
    * `Sysinit.target` : The time from power-on until sysinit.target is reached — the point where all essential system initialization services (file systems mounted, kernel modules loaded, basic hardware configured) have completed.

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

    | **Use case** | **UEFI** | **Uboot** |
    | - | - | - |
    | `Boot time till Init/systemd process` | 3.05 | 3.34 |
    | `Boot time till Camera driver init finish` | 5.84 | Not Available |
    | `Boot time till Sysinit.target` | 6.51 | 6.81 |

    <Note>
      **Note**

      The boot time values specified in the table are measured on Config #2. Config #1 also yielding comparable numbers with a deviation of 5%.
    </Note>

    <Note>
      A lower boot time score is better.
    </Note>

    **Config #1**
    Config #1: A fully upstream configuration that combines upstream graphics, video, camera, and audio components to build a pure upstream Linux image.

    **Config #2**
    Config #2: A configuration that uses downstream graphics, video, camera, audio, sensors, and vision components to generate a Qualcomm multimedia proprietary image.

    For more information on configurations, see [Use overlay configurations to derive image recipes](https://dragonwingdocs.qualcomm.com/archives/2.0/Key-Documents/Migration-Guide/use-overlay-configurations-to-derive-image-recipes).

    For information about the measurement procedure, see [Measure boot time](#measure-boot-time).

    ## **System benchmarks**

    This section outlines how system performance is measured using a set of standard benchmarks. The following tables list the CPU, memory, storage, and graphics benchmark scores on Dragonwing IQ-615.

    **Geekbench**

    | **Benchmark** | **Version** | **Benchmark score** |
    | :-: | :-: | :-: |
    | Geekbench ST | 6.5.0 | 636 |
    | Geekbench MT | 6.5.0 | 1602 |

    **CoreMark**

    | **Benchmark** | **Score (Iterations/sec)** |
    | - | - |
    | CoreMark | 15024.038 |

    **Tiotest**

    | **Test** | **Configuration** | **Score** |
    | - | - | - |
    | Sequential read | 256 MB/thread at 512 KiB blocks (MB/second) | 203.2 |
    | Sequential write | 256 MB/thread at 512 KiB blocks (MB/second) | 292.2 |
    | Random read | 64 MB/thread at 4 KiB blocks (IOPS) | 23429 |
    | Random write | 64 MB/thread at 4 KiB blocks (IOPS) | 11982 |

    **GLmark2**

    | **Benchmark** | **Score** |
    | - | - |
    | GLmark2 | 632 |
    | GLmark2 1920 × 1080 | 379 |
    | GLmark2 offscreen | 386 |
    | GLmark2 offscreen 1920 × 1080 | 268 |

    **Sysbench**

    | **Benchmark** | **Score** |
    | - | - |
    | CPU total time (second) | 4.7 |
    | Memory bandwidth (MB/second) | 2926.98 |
    | Thread total time (second) | 5.1491 |
    | Mutex total time (second) | 0.0144 |

    For information about the measurement procedure, see [Measure system benchmarks](#measure-system-benchmarks).

    <Note>
      A higher system benchmark score is better, except for CPU total time, thread total time, and Mutex total time where a lower value is better.
    </Note>

    ## **Memory map**

    The following tables list 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.

    **Config #1**

    | **Memory partitions** | **After boot** |
    | - | - |
    | Total RAM | 4096 |
    | Non-Linux | 367 |
    | Kernel static | 112 |
    | Applications + framework | 493 |
    | Total free memory | 3124 |

    **Config #2**

    | **Memory partitions** | **After boot** |
    | - | - |
    | Total RAM | 4096 |
    | Non-Linux | 367 |
    | Kernel static | 113 |
    | Applications + framework | 535 |
    | Total free memory | 3081 |

    For information about the measurement procedure, see [Measure memory map](#measure-memory-map).

    <Note>
      A higher total free memory value is better for the system performance.
    </Note>

    ## **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.442 |

    <Note>
      A lower camera latency value is better.
    </Note>

    For information about the measurement procedure, see [Measure camera recording and snapshot latency](#measure-camera-recording-and-snapshot-latency).
  </Tab>

  <Tab title="IQ-8275">
    ## **Boot time**

    The following boot time KPIs indicate system readiness at different stages:

    * `Init/systemd process`: The elapsed time from power-on until the system’s first user-space process (PID 1, typically systemd) begins execution. This duration includes firmware initialization, bootloader execution, and kernel plus initramfs loading.
    * `Camera driver init finish`: Indicates that the camera hardware has completed initialization and is ready for use.
    * `Sysinit.target`: The elapsed time from power-on until the system reaches sysinit.target, marking the completion of essential system initialization services, including filesystem mounting, kernel module loading, and basic hardware configuration.

    **Config #1**

    Config #1: A fully upstream configuration that combines upstream graphics, video, camera, and audio components to build a pure upstream Linux image.

    **Config #2**

    Config #2: A configuration that uses downstream graphics, video, camera, audio, sensors, and vision components to generate a Qualcomm multimedia proprietary image.

    For more information on configurations, see [Use overlay configurations to derive image recipes](https://dragonwingdocs.qualcomm.com/archives/2.0/Key-Documents/Migration-Guide/use-overlay-configurations-to-derive-image-recipes).

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

    | **Use case** | **UEFI** | **Uboot** |
    | :-: | :-: | :-: |
    | Boot time till `Init/systemd process` | 6.55\* | 3.76 |
    | Boot time till `Camera driver init finish` | 9.63\* | Not Available |
    | Boot time till `Sysinit.target` | 9.70\* | 6.91 |

    \* The boot KPI impact is seen due to the implementation of workaround for ARM errata CVE-2025-10263. See [ARM errata CVE-2025-10263](https://support.arm.com/documentation/112137/1-0/) for more details.

    <Note>
      **Note**

      The boot time values specified in the table are measured on Config #2. Config #1 also yielding comparable numbers with a deviation of 5%.
    </Note>

    <Note>
      **Note**

      A lower boot time score is better.
    </Note>

    For information about the measurement procedure, see [Measure boot time](System/Performance/Addendum-iq8275/Performance-dashboard#measure-boot-time).

    ## **System benchmarks**

    This section outlines how system performance is measured using a set of standard benchmarks. The results provide insight into processing efficiency, floating-point capability, memory behavior, and system handling of threads and processes.

    **Geekbench**

    | **Benchmark** | **Version** | **Benchmark score** |
    | :-: | :-: | :-: |
    | Geekbench ST | 6.5.0 | 1037 |
    | Geekbench MT | 6.5.0 | 3194 |

    **CoreMark**

    | **Benchmark** | **Version** | **Benchmark score** |
    | :-: | :-: | :-: |
    | CoreMark | Not applicable | 22836.264 |

    **Tiotest**

    | **Test** | **Configuration** | **Score** |
    | - | - | - |
    | Sequential read | 256 MB/thread at 512 KiB blocks (MB/second) | 331.7 |
    | Sequential write | 256 MB/thread at 512 KiB blocks (MB/second) | 1394.7 |
    | Random read | 64 MB/thread at 4 KiB blocks (IOPS) | 38066 |
    | Random write | 64 MB/thread at 4 KiB blocks (IOPS) | 48973 |

    **GLmark2**

    | **Benchmark** | **Score** |
    | - | - |
    | GLmark2 | 612 |
    | GLmark2 1920 × 1080 | 448 |
    | GLmark2 offscreen | 368 |
    | GLmark2 offscreen 1920 × 1080 | 295 |

    **Sysbench**

    | **Benchmark** | **Score** |
    | - | - |
    | CPU total time (s) (Lower is better) | 3.6595 |
    | Memory transfer rate (MB/s) (Higher is better) | 3955.46 |
    | Thread total time (s) (Lower is better) | 3.9773 |
    | Mutex total time (s) (Lower is better) | 0.0048 |

    ## **Memory map**

    The following tables list 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.

    **Config #1**

    | **Memory partitions** | **After boot** |
    | - | - |
    | Total RAM | 12288 |
    | Non-Linux | 835 |
    | Kernel static | 270 |
    | Applications + framework | 600 |
    | Total free memory | 10583 |

    **Config #2**

    | **Memory partitions** | **After boot** |
    | - | - |
    | Total RAM | 12288 |
    | Non-Linux | 835 |
    | Kernel static | 270 |
    | Applications + framework | 590 |
    | Total free memory | 10592 |

    For information about the measurement procedure, see [Measure memory map](System/Performance/Addendum-iq8275/Performance-dashboard#measure-memory-map).

    <Note>
      A higher total free memory value is better for the system performance.
    </Note>
  </Tab>

  <Tab title="IQ-9075">
    ## **Boot time**

    The following boot time KPIs indicate system readiness at different stages:

    * `Init/systemd process`: The elapsed time from power-on until the system’s first user-space process (PID 1, typically systemd) begins execution. This duration includes firmware initialization, bootloader execution, and kernel plus initramfs loading.
    * `Camera driver init finish`: Indicates that the camera hardware has completed initialization and is ready for use.
    * `Sysinit.target`: The elapsed time from power-on until the system reaches sysinit.target, marking the completion of essential system initialization services, including filesystem mounting, kernel module loading, and basic hardware configuration.

    **Config #1**

    Config #1: A fully upstream configuration that combines upstream graphics, video, camera, and audio components to build a pure upstream Linux image.

    **Config #2**

    Config #2: A configuration that uses downstream graphics, video, camera, audio, sensors, and vision components to generate a Qualcomm multimedia proprietary image.

    For more information on configurations, see [Use overlay configurations to derive image recipes](https://dragonwingdocs.qualcomm.com/archives/2.0/Key-Documents/Migration-Guide/use-overlay-configurations-to-derive-image-recipes).

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

    | **Use case** | **UEFI** | **Uboot** |
    | :-: | :-: | :-: |
    | Boot time till `Init/systemd process` | 3.43 | 3.06 |
    | Boot time till `Camera driver init finish` | 6.19 | Not Available |
    | Boot time till `Sysinit.target` | 5.88 | 5.51 |

    <Note>
      **Note**

      The boot time values specified in the table are measured on Config #2. Config #1 also yielding comparable numbers with a deviation of 5%.
    </Note>

    <Note>
      Note

      A lower boot time score is better.

      For information about the measurement procedure, see [Measure boot time](System/Performance/Addendum-iq9075/Performance-dashboard#measure-boot-time).
    </Note>

    ## **System benchmarks**

    This section outlines how system performance is measured using a set of standard benchmarks. The results provide insight into processing efficiency, floating-point capability, memory behavior, and system handling of threads and processes.

    **Geekbench**

    | **Benchmark** | **Version** | **Benchmark score** |
    | :-: | :-: | :-: |
    | Geekbench ST | 6.5.0 | 1139 |
    | Geekbench MT | 6.5.0 | 5878 |

    <Note>
      Note

      A higher system benchmark score is better.
    </Note>

    **CoreMark**

    | **Benchmark** | **Version** | **Benchmark score** |
    | :-: | :-: | :-: |
    | CoreMark | Not applicable | 22832.788 |

    **Tiotest**

    | **Test** | **Configuration** | **Score** |
    | - | - | - |
    | Sequential read | 256 MB/thread at 512 KiB blocks (MB/second) | 434.5 |
    | Sequential write | 256 MB/thread at 512 KiB blocks (MB/second) | 1401.9 |
    | Random read | 64 MB/thread at 4 KiB blocks (IOPS) | 66829 |
    | Random write | 64 MB/thread at 4 KiB blocks (IOPS) | 78674 |

    **GLmark2**

    | **Benchmark** | **Score** |
    | - | - |
    | GLmark2 | 2847 |
    | GLmark2 1920 × 1080 | 2464 |
    | GLmark2 offscreen | 2602 |
    | GLmark2 offscreen 1920 × 1080 | 712 |

    **Sysbench**

    | **Benchmark** | **Score** |
    | - | - |
    | CPU total time (s) (Lower is better) | 3.6559 |
    | Memory transfer rate (MB/s) (Higher is better) | 3914.28 |
    | Thread total time (s) (Lower is better) | 4.2239 |
    | Mutex total time (s) (Lower is better) | 0.0037 |

    **UnixBench**

    | **Benchmark** | **Score** |
    | - | - |
    | UnixBench ST | 1101 |
    | UnixBench MT | 7564.8 |

    For information about the measurement procedure, see [Measure system benchmarks](#measure-system-benchmarks).

    ## **Memory map**

    The following tables list 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.

    **Config #1**

    | **Memory partitions** | **After boot** |
    | - | - |
    | Total RAM | 36864 |
    | Non-Linux | 2219 |
    | Kernel static | 749 |
    | Applications + framework | 1057 |
    | Total free memory | 32838 |

    **Config #2**

    | **Memory partitions** | **After boot** |
    | - | - |
    | Total RAM | 36864 |
    | Non-Linux | 2219 |
    | Kernel static | 750 |
    | Applications + framework | 974 |
    | Total free memory | 32922 |

    For information about the measurement procedure, see [Measure memory map](System/Performance/Addendum-iq9075/Performance-dashboard#measure-memory-map).

    <Note>
      A higher total free memory value is better for the system performance.
    </Note>
  </Tab>

  <Tab title="CQ2390">
    ## **Boot time**

    The following boot time KPIs indicate system readiness at different stages:

    * `Init/systemd process`: The elapsed time from power-on until the system’s first user-space process (PID 1, typically systemd) begins execution. This duration includes firmware initialization, bootloader execution, and kernel plus initramfs loading.
    * `Sysinit.target`: The elapsed time from power-on until the system reaches sysinit.target, marking the completion of essential system initialization services, including filesystem mounting, kernel module loading, and basic hardware configuration.

    **Config #1**

    Config #1: A fully upstream configuration that combines upstream graphics, video, camera, and audio components to build a pure upstream Linux image.

    **Config #2**

    Config #2: A configuration that uses downstream graphics, video, camera, audio, sensors, and vision components to generate a Qualcomm multimedia proprietary image.

    For more information on configurations, see [Use overlay configurations to derive image recipes](https://dragonwingdocs.qualcomm.com/archives/2.0/Key-Documents/Migration-Guide/use-overlay-configurations-to-derive-image-recipes).

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

    | **Use case** | **UEFI** | **Uboot** |
    | :-: | :-: | :-: |
    | Boot time till `Init/systemd process` | 6.07 | 5.61 |
    | Boot time till `Sysinit.target` | 15.39 | 14.93 |

    <Note>
      **Note**

      The boot time values specified in the table are measured on Config #2. Config #1 also yielding comparable numbers with a deviation of 5%.
    </Note>

    <Note>
      A lower boot time score is better.
    </Note>

    <Note>
      Camera init boot time is not available. Camera is not L0 enabled on CQ2390 currently.
    </Note>

    For information about the measurement procedure, see [Measure boot time](#measure-boot-time).

    ## **System benchmarks**

    This section outlines how system performance is measured using a set of standard benchmarks. The following tables list the CPU, memory, storage, and graphics benchmark scores on CQ2390.

    **Geekbench**

    | **Benchmark** | **Version** | **Benchmark score** |
    | :-: | :-: | :-: |
    | Geekbench ST | 6.5.0 | 684 |
    | Geekbench MT | 6.5.0 | 928 |

    **CoreMark**

    | **Benchmark** | **Score (Iterations/sec)** |
    | - | - |
    | CoreMark | 20622.809 |

    **Sysbench**

    | **Benchmark** | **Score** |
    | - | - |
    | CPU total time (s) (Lower is better) | 10.0006 |
    | Memory transfer rate (MB/s) (Higher is better) | 3204.57 |
    | Thread total time (s) (Lower is better) | 10.0006 |
    | Mutex total time (s) (Lower is better) | 0.321 |

    For information about the measurement procedure, see [Measure system benchmarks](#measure-system-benchmarks).

    <Note>
      A higher system benchmark score is better, except for CPU total time, thread total time, and Mutex total time where a lower value is better.
    </Note>

    ## **Memory map**

    The following tables list 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.

    **Config #1**

    | **Memory partitions** | **After boot** |
    | - | - |
    | Total RAM | 4096 |
    | Non-Linux | 560 |
    | Kernel static | 111 |
    | Applications + framework | 491 |
    | Total free memory | 2934 |

    **Config #2**

    | **Memory partitions** | **After boot** |
    | - | - |
    | Total RAM | 4096 |
    | Non-Linux | 560 |
    | Kernel static | 111 |
    | Applications + framework | 498 |
    | Total free memory | 2927 |

    For information about the measurement procedure, see [Measure memory map](#measure-memory-map).

    <Note>
      A higher total free memory value is better for the system performance.
    </Note>

    ## **Use case KPIs**

    Camera latency KPIs are not available for CQ2390. Camera is not L0 enabled on CQ2390 currently.
  </Tab>
</Tabs>

## **Measurement procedures**

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

### **Measure boot time**

To measure boot time, do the following:

1. Flash a build. See [Flash software images](https://dragonwingdocs.qualcomm.com/Key-Documents/Flash-Guide/flash-with-qdl) to boot the device.

2. After the device is up, reboot it.

3. Connect to the device console using a serial cable.

   a. Connect a serial cable between the device and the Linux host PC.

   b. Connect to the UART terminal using credentials ( user: root, password: oelinux123 ). See [Connect to a UART shell](https://dragonwingdocs.qualcomm.com/Key-Documents/Flash-Guide/how-to-trigger-edl-with-uart#connect-to-a-uart-shell).

   c. Power-off and on the device.

Boot time KPIs can be measured by capturing systemd-analyze and journalctl logs after the device boots up and stabilized.

```text theme={null}
systemd-analyze > /var/lib/systemd-analyze.txt
```

```text theme={null}
journalctl --output=short-monotonic -b --no-pager -l > /var/lib/journalctl.txt
```

```text theme={null}
grep Startup /var/lib/systemd-analyze.txt
```

Expected output:

```text theme={null}
Startup finished in 1.697s (firmware) + 402ms (loader) + 1.693s (kernel) + 15.887s (userspace) = 19.681s 
```

```text theme={null}
grep "camera driver initialized rc : 0" var/lib/journalctl.txt
```

Expected output:

```text theme={null}
[    4.220245] iq-615-evk kernel: CAM_INFO: CAM-UTIL: cam_main_probe: 336: Spectra camera driver initialized rc : 0
```

```text theme={null}
grep "Reached target System Initialization." /var/lib/journalctl.txt
```

Expected output:

```text theme={null}
[    4.757850] iq-615-evk systemd[1]: Reached target System Initialization.
```

```text theme={null}
Boot time till Init/systemd process = Firmware + Loader + Kernel = 1.697 + 0.402 + 1.693 = __3.892s__ 
```

```text theme={null}
Boot time till Camera driver init finish =  Firmware + Loader + journalctl timestamp of "camera driver initialized" = 1.697 + 0.402 + 4.220 = __6.319s__
```

```text theme={null}
Boot time till Sysinit.target = Firmware + Loader + journalctl timestamp of "Reached target System Initialization" = 1.697 + 0.402 + 4.757 = __6.856s__
```

<Note>
  The Firmware and Loader times are taken from systemd-analyze output (1.697s + 0.402s). The kernel timestamps in journalctl are relative to kernel start, so Firmware + Loader time is added to get the absolute boot time from power-on.
</Note>

### **Measure system benchmarks**

These benchmarks measure the performance of subsystems such as CPU throughput, memory bandwidth, memory latency, and I/O performance.

**Prerequisites**

Before running any benchmark, complete the following setup:

<Note>
  ADB isn't enabled by default on the device. To enable ADB before running these benchmarks, see [Enable ADB](./troubleshoot-performance-issues#build-procrank-from-source-code).
</Note>

1. Flash the build.
2. Run the following command to get root access:
   ```text theme={null}
   adb root
   ```
3. Open a shell on the device:
   ```text theme={null}
   adb shell
   ```
4. Navigate to the directory where the binary is pushed:
   ```text theme={null}
   cd /usr/bin
   ```
5. Set execute permissions on the binary:
   ```text theme={null}
   chmod 777 <binary>
   ```

**Geekbench**

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.
</Note>

2. To measure a CPU benchmark using Geekbench, do the following:
   1. Unzip the Geekbench file and push it to the device from the host using ADB or SCP. The following are example commands:

      **Using ADB:**

      ```text theme={null}
      adb push Geekbench-6.3.0-LinuxARMPreview /var/cache/
      ```

      **Using SCP:**

      ```text theme={null}
      scp -r Geekbench-6.3.0-LinuxARMPreview root@<device-ip>:/var/cache/
      ```

      ```text theme={null}
      cd /var/cache
      ```

      ```text theme={null}
      chmod 777 Geekbench-6.3.0-LinuxARMPreview/*
      ```
   2. To run Geekbench, run the following commands on the device:
      ```text theme={null}
      cd Geekbench-6.3.0-LinuxARMPreview
      ```
      ```text theme={null}
      ./geekbench_aarch64
      ```

**Sysbench**

Sysbench measures CPU, memory, thread, mutex, and file I/O performance.

To run Sysbench tests, run the following commands on the device:

```text theme={null}
./sysbench --test=cpu run
./sysbench --test=memory run
./sysbench --test=threads run
./sysbench --test=mutex run
./sysbench --test=fileio --file-test-mode=seqwr run
./sysbench --test=fileio --file-test-mode=seqrd run
./sysbench --test=fileio --file-test-mode=rndrd run
./sysbench --test=fileio --file-test-mode=rndwr run
```

To run with taskset:

```text theme={null}
taskset <taskset> ./sysbench --test=<test_name> run
```

**Tiotest**

Tiotest measures storage I/O performance.

To run Tiotest, do the following:

1. Run the sequential I/O test:
   ```text theme={null}
   /data/tio/tiotest -t 8 -d /data/tio -f 256 -b 524288 -k3 -k1 --direct-io sync=1
   ```
2. Run the random I/O test:
   ```text theme={null}
   /data/tio/tiotest -t 8 -d /data/tio -f 64 -b 4096 -k2 -k0 2012 -r 12500 20 --direct-io sync=1
   ```
3. Drop the cache between iterations:
   ```text theme={null}
   echo 3 > /proc/sys/vm/drop_caches
   ```

**CoreMark**

CoreMark measures embedded processor performance.

To run CoreMark, run the following command on the device:

```text theme={null}
./coremark.exe
```

The following is an example output:

```text theme={null}
2K performance run parameters for coremark.
CoreMark Size    : 666
Total ticks      : 15268
Total time (secs): 15.268000
Iterations/Sec   : 26198.585276
Iterations       : 400000
Compiler version : GCC11.4.0
Compiler flags   : -O2 -DPERFORMANCE_RUN=1  -lrt
seedcrc          : 0xe9f5
[0]crclist       : 0xe714
[0]crcmatrix     : 0x1fd7
[0]crcstate      : 0x8e3a
[0]crcfinal      : 0x65c5
```

**Glmark2**

Glmark2 measures GPU rendering and graphics performance.

To run Glmark2, do the following:

1. Configure the Wayland runtime environment:

```text theme={null}
export XDG_RUNTIME_DIR=/dev/socket/weston
mkdir --parents $XDG_RUNTIME_DIR
chmod 0700 $XDG_RUNTIME_DIR
export WAYLAND_DISPLAY=wayland-1
```

2. Run the off-screen test at default resolution:

```text theme={null}
./glmark2-es2-wayland --off-screen --data-path /usr/share/glmark2
```

3. Run the off-screen test at 1920x1080 resolution:

```text theme={null}
./glmark2-es2-wayland --off-screen -s 1920x1080 --data-path /usr/share/glmark2
```

4. Run the on-screen test at default resolution:

```text theme={null}
./glmark2-es2-wayland --data-path /usr/share/glmark2
```

5. Run the on-screen test at 1920x1080 resolution:

```text theme={null}
./glmark2-es2-wayland -s 1920x1080 --data-path /usr/share/glmark2
```

### **Measure memory map**

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:

```text theme={null}
cat /proc/meminfo
```

```text theme={null}
cat /proc/iomem
```

```text theme={null}
cat /proc/vmstat
```

**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:

```text theme={null}
cat /proc/meminfo | grep -i "MemTotal"
```

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

```text theme={null}
cat /proc/iomem | grep System
```

**Kernel static**

Use the following formula to calculate the kernel static:

Kernel static = Total Linux − MemTotal

**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:

```text theme={null}
cat /proc/meminfo
```

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

```text theme={null}
cat /proc/vmstat
```

### **Measure camera recording and snapshot latency**

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

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

```text theme={null}
mount -t debugfs none /sys/kernel/debug
```

```text theme={null}
setprop persist.qmmf.kpi.debug 2
```

**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:
   ```text theme={null}
   cat /sys/kernel/debug/tracing/trace_pipe > trace.log
   ```
3. In another shell, run the use case.
4. Stop the trace log.
5. See the [reference table](#reference-table-for-measurement) below to measure the record latency.

**First snapshot latency**

1. Boot the device.
2. After the device stabilizes, in one shell, run the following command:
   ```text theme={null}
   cat /sys/kernel/debug/tracing/trace_pipe > trace.log
   ```
3. In another shell, run the use case.
4. Stop the trace log.
5. See the [reference table](#reference-table-for-measurement) below to measure snapshot latency.

<a id="reference-table-for-measurement" />

**Reference table for measurement**

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