Multi-stream inference scaling on EXEC-Q911 (IQ-9075) across video resolutions

This topic describes a multi-stream inference benchmark on the EXEC-Q911 at 720p, 1080p, 2K, and 4K. The purpose is to observe how many channels the platform sustains in real time at each resolution, and what limits it as the channel count increases. The results are not intended to be a general hardware performance ranking.

• Application: iQS-QVADK v3.0.0 (GStreamer hardware decode → inference → drawing → compositor display)
• Task: object detection with an INT8 model
• Input: 720p, 1080p, 2K, and 4K, 30 FPS H.264 video streams
• Platform: EXEC-Q911 (Qualcomm Dragonwing IQ-9075), BSP v2.5.0
• Metrics:
  • Output average end-to-end FPS per channel
  • Average CPU loading (%)
  • Average CPU memory usage (%)
  • System power (W) and FPS per watt

Hardware

AI model

Videos

The four videos were made from one licensed stock video from Envato, and they are not distributed with iQ-Studio. To reproduce the results, license a video and prepare your own copies at each resolution.

The four videos have almost the same bitrate, so only the resolution differs. This bitrate is higher than a typical 720p to 2K camera stream (about 2–8 Mbps), so the results show the load at equal bitrate and may not match a real camera deployment.

Results

Measurement summary

Each channel count was run once for 300 seconds with a 180-second warm-up. CPU and memory are averages over the 120 seconds after warm-up. Power is a single reading of the whole board at the power adapter.

FPS/Watt = (FPS per channel ÷ power) × channels. 4K stops at 8 channels (decoder limit). For channel counts that are not listed, see Known issues.

• The FPS plot (left) shows every resolution holding about 30 FPS per channel at low channel counts, then dropping once the CPU saturates: from 6 channels at 4K, 12 channels at 2K, and 16 channels at 1080p. 720p still holds 30 FPS at 16 channels.
• The CPU loading plot (middle) shows the FPS drop lining up with CPU loading reaching about 95–99%. NPU utilization stayed below about 50% in every test (for example 4K 8 channels about 14%, 720p 16 channels about 48%), so the CPU, not the NPU, is the bottleneck.
• The CPU memory plot (right) shows memory usage rising with channel count but staying moderate. It is the system-wide RAM usage, not NPU memory.

Conclusion

On EXEC-Q911 with this workload, near real-time FPS per channel is sustained up to 16 channels at 720p, 12 channels at 1080p, 9 channels at 2K, and 4 channels at 4K. Beyond that, the CPU saturates and per-channel FPS drops. Lower resolutions allow more channels, but the limit is not set by pixel count alone.

Notes

• Uptime: when the CPU is saturated, results get slower the longer the board has been up (about 11–20% lower after two hours, for example 1080p 16 channels: 22–24 FPS shortly after boot, about 19 FPS after two hours). Runs that are not CPU-limited are not affected. The cause is unknown, so record the uptime when comparing results.
• Boards: 4K and 2K were measured on one board and 720p and 1080p on another of the same model. Board-to-board variation was not measured.
• Single run: each point was run once, and power is a manual reading, so small differences are not meaningful.

Known issues

The following issues were observed with iQS-QVADK v3.0.0 on BSP v2.5.0.

• 720p at 24 and 32 channels and 1080p at 32 channels cannot run (NPU graph memory allocation fails).
• 1080p at 24 channels and 2K at 16 channels fail intermittently.
• streampipe crashes once at the end of each run, after the report is printed. The results are not affected.

These issues are under investigation and will be re-tested after fixes.

How to Use

Below is an overview of how we conduct this benchmark on EXEC-Q911. The application runs in a Docker container.

1. 1
   Install iQ-Studio

   {{ cb1.fname }} bash

   The iQS-QVADK Docker image is not included in the BSP. Pull it first:

   {{ cb2.fname }} bash

2. 2
   From the repository root on EXEC-Q911, change to the benchmark directory:

   {{ cb3.fname }} bash

   You should see config.json in this directory:

   {{ cb4.fname }} text

   config.json is the config used in the next step. iqs-launcher shares the current directory with the container as /workspace, so the application reads it as /workspace/config.json. The default config runs 1 channel of the 1080p demo video in the image, so you can run the next step as it is. To change the video, the model, or the channel count, see How to change the config.

3. 3
   Run the benchmark for 300 seconds with a 180-second warm-up. Start it from an SSH session, because programs started from adb or system services are limited to CPU cores 0–3, which lowers the results:

   {{ cb5.fname }} bash

   The application prints the inference time and FPS report when it stops.

4. 4
   Open a second SSH session. When the application has been running for 180 seconds, measure CPU and memory for 120 seconds. Run this from the directory where you ran git clone:

   {{ cb6.fname }} bash

5. 5
   (Optional) Around 250 seconds, read the power meter. The platform's power adapter is plugged into a digital power meter (DDSC-728), so the meter shows the power of the whole system.

How to change the config

Open config.json in benchmarks/iq-9075/multi-stream/iqs-qvadk-scaling/ and edit it:

• Video: the default source_path is videos/adb/ppe/road.mp4, the 1080p demo video in the image. To use your own video, first copy the file to the benchmarks/iq-9075/multi-stream/iqs-qvadk-scaling/ directory on the platform. For example, run this on your PC:
  {{ cb8.fname }} bash

  Then set source_path to /workspace/<file name>, for example /workspace/01_720.mp4. /workspace is the benchmarks/iq-9075/multi-stream/iqs-qvadk-scaling/ directory as seen from inside the container, so the file must be in that directory. Also change width and height (Resolution in the figure) to the resolution of the video:

  Resolution	width	height
  720p	1280	720
  1080p (default)	1920	1080
  2K	2560	1440
  4K	3840	2160

• Model: the default yolo_model (Model in the figure) is models/tflite/yolo26n_ppe_v73_int8.tflite, which is in the image. To use your own model, copy the file to the benchmarks/iq-9075/multi-stream/iqs-qvadk-scaling/ directory on the platform in the same way, and set yolo_model to /workspace/<file name>.
• Channel count: the streams array has 1 entry (the { ... } block in the figure), which is 1 channel. Copy the whole block and paste it after itself, separated by a comma, until the array has the channel count you want to test (for example 4, 8, or 16 entries). Every channel uses the same video.