--- title: Low latency Linux for industrial embedded systems – Part I description: A low-latency Linux kernel is often the preferred solution for low-jitter, low-latency, soft real-time workloads. url: https://canonical.com/blog/industrial-embedded-systems?format=md --- 1. [Blog](https://canonical.com/blog) 2. Article --- [Edoardo Barbieri](https://canonical.com/blog/author/edoardo-barbieri "More about Edoardo Barbieri") 10 February 2022 # Low latency Linux for industrial embedded systems – Part I [Embedded](https://canonical.com/blog/tag/embedded) [Industrial](https://canonical.com/blog/tag/industrial) [IoT](https://canonical.com/blog/tag/iot) [kernel](https://canonical.com/blog/tag/kernel) [Linux](https://canonical.com/blog/tag/linux) --- Share the article Welcome to this mini blog series on the low latency Linux kernel for industrial embedded systems! The real-time patch, which is [not fully upstream yet](https://www.youtube.com/watch?t=14444&v=cZUzc0U1jJ4&feature=youtu.be&ab_channel=LinuxPlumbersConference), has had many developers wonder about stable alternatives for their projects adopting an embedded Linux **operating system (OS)** with latency requirements in the milliseconds’ range. The [low-latency Ubuntu Linux kernel](https://packages.ubuntu.com/search?suite=all&searchon=all&keywords=lowlatency) from [Canonical](https://canonical.com/) is less costly to maintain than real-time alternatives. **PREEMPT\_RT** is an intrusive patchset that may not be compatible with all required drivers and may require debugging/reworking, whereas low latency is a configuration flavour of mainline. The [low latency Ubuntu kernel](https://packages.ubuntu.com/search?suite=all&searchon=all&keywords=lowlatency) has the maximum preemption currently available in mainline (**PREEMPT**), coupled with four times the timer granularity of the generic Ubuntu kernel (**HZ\_1000** for low latency vs **HZ\_250** for generic). If this sentence is crystal-clear to you and if you are familiar with the concepts, you may want to [jump ahead](https://ubuntu.com/blog/industrial-embedded-systems-ii) to the remaining two blogs of his three-part blog series. Part I of the series is for those at the beginning of their learning journey. Here, we will provide a basic introduction to preemptable processes in multiuser systems, and memory segregation into kernel and user space. Building on this knowledge, we will tackle preemption and frequency of the timer interrupt in [Part II](https://ubuntu.com/blog/industrial-embedded-systems-ii). Finally, [Part III](https://ubuntu.com/blog/industrial-embedded-systems-iii) of this three-part blog series will put everything together and delve into the considerations behind adopting [low-latency Ubuntu](https://packages.ubuntu.com/search?suite=all&searchon=all&keywords=lowlatency) for your embedded applications. We have a lot to cover, so let’s get started. ## Industrial embedded systems While executing, the programs of an industrial embedded system contend for resources like the **central processing unit (CPU)**. Whereas some industrial [embedded systems](https://ubuntu.com/blog/what-is-embedded-linux) comprise high-end **CPUs** and large memory footprints, many are resource-constrained and have low-powered **CPUs**. It follows having hardware-enforced protection of system resources (**CPU**, memory, I/O) is particularly relevant for industrial [embedded Linux applications](https://ubuntu.com/engage/linux-embedded-applications-webinar?utm_source=linkedin&utm_medium=social&utm_campaign=7014K000000UZiRQAW). But let’s not get ahead of ourselves and get back to the basics. The Linux kernel adopts design and architectural considerations from the Unix family of kernels. Here, we are not concerned with the internals of Unix but need to mention some of its features for a proper understanding of the [low-latency Ubuntu kernel](https://packages.ubuntu.com/search?suite=all&searchon=all&keywords=lowlatency). Unix is a multiuser system with preemptable processes enforcing hardware protection of system resources. As such, several processes, or instances of a program in execution, can occur concurrently and contend for those resources, the **CPU** being one of them. The processes of a multiuser system must be preemptable in that the operating system tracks how long each of those holds the **CPU** and periodically activates the scheduler. On the other hand, only one process uses the **CPU** on uniprocessor systems, with only one execution flow progressing at a time. Programs in Unix kernels execute in two states: the **User Mode** and the **Kernel Mode**. ## Kernel space vs user space As system memory in Linux segregates into kernel space and user space, it follows the **CPU** of an [embedded Linux OS](https://ubuntu.com/core/docs#:~:text=Ubuntu%20Core%20is%20a%20version,for%20IoT%20and%20embedded%20systems.&text=Snap%20packages%20are%20used%20exclusively,maintain%2C%20and%20easy%20to%20upgrade.) can run in either User Mode or Kernel Mode. The **CPU** cannot directly access the kernel extensions and data structures when application software executes in userland (or user space) because of hierarchical protection domains (also referred to as rings). The access-protected kernel space is the memory area reserved for executing the [core of the OS](https://kernel.ubuntu.com/~kernel-ppa/mainline/) (Ring 0 on the x86 architecture), whereas user space is the system memory, where user processes execute (Ring 3 in Linux x86 protection rings lingo). A program usually executes in the User Mode in userland and activates a kernel routine only when requesting one of its services. Once the [Linux kernel](https://ubuntu.com/kernel) has serviced the request, it then resumes execution in the user address space. Processes switch to Kernel Mode when, e.g., issuing system calls or due to devices invoking an interrupt signal. At the time of Linux 1.x, when an instance of a program issued a system call requiring to switch to the kernel address space, no other task could be scheduled to execute until the kernel serviced the original request. Why was that the case? Because [Linux introduced kernel preemption only with version 2.5.4](https://cdn.kernel.org/pub/linux/kernel/v2.5/ChangeLog-2.5.4). Preemption plays a central role in the latency-throughput tradeoff. When vendors consider adopting a real-time **OS** they have already assessed latency is more important than throughput. On the other hand, the [low-latency Ubuntu Linux kernel](https://packages.ubuntu.com/search?suite=all&searchon=all&keywords=lowlatency) enables a well-balanced solution reducing overhead while maintaining responsiveness. By shipping a preemptable kernel, Linux enabled higher-priority processes to force interrupt lower-priority ones already executing in kernel space, despite their requests not being serviced yet. What are the preemption models available in the Linux kernel? And which config option does the [low latency Ubuntu kernel](https://packages.ubuntu.com/search?suite=all&searchon=all&keywords=lowlatency) adopt? Dive straight into [Part II](https://ubuntu.com/blog/industrial-embedded-systems-ii) of this mini-series to find out! ## Conclusion The [low-latency Ubuntu Linux kernel](https://packages.ubuntu.com/search?suite=all&searchon=all&keywords=lowlatency) efficiently services most real-world low-latency, low-jitter workloads, achieved via the maximum preemption available in mainline coupled with a rate of the timer interrupt handler higher than in a generic kernel. The meaning of these concepts will be better understood in the next part of this three-part blog series. In this part, we aimed at a quick introductory overview on the processes of a multiuser system and memory segregation into kernel and user space. [Part II](https://ubuntu.com/blog/industrial-embedded-systems-ii) of the series will address preemption in Linux and the timer interrupt frequency of the low latency Ubuntu kernel. [See you there](https://ubuntu.com/blog/industrial-embedded-systems-ii)! #### Are you evaluating the low latency Ubuntu Linux kernel for your system? [Get in touch](https://ubuntu.com/core/contact-us) ## Further reading Why is Linux the OS of choice for embedded systems? Find out with the ultimate [guide to Linux for embedded applications](https://ubuntu.com/engage/linux-embedded-applications-webinar). Interested in a detailed comparison of Yocto and Ubuntu Core? Watch the [Yocto or Ubuntu Core for your embedded Linux project?](https://ubuntu.com/engage/embedded-linux-project-webinar) webinar. ## Sign up for our newsletter Get the latest Canonical news and updates in your inbox. Work email: \*I agree to receive information about Canonical's products and services. By submitting this form, I confirm that I have read and agree to [Canonical's Privacy Policy](https://canonical.com/legal/dataprivacy). Sign up ## Share on --- ## Related posts [### Arduino® VENTUNO™ Q is available for pre-order with Ubuntu pre-installed](https://canonical.com/blog/arduino-ventuno-q-is-available-for-pre-order-with-ubuntu-pre-installed) London, UK – August 25, 2026 – Following our initial collaboration announcement in March 2026, Canonical and Arduino (a subsidiary of Qualcomm Technologies, Inc.) are excited... [Canonical](https://canonical.com/blog/author/canonical) 25 August 2026 [### Advantech AOM-2721 is now Ubuntu Certified](https://canonical.com/blog/advantech-aom-2721-ubuntu-certified) Canonical announces that the Advantech AOM-2721 is officially joining the list of Ubuntu Certified Hardware. [Mikhail Khazov](https://canonical.com/blog/author/khazov-m) 13 August 2026 [### So you need to add microcontrollers to your fleet: now what?](https://canonical.com/blog/microcontrollers-ubuntu-core-golioth) Your Ubuntu Core fleet is running beautifully. OTA updates roll out in minutes. Every device is strictly confined, cryptographically attested, and carrying a 10 to 15 year long... [Jonathan Beri](https://canonical.com/blog/author/jmberi) 18 June 2026 [### A look into Ubuntu Core 26: Building a local AI inference appliance in a virtual machine](https://canonical.com/blog/ubuntu-core-26-ai-box) Welcome to this blog series which explores innovative uses of Ubuntu Core. Throughout this series, Canonical’s Engineers will show what you can build with this Core 26 release,... [Gabriel Aguiar Noury](https://canonical.com/blog/author/g-aguiar-noury) 16 June 2026