Lectures

Lecture 1 - Real-time systems: characteristics and design methods

In this lecture, we describe the general construction methods used for the design of real-time systems. A three-stage design flow is introduced that encompasses specification, implementation, and verification. For the specification stage, we present application constraints particular to real-time systems, and discuss their origin and implications. For the implementation stage, we discuss critical design choices to be made. For the verification stage, we discuss the pros and cons of ad hoc testing and formal analysis (schedulability analysis).

Slides

Reading

• Chapter 1.1, 1.2 and 1.3 in the course book
• John Stankovic, Misconceptions About Real-Time Computing - A Serious Problem for Next-Generation Systems [PDF]

Lecture 2 - Real-time systems: programming paradigms

In this lecture, we identify the desired properties of a real-time programming language and show to what extent these properties exist in contemporary imperative languages. We then discuss the pros and cons of a concurrent/parallel programming paradigm and show how contemporary imperative languages offer support for this paradigm. Finally, using an example control application, we show that correct application behavior can only be achieved by means of concurrent programming and synchronization.

Slides

Reading

• Chapter 1.4 and 1.5 in the course book

Lecture 3 - The TinyTimber kernel

In this lecture, we give an overview of the philosophy behind the TinyTimber kernel, and also give a short history of how the kernel developed from its big brother, the Timber language, and its predecessor O'Haskell.

Slides

Reading

• Johan Nordlander, Programming with the TinyTimber kernel [PDF]

Lecture 4 - Concurrent programming: problems and solutions

In this lecture, we introduce the general resource management problem, and highlight the deadlock, starvation and mutual exclusion issues. We then take a closer look at the mutual exclusion property and show how different imperative languages and run-time systems offer support for mutual exclusion. Techniques that will be described are protected objects, monitors, semaphores and mutex methods.

Slides

Reading

• Chapter 3 in the course book

Lecture 5 - Concurrent programming: problems and solutions (cont'd)

In this lecture, we first demonstrate why mutual exclusion matters using an example involving a circular buffer. We then describe how mutual exclusion is achieved with support from the processor hardware. Finally, we highlight the need for call-back functionality in real-time programming, and give examples in the context of TinyTimber.

Slides

Reading

• Chapter 2 in the course book
• Johan Nordlander, Programming with the TinyTimber kernel [PDF]

Lecture 6 - Concurrent programming: guaranteeing timeliness

In this lecture, we show the mechanisms that are used in Ada95 and TinyTimber to provide clocks, time, delays and task priorities. We also discuss the priority/deadline inversion problem and discuss different methods for avoiding/reducing the problem.

Slides

Reading

• Chapter 5.1, 5.2 and 5.3.1 in the course book
• Johan Nordlander, Programming with the TinyTimber kernel [PDF]

Lecture 7 - Task model; Worst-case execution time

In this lecture, we introduce abstract models for the run-time system and the tasks as a means for the formal verification of the timing correctness of the system. We also give an overview of the problem of deriving worst-case execution times for the code executed by a task.

Slides

Reading

• Chapter 5.3 in the course book

Lecture 8 - Real-time network communication

In this lecture, we give an introduction to network communication mechanisms that are used in the design of real-time systems. In particular, we take a closer look at the CAN protocol.

Slides

Reading

• Chapter 7 in the course book

Lecture 9 - Scheduling: terminology, cyclic executives

In this lecture, we introduce some basic terminology relating to scheduling and schedulability analysis. We also describe the mechanisms used in static scheduling (cyclic executives).

Slides

Reading

• Chapter 6.1, 6.2 and 6.3 in the course book

Lecture 10 - Scheduling: static and dynamic priorities, utilization-based analysis

In this lecture, we introduce dynamic scheduling using priorities according to the rate-monotonic and earliest-deadline-first policies. In addition, we describe how to check schedulability of a set of tasks using processor-utilization analysis.

Slides

Reading

• Chapter 6.4.1 and 6.5.1 (except second half of page 129) in the course book

Lecture 11 - Scheduling: response-time analysis

In this lecture, we introduce the deadline-monotonic scheduling policy. In addition, we describe how to check schedulability of a set of tasks using response-time analysis.

Slides

Reading

• Chapter 6.4.2 – 6.4.7 in the course book

Lecture 12 - Scheduling: processor-demand analysis

In this lecture, we describe how to check schedulability of a set of tasks using processor-demand analysis.

Slides

Reading

• Lecture notes only. (Ignore second half of page 129 in the course book.)

Lecture 13 - Scheduling: multiprocessor systems

In this lecture, we introduce the two main approaches to multiprocessor scheduling: partitioned scheduling and global scheduing. We also describe the fundamental problems in finding good priority assignment policies and schedulability tests for multiprocessor real-time systems. Finally, we present the RM-US scheduling policy, which represents a state-of-the-art technique for global real-time multiprocessor scheduling.

Slides

Reading

• Lecture notes only.

Lecture 14 - Summary and reading hints

In this lecture, we summarize the contents of the course and give preparation hints for the written exam.

Slides