---

Introduction

Hello Everyone! 🌟 In this post, I'll take you through a deep dive into the world of real-time systems by benchmarking semaphore operations and analyzing system latency on a Raspberry Pi 4 using the PREEMPT_RT kernel. Whether you're a real-time systems enthusiast or just curious about how your Raspberry Pi can handle time-critical tasks, this project is designed to give you insights into the performance of semaphore signaling, waiting times, and system latencies under stress conditions.

We'll cover everything from setting up the environment, running the benchmarks, analyzing the results, and visualizing system latencies. Ready to explore the intricacies of real-time Linux? Let's get started!

Prerequisites 🛠️

Before jumping into the benchmarking process, make sure you have the following:

• Raspberry Pi 4: Running a Linux distribution with PREEMPT_RT support.

• C Compiler: GCC or Clang to compile the C programs.

• Python 3.x: Required for running the latency plotting script.

• Matplotlib: A Python library for creating static, animated, and interactive visualizations. Install it using pip:

pip install matplotlib pandas

With these tools in hand, you'll be able to set up your environment and run the benchmarks efficiently.

---

Developments 🚀

Semaphore Benchmarking 🧩

In this project, we focus on two main C programs:

1. Semaphore Operations Benchmarking

The first part of our project benchmarks semaphore operations. The C program (sem.c) is designed to measure the time taken for semaphore signaling and acquisition between two tasks with different priorities.

• Sender: Signals the semaphore and records the time taken.

• Receiver: Waits on the semaphore and computes the time statistics.

This benchmark gives us valuable insights into how quickly the system can handle semaphore operations, which are critical in real-time environments where tasks need to coordinate efficiently.

2. Semaphore Processing with Workloads

The second C program (sem_processing.c) extends the benchmarking by introducing additional workloads during semaphore operations. This allows us to measure how these extra processing tasks affect the semaphore's signaling and acquisition times.

• Impact of Workloads: By simulating real-world processing tasks, we can better understand the overhead introduced by semaphore operations under load.

Latency Analysis with cyclictest 📊

To complement the semaphore benchmarking, we also analyze system latency using cyclictest, a tool that measures how quickly a real-time system can respond to timer events.

Generating cyclictest Output

Run cyclictest on the Raspberry Pi 4 with your desired parameters and save the output to a file:

cyclictest -l100000 -m -n -S99 -p99 -q > cyclictest_output.txt

This command measures the latency of the system over 100,000 iterations, giving us a comprehensive view of how the system performs under stress.

Plotting Latency Data

To visualize the latency data, we use a Python script (cyclictestplotgraph.py) that parses the cyclictest output and generates latency plots. These plots help us understand the behavior of user space, kernel space, and IRQ latencies over time.

python cyclictestplotgraph.py

The script will display a graph showing latencies across different system components, providing a clear visual representation of the system's real-time performance.

Database Configuration 🗄️

Although not a traditional database setup, the benchmarking and latency data collected through this project can be considered analogous to database records. Here's how data is managed:

• Semaphore Benchmarking Results: Stored in arrays and processed in real-time during the execution of the C programs.

• Latency Data: Parsed and stored in dataframes using pandas for easy manipulation and visualization.

---

Outcome and Insights ✨

After running the benchmarks and analyzing the results, you'll have a solid understanding of how your Raspberry Pi 4 performs under real-time conditions. The semaphore benchmarking reveals the time overhead introduced by these operations, while the latency analysis highlights the system's responsiveness under load.

This project serves as a valuable resource for anyone looking to optimize their real-time Linux systems, particularly in environments where timing and synchronization are critical.

Thanks for following along on this journey into real-time system performance on the Raspberry Pi 4! 🎉 Whether you're working on an industrial application, a research project, or just exploring the capabilities of your Pi, these benchmarks and analyses provide key insights into the system's behavior under stress.

Feel free to explore the GitHub repository for the full code and additional details. Happy benchmarking! 🚀

As always, here is the image dump of my tests!!!