"Debugging Real-Time Software"
* An Advanced Course for Experienced Real-Time Embedded Software Developers and Quality Engineers
* How to Identify and Correct Defects in Real-Time Software Systems
* 2 or 3 Day Intensive Class (lectures, discussions, example debugging scenarios, classroom exercises)
This course examines the activities involved in discovering and correcting errors, flaws, faults and failures in real-time
and embedded systems software.
The class begins with a presentation of the main steps and guidelines for identifying and remedying situations in
which real-time and embedded software is not working correctly. This is followed by a survey of the wide range of
categories of bugs from which such software can suffer . The class then quickly focuses in on a detailed discussion
of the "top 5" kinds of bugs that can be "project killers" or "product killers", including stack overflows, race conditions,
deadlocks, timing problems, and re-entrancy conditions . Emphasis is placed on multitasking and timing behaviors,
rather than on general data processing issues.
The class continues with an examination of debugging tools that are helpful in real-time software development, such
as low-level monitors, and high-level RTOS-aware system debuggers. 'Liveness' issues including deadly embrace,
lockout, memory starvation and CPU starvation are discussed in depth. As are the particular sorts of bugs that tend to
create problems in multi-tasking software when using real-time operating systems. Emphasis then focuses on the
unique sorts of bugs that plague Interrupt Service Routines ("ISRs"), such as interrupt overflow.
This course is not a general course about software debugging, but rather it is highly focused on the debugging of
embedded, time-constrained, resource-constrained multitasking software that may run under the control of a modern
real-time operating system ("RTOS").
WHO SHOULD ATTEND ?
This course is intended for practicing real-time and embedded systems software designers, software developers,
project managers and quality engineers who have responsibility for planning, implementing and debugging the
software for real-time and embedded computer systems.
Course participants are expected to have practical knowledge of coding for real-time and embedded systems, plus
some familiarity with at least one RTOS. [This knowledge can also be gained by attending one of our prerequisite
introductory courses "Introduction to Embedded Systems and Software" or "Introduction to Real-Time Operating
The primary goal of this course is to give the participant the skills necessary to identify and correct defects in software
for real-time computer systems developed with or without an RTOS. This is a very practical, results-oriented course
that will provide knowledge and skills that can be applied immediately.
RECOMMENDED PREREQUISITE COURSE
Additional knowledge useful for attendees of this course can be obtained at the prerequisite foundation course
"Testing of Embedded Software". [Both courses can be combined in a 3-day format named "Embedded Software
Testing and Debugging Masterclass".]
What is a Bug ?
The Debugging "Cookbook"
9 Golden Guidelines for Debugging
A Taxonomy of Real-Time / Embedded Bugs
Exercise: Bugs when Porting to New Hardware
David's "Top 5" Real-Time Bugs
Real-Time Debugging Tools and their Limitations
Where Traditional Debugging Techniques are Insufficient
The Correctness Killers: Violations of Liveness
Deadlock: 4 Ingredients, and 8 'Fixes'
Task Lockouts and Starvations
The 3 Classes of Real-Time Software Debuggers
Modern Features of Source Level Debuggers
Cutting Edge Debuggers: Time-Reversal, SensorPoints
Exercise: Bug in a Real-Time Controller
Mindsets for Debugging Real-Time Software
Cause and Effect: The Scientific Method
Assertions and Invariants
Memory Allocation/De-allocation Bugs
Proactive Debugging Techniques
Bugs in Multi-tasking and ISRs: The Mis-use of RTOS's
Task Decomposition and Communication Defects
Multi-tasking Debugging Techniques
Interrupt Service Routine Design Defects
RTOS Usage Defects
Exercise: Bug in Interrupt Handling
Programming Bugs in Real-Time Software
C-Language Ambiguities and Coding Disciplines
C-Language Code Analysis and Tools
Static vs. Dynamic Code Analysis
Exercise: C-Language Shenanigans
Update on Static Code Analysis
The JPL "Power of 10" Coding Rules
Metrics Predict Bugs
Exercise: Cyclomatic Complexity
Hard Real-Time Performance Bugs and Calculations
Bugs in Multi-Core and Symmetric Multi-Processing Software
INSTRUCTOR: Dr. David Kalinsky
|© Copyright 2011, D. Kalinsky Associates, All Rights Reserved.
This page Updated March 19, 2011