Profile the Linux kernel with Arm Streamline
Introduction
Profile Linux kernel modules with Arm Streamline
Set up your environment
Build the out-of-tree kernel module
Profile the out-of-tree kernel module
Integrate a custom character device driver into the Linux kernel
Profile the in-tree kernel driver
Use Streamline with the Statistical Profiling Extension
Summary
Next Steps

  Log an issue

  Fork and edit

  Discuss on Discord

About this Learning Path

Skill level:  Advanced
Reading time:  1 hr
Last updated:  14 Aug 2026
Skill level:
  Advanced
Reading time:
  1 hr
Last updated:
  14 Aug 2026
Author:Yahya Abouelseoud, Arm
Arm IP:Cortex-A
Tags: Performance and Architecture Linux Arm Streamline Arm Performance Studio Linux kernel Performance analysis
Author:
  • Yahya Abouelseoud, Arm
Arm IP:
Cortex-A
Tags:
Performance and Architecture Linux Arm Streamline Arm Performance Studio Linux kernel Performance analysis

Who is this for?

This is an advanced topic for developers and performance engineers interested in profiling Linux kernel performance.

What will you learn?

Upon completion of this Learning Path, you will be able to:

  • Understand why profiling Linux kernel modules is important for performance and stability
  • Set up and use Arm Streamline to profile the Linux kernel
  • Profile both out-of-tree and in-tree kernel modules on Arm-based systems
  • Analyze profiling data to find and address performance bottlenecks
  • Use the Statistical Profiling Extension (SPE) for deeper kernel profiling insights

Prerequisites

Before starting, you will need the following:

  • Basic understanding of Linux kernel development and module programming
  • Arm-based Linux target device (such as a Raspberry Pi, BeagleBone, or similar board) with Secure Shell (SSH) access
  • A host machine that meets Buildroot system requirements

Summary

AI-assisted

This summary was drafted with an approved AI-assisted workflow and reviewed by Arm contributors before publication. Human technical review remains part of the process so the final page reflects engineering rigor, accuracy, and Arm editorial standards.

Close
?
You’ll profile Linux kernel code on an Arm-based system with Arm Streamline. First, you’ll build and exercise a cache-unfriendly out-of-tree character-device module, then inspect CPU, cycle, memory, and cache metrics. Next, you’ll profile the driver in-tree with vmlinux symbols and, on supported targets, use SPE for deeper kernel analysis.

Frequently asked questions

AI-assisted

These FAQs were drafted with an approved AI-assisted workflow and reviewed by Arm contributors before publication. Human technical review remains part of the process so the final page reflects engineering rigor, accuracy, and Arm editorial standards.

Close
?
Which file should I add in Streamline to analyze an in-tree driver?
Add the kernel’s vmlinux file in the capture settings. Doing so enables analysis of function calls, call paths, and specific kernel code sections.
How do I know Streamline is capturing my out-of-tree module?
During the workload, expect samples attributed to your module’s functions. You should also see changes in metrics such as memory access and cache misses while the device is exercised.
What result should I expect when profiling the cache‑unfriendly module?
Streamline should show sampling activity during the device operations and elevated cache‑related metrics due to the column‑major traversal. Use these indicators to locate hotspots and costly memory access patterns.
Do I need to install the Buildroot dependencies on an AArch64 host?
Yes. Run the package installation on an AArch64-based Linux system before building.
When should I enable SPE in this workflow?
Use SPE when deeper kernel profiling insights are needed beyond regular sampling. The Learning Path introduces SPE on supported targets to extend kernel execution analysis.
Next