CS452 - Real-Time Programming - Fall 2009

Lecture 26 - Pathologies

Reminders

• Train tracking 1: new deadline
• Train tracking 1: demos

Pathologies

1. Deadlock

2. Livelock (Deadly Embrace)

3. Critical Races

Example

1. Two tasks, A & B, at the same priority
2. A is doing a lot of debugging IO
3. B always reserves a section of track before A, and all is fine.
4. Debugging IO is removed
5. A reserves the section before B can get it, and execution collapses.
6. Lower priority of A to the same level as C.
7. Now C executes more slowly, and D gets a different resource before C .
8. You shuffle priorities forever, eventually reverting to leave in the debugging IO.

Symptoms

1. Small changes in priorities change execution unpredictably, and drastically.
2. Debugging output changes execution drastically.
3. Changes in train speeds change execution drastically.
   • Example from two terms ago

`Drastically' means chaos in both senses of the term

1. Sense one: a small change in the initial conditions produces an exponentially growing change in the system
2. Sense two: exercise for the reader.

Solutions

1. Explicit synchronization
   • but you then have to know the orders in which things are permitted to occur
2. Gating is a technique of global synchronization
   • which can be provided by a detective/coordinator

4. Performance

The hardest problem to solve

• You just don't know what is possible
• Ask a question like:
  • Is my kernel code at the limit of what is possible in terms of performance?

Priority

The hardest thing to get right

• Sizing stacks used to be harder, but now we have lots of memory
  • But last term, ...
• NP-hard for the human brain
• Practical method starts with all priorities the same, then adjusts
• symptoms of good priority assignment
  • The higher priority, the more likely the ready queue is to be empty
  • The shorter the run time in practice the higher the priority

Problems with priority

1. Priority inversion
2. One resource, many clients
3. Tasks try to do too much

Congestion

1. Too many tasks
   • blocked tasks don't count,
   • lowest priority tasks almost don't count

Layered abstraction are costly

e.g. Notifier -> SerialServer -> InputAccumulater -> Parser -> TrackServer

Hardware

1. Turn on optimization, but be careful
   • There are places where you have done register allocation by hand
2. Turn on caches
   • locking is possible
3. Size & align calibration tables by size & alignment of cache lines
   • linker command script
   • I think that this is stretching it.

Return to:

• Bill Cowan's CS452 lecture note page for Fall 2009
• Bill Cowan's Fall 2009 CS452 page
• Bill Cowan's CS452 page
• Bill Cowan's teaching page
• Bill Cowan's home page