I plan to build a kernel that supports real-time programs over multiple cores. The kernel will implement several scheduling algorithms and aim for benchmarks in utilization and energy cost.


Embedded systems are computer components inside a vast array of electronic systems that impact our lives in common and crucial circumstances, making the monitoring and control of systems more simple with software rather than just hardware. From household appliances and gadgets to medical devices and factory machines to automobiles, airplanes, missiles, and space shuttles, anything using sensors and control mechanisms today probably makes use of an embedded system.


Many of these embedded systems are also real-time systems, which track the passage of real time as a component independent from the code run by the systems, then use the time measurements to control the system. A barometer may need to consistently measure air pressure every 500 milliseconds or a pacemaker may need to deliver shocks to someone’s heart at a precise rhythm; thus they use real-time embedded systems. To ensure that these tasks are completed at regular real-time intervals, rather than whenever it would be convenient for the computer, a real-time system uses a real-time scheduler, a software component which controls the execution of several program threads to ensure that they each consistently complete their task within a given period.


This paradigm has allowed single processors to execute multiple tasks concurrently; by tracking the statuses of many concurrent tasks, the computer system can switch between tasks, working on only one at any given time, but performing all of them in the long term. While embedded systems can achieve concurrency with just one processor core, though, this leaves out potential for much greater throughput via parallelism over multiple cores. While several scheduler schemes I’ve studied, such as rate monotonic scheduling, guarantee whether a single processor can schedule task sets, the process of assigning tasks to cores makes real-time systems with multiple processors more difficult to analyze. Despite this added complexity, by executing tasks on multiple processors, some real-time systems can operate at much higher throughput.


The Challenge
  • Implement a kernel to manage programs on multiple cores

  • Construct tests that stretch scheduling limits on utilization and task assignment between cores

  • Implement scheduling algorithms that can meet higher-end tests



Last semester, I took a course in Embedded Real Time Systems. One of my projects in that course was a single-core real-time kernel, which implemented a real-time system manager that parallelized tasks over multiple threads. I plan to expand on that project to create the kernel for this research, using other knowledge gained from the class like power-saving scheduling and (briefly-covered) topics in multicore real-time systems. This kernel was tested on a Raspberry Pi with a breakout board - I still have that breakout board, and I plan to use it with another Raspberry Pi, this time using all 4 of its cores.


Goals and Deliverables



Platform Choice

Raspberry Pi - lightweight computer that can approximate smaller embedded systems, yet has multiple cores

C and assembly (ARM) - for optimal interrupt handling, control over data structures and primitives



April 23 - Set up toolbench, enable use of multiple cores

April 30 - All scheduling algorithms implemented

May 6 - Testing and Tuning


I was unable to work on this project in the first two weeks. To cut back accordingly, I am choosing to not aim for energy efficiency unless time permits at the end. For the presentation at the end, I should at least have a table of which scheduling algorithms meet which tests.