An Exception Based Approach to Timing Constraints Violations in Real-Time and Multimedia Applications

SIES 2010
July 9th, Trento, Italy

An Exception Based Approach to
Timing Constraints Violations in
Real-Time and Multimedia Applications

Tommaso Cucinotta, Dario Faggioli
Real-Time Systems Laboratory
Scuola Superiore Sant'Anna
Pisa, Italy

Tommaso Cucinotta – ReTiS Lab – Scuola Superiore Sant'Anna – Pisa – Italy 1/29

Summary

Table of Contents
 Introduction and motivation

 Proposed solution

 Experimental results

 Future work


Introduction and motivation


Introduction

Traditional (hard) real-time development
 Violations of timing constraints not deemed as acceptable
 would cause complete system failure, or life losses
 Use of proper methodologies
 WCET estimation
 static code analysis
 use of a Hard Real-Time OS
 conservative admission control and schedulability tests
 Common verifiable assumptions
 No task will run for more than its declared WCET
– Similar for blocking times, critical section lengths, …
 All jobs of all tasks will respect their deadlines


Introduction

Soft real-time development
 Timing violations:
 might occur at run-time
– WCET based on benchmarks, but run-time conditions may be different
– Use of a General-Purpose OS (for real-time, distributed, embedded apps)
– Very complex software infrastructures preclude possibility of analysis
– Resource sharing and synchronisation not exactly how modelled
 they are foreseen by the programs and compensated
– e.g., in multimedia, frame skipping
– e.g., in control applications, feedback loops adjusting the
Quality of Control depending on the dynamic requirements of
applications or controller, or on availability of resources at run-time
 lead to QoS degradation


Problem presentation

How to deal with timing constraints violations ?
 Common paradigms
 Continue computations till the end, then compensate
 Abort current computations (e.g., killing the faulty thread)
 Triggering recovery logic (e.g., notify faulty thread by signal)
 A mix of these techniques
 Custom application-level logic
Timing constraints violations
 Expected to happen quite rarely, under proper design
 Code development should
 mainly focus on “normal” path of execution
 foresee proper recovery logic
– also in case of timing constraints violations

Sample scenario

Periodic task
Deadline constraint
 On overall task activation
WCET constraint
Component-based design
 Leverage WCET estimations
at the subcomponent level
 Multiple timing constraints in
place at the same time
 Violations may occur at
different levels


Sample scenario

Periodic task
Deadline constraint
WCET constraint
different levels


Proposed solution


Our proposal

We propose
 To use the well-known exception-handling paradigm
 For dealing with timing constraints violations
 Confining the recovery logic in proper exception handlers
Example (pseudo-C)
Acquire
Acquire
try (within 10 ms) {
AcquireImage(); PreProcess
Acquire Deadline
PreProcess
Acquire Expired
PreProcessImage();
ComputePosition();
ComputePos
ComputePos Interpolate
Interpolate
} catch (EDeadline) {
InterpolatePosition();
} …
…

Problems with
Exception Handling
Exception handling
 Common paradigm in dealing with occasional faults
 Focus on main error-free path
 Clearly delineate code sections dealing with error
conditions occurring rarely
 Widely used in high-level languages (e.g., Java, C++)
 Absent from the C language
 One of the most widely used language for embedded applications


Our proposal

Use a library for exceptions in C
 Originally written by Alessandro Evangelista
 Embedded within the Open Macro Library (OML) project
 http://oml.sourceforge.net
 Provides macro-oriented reusable functionality
OML was extended with new macros
 Timing constraints coded as special try blocks
 Violations coded as special types of exception
 Violation recovery logic coded as OML exception handler


Background on OML

Objectives of OML
 Explore extensive use of C macros for providing generic
(template-like) reusable utilities
 logging and debugging
 collections (vector, list, queue, hash table, map, heap)
 synchronisation
 exceptions
 etc.
 Exploit standard C macro constructs plus commonly used
extensions (e.g., variadic macros)
 Extensible exceptions hierarchy


OML Exceptions Example

Example Declare a new type of
exception extending the
base EException type
#include <oml_exceptions/oml_exceptions.h>
define_exception(ENotReady)
extends(EException);
Begin of a try block
try {
Begin of handlers list
f();
} handle Handler for specific
when (ENotReady) { ENotReady exception
printf("Not Ready Exception !n");
}
when (EException) {
printf("General Exception !n"); Handler for generic type of
} exception
end;
End of handlers list and of
try block


Extensions to OML
New exception types exception
exception
 exception
 ex_time_constr_violation ex_time_constr_violation
ex_time_constr_violation
– ex_deadline_violation
– ex_wcet_violation
ex_deadline_violation
ex_deadline_violation ex_wcet_violation
ex_wcet_violation
New macros
 Begin a deadline-constrained block
 try_within_abs(deadline_ts)
 try_within_rel(deadline_ts)
 Begin a WCET-constrained block
 try_within_wcet
 Atomic blocks, non-interruptible by asynchronous exceptions
 try_within_disable
 try_within_enable


Implementation details

Mechanism builds on standard POSIX calls
 Timer management
 Signal handling
 setjmp/longjmp
Implementation
 try() blocks
 perform a setjmp()
 post of signal delivery in the future
– Deadline: use CLOCK_MONOTONIC
– WCET: use CLOCK_THREAD_CPUTIME_ID
 signal handler performs a longjmp()
 handle … when() blocks
 properly coded if() walking up the exceptions hierarchy

Benchmarking mode

Painful question
 How to properly set-up WCET and/or deadlines, at first
executions of the application ?
Solution
 Benchmarking mode
 may be enabled at compile-time defining a symbol
 try() blocks do not enforce any timing constraint, but they
actually log the absolute time and thread execution time


Devil is in the details

Troublesome issues
 On Linux
 Absolute-time timers fire with a high precision, thanks to the
high-resolution timers now built into the kernel
– Deadline constraint violation notified with low latencies ~ 1 usec.
 Per-thread timers fire at HZ boundaries (simplifying)
– WCET violation notified with latencies largely influenced by HZ
use high HZ=1000 for highest precision ~ 400 usec.
 Future work: make WCET violations precise
 No per-thread signal delivery system call in POSIX
 Additional signal-specific thread required → higher overhead
 Linux has a specific extension allowing thread-level signal
delivery → lower overhead
(its use may be enabled at compile-time)
 Nesting-based matching of exceptions with handlers

Case study
mplayer on Linux


Case study

Proposed technique applied to
 Frame dropping in the popular mplayer for Linux
mplayer original heuristic
 Keep the A/V delay under control, ideally below 100 ms
 Drop as few frames as possible; avoid bursts of drops
 The drop/no-drop decision is taken in advance, so the
preventive decision might have been mistaken
 If decoded, the dropped frame might not have exhibited a so high
decoding time
 A decoded frame might exhibit a far higher computation time
than expected, leading to large A/V de-synchronisations


Modified mplayer-dlex

Reworked exception-based heuristic
 Use a try_within_rel() block around decoder
 Set decoding deadline to:
 current audio-frame pts + maximum tolerable A/V delay
 Whenever decoder takes too much, it is aborted
Pay attention
 We never drop key frames


Experimental results

Unloaded system: similar A/V delay and InterFrame Times


Experimental results

Loaded system: -30% avg(A/V delay); -10% max(A/V delay);


Conclusions and Future Work


Conclusions

We proposed
 An exception-based management of timing constraints
 For embedded real-time applications
We provided
 A full implementation of the framework in form of an
open-source library of macros for the C language
 Implementation relies on POSIX timers, signals and longjmp()
We validated the approach
 Modifying mplayer, an open-source multimedia player
 We measured deadline miss rates and inter-frame times
under various load conditions
Experimental results show that
 The more the system is loaded, the more the benefits

Future Work

Mechanism level
 Improving exception handling latency for WCET violation
 Requires to post additional timers into the kernel (working on it)
 Improving exception-handling syntax
 It might be made more C friendly
– causing more meaningful error messages on incorrect use of macros
Application level
 Experiment with applying the technique to other scenarios
 Control applications
 Anytime computing algorithms


Related Work

Asynchronous Transfer of Control (ATC)
 Present in common programming languages, e.g. Ada, Java, C

Deadline instruction concept (hardware extension)
 B. Lickly, I. Liu, S. Kim, H. D. Patel, S. A. Edwards, E. A. Lee
Predictable programming on a precision timed architecture
CASES 2008, Atlanta, Georgia, US, October 2008, pp. 137–146
Contribution of the paper
 To provide a framework for the C language, built on top of POSIX,
allowing for handling arbitrarily nestable time-constraints
violations as exceptions
Preliminary paper of ours on the topic
 Cucinotta, T., Faggioli, D., Evangelista, A.
Exception-Based Management of Timing Constraints Violations
for Soft Real-Time Applications
OSPERT 2009, Dublin, Ireland, June 2009

Thanks for your attention!

Questions ?


An Exception Based Approach to Timing Constraints Violations in Real-Time and Multimedia Applications

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (6)

Similar a An Exception Based Approach to Timing Constraints Violations in Real-Time and Multimedia Applications

Similar a An Exception Based Approach to Timing Constraints Violations in Real-Time and Multimedia Applications (20)

Último

Último (20)

An Exception Based Approach to Timing Constraints Violations in Real-Time and Multimedia Applications