fio: Flexible I/O Tester for QNX

Introduction to fio

fio (Flexible I/O tester) is the industry-standard tool for storage performance benchmarking and stress testing. Created by Jens Axboe (Linux kernel block layer maintainer), fio provides sophisticated I/O workload simulation capabilities that go far beyond simple sequential read/write tests.

Originally supporting Linux and other Unix-like systems, fio has become essential for:

Storage Performance Validation: Characterizing SSD, HDD, and NVMe performance
Filesystem Benchmarking: Testing different filesystem implementations
Hardware Verification: Stress testing storage controllers and devices
Performance Regression Testing: Automated testing in CI/CD pipelines

Why Port fio to QNX?

QNX Neutrino RTOS is widely used in automotive, industrial, and medical systems where storage performance is critical. However, the ecosystem lacks robust benchmarking tools comparable to what Linux offers. Porting fio to QNX provides:

Standardized Benchmarking: Compare QNX storage performance against Linux and other platforms using the same tool

Advanced Test Scenarios: fio supports complex I/O patterns (random, sequential, mixed), queue depths, and multiple threads

Automotive Validation: Critical for automotive storage systems where performance requirements are stringent (e.g., ADAS data logging, infotainment storage)

Development Efficiency: Engineers familiar with fio from Linux can use the same workflows on QNX

Supported Operating Systems

The fio codebase originally supported cross-compilation for:

Linux - Primary development platform
Android - Mobile and embedded testing
AIX - IBM’s Unix variant
OpenBSD / NetBSD - BSD variants
FreeBSD - FreeBSD systems
SunOS / Solaris - Oracle’s Unix
CYGWIN - POSIX layer on Windows

With my contribution, QNX Neutrino RTOS is now officially supported.

Porting Challenges

Adapting fio to QNX required addressing several platform-specific differences:

1. Thread and Process Management

QNX uses POSIX threads but with subtle differences in scheduling and priority management:

// QNX-specific thread priority handling
struct sched_param param;
param.sched_priority = priority;
pthread_setschedparam(pthread_self(), SCHED_RR, &param);

2. Memory Management

QNX’s memory management differs from Linux, particularly regarding:

mmap() behavior and flags
Shared memory semantics
Memory locking for real-time performance

3. I/O Subsystem Differences

AIO (Asynchronous I/O): QNX implements POSIX AIO differently than Linux’s io_uring or libaio

Direct I/O: The O_DIRECT flag behaves differently; QNX requires careful alignment

Resource Managers: QNX’s unique resource manager architecture affects device access patterns

4. System Calls and APIs

Several Linux-specific system calls needed QNX equivalents:

Timer interfaces
System statistics gathering
CPU affinity settings
Clock sources for high-precision timing

5. Build System Integration

Integrating QNX’s build environment (qcc compiler, QNX-specific libraries) with fio’s existing configure/make infrastructure required:

# QNX-specific build configuration
./configure --build-static --cc=qcc --extra-cflags="-Vgcc_ntox86_64" \
    --disable-native --disable-optimizations

Implementation Details

My patch adds QNX support through:

OS Detection: Extended the configure script to detect QNX Neutrino

QNX-Specific Code Paths: Added conditional compilation for QNX-specific implementations

Engine Adaptations: Modified I/O engines to work with QNX’s resource managers

Timer Accuracy: Implemented high-resolution timing using QNX’s ClockCycles() API

View the complete implementation in my GitHub branch.

Building fio for QNX

Prerequisites

QNX Software Development Platform (SDP) 7.0 or later
QNX target configured (x86_64 or AArch64)
Cross-compilation environment set up

Build Steps

# Source QNX environment
source ~/qnx700/qnxsdp-env.sh

# Clone the repository
git clone -b 3.37_for_qnx https://github.com/huangweiliang/fio_for_qnx.git
cd fio_for_qnx

# Configure for QNX
./configure --build-static --cc=qcc \
    --extra-cflags="-Vgcc_ntoaarch64le" \
    --disable-native

# Build
make -j$(nproc)

# Transfer to QNX target
scp fio qnxuser@target:/usr/local/bin/

Example Workloads on QNX

Sequential Read Test

fio --name=seq-read --ioengine=sync --rw=read --bs=1M \
    --size=1G --numjobs=1 --filename=/dev/hd0t77

Random Write with Multiple Threads

fio --name=rand-write --ioengine=psync --rw=randwrite \
    --bs=4k --size=512M --numjobs=4 --filename=/fs/test.dat

Mixed Read/Write Workload

fio --name=mixed-rw --ioengine=psync --rw=randrw \
    --rwmixread=70 --bs=4k --size=1G --numjobs=2 \
    --filename=/fs/mixed.dat

Real-World Applications in Automotive

In automotive QNX systems, fio helps validate:

ADAS Data Logging: Ensuring storage can sustain 100+ MB/s write rates for camera and sensor data

Boot Time Optimization: Measuring filesystem read performance during system startup

Flash Endurance Testing: Long-running stress tests to validate eMMC/UFS reliability

Performance Regression: Automated testing before software releases

Performance Considerations

When using fio on QNX:

Real-Time Priority: Run fio with appropriate priority to avoid interference from other processes

Memory Locking: Use --mem-type=mlock to prevent page faults during testing

Direct I/O: Test both buffered and direct I/O to understand caching effects

Resource Manager Overhead: Account for QNX resource manager overhead in results

Future Enhancements

Potential improvements for the QNX port:

Support for QNX-specific block device features
Integration with QNX’s filesystem statistics
Support for io_uring-like async I/O mechanisms if QNX adds them
Better integration with QNX’s adaptive partitioning scheduler

Conclusion

Bringing fio to QNX provides the embedded systems community with a powerful, standardized tool for storage performance validation. Whether you’re developing automotive systems, industrial controllers, or medical devices, fio enables rigorous performance testing that matches industry best practices.

The port demonstrates that with careful adaptation, tools from the broader Linux ecosystem can enhance the QNX development experience while maintaining the real-time guarantees and reliability QNX is known for.

Resources

Here is patch from my branch to support the QNX OS.

Porting fio (Flexible I/O Tester) to QNX RTOS

Bringing Industry-Standard Storage Benchmarking to QNX