Software Engineering for Real-Time Systems (The Complete Edition)

Cover
FM
Copyright
Table of Contents
Preface
Chapter 1: Real-Time Systems – Setting the Scene
	1.1 Categorizing Computer Systems
	1.2 Real-Time Computer Systems
		1.2.1 Time and Criticality Issues
		1.2.2 Real-Time System Structures
		1.2.3 Characteristics of Embedded Systems
	1.3 The Computing Elements of Real-Time Systems
		1.3.1 Overview
		1.3.2 General-Purpose Microprocessors
		1.3.3 Highly Integrated Microprocessors
		1.3.4 Single-Chip Microcomputers
		1.3.5 Single-Chip Microcontrollers
		1.3.6 Digital Signal Processors
		1.3.7 Mixed-Signal Processors
		1.3.8 System-On-Chip Designs – Overview
		1.3.9 Programmable SOCs – FPGA-Embedded Processors
		1.3.10 SOC Devices – Single and Multicore
	1.4 Software for Real-Time Applications – Some General Comments
	1.5 Review
	1.6 Useful Reading Material
Chapter 2: The Search for Dependable Software
	2.1 What Do We Want in Our Software?
	2.2 Software Errors
		2.2.1 Overview
		2.2.2 System Design Errors
		2.2.3 Design and Coding Errors
		2.2.4 Environmental Factors
		2.2.5 Why Do We Get Poor Software?
		2.2.6 Testing – How Useful?
	2.3 The Basics of Good Software
		2.3.1 General
		2.3.2 Specification Correctness
		2.3.3 Feasibility and Suitability
		2.3.4 Modularization
		2.3.5 Portability and Reusability
		2.3.6 Error Avoidance and Defensive Programming – Robust Programs
		2.3.7 Design Codes of Practice – Style, Clarity, and Documentation
	2.4 A Final Comment
	2.5 Review
	2.6 References
Chapter 3: First Steps – Requirements Analysis and Specification
	3.1 The Software Life Cycle
		3.1.1 Introduction
		3.1.2 A Mythical Model of the Software Life Cycle
		3.1.3 Bringing Realism to the Life Cycle
		3.1.4 Requirements Issues – a Practical Approach
	3.2 The Importance of the Requirements Stage
	3.3 Making Mistakes – Sources and Causes
		3.3.1 A General Comment
		3.3.2 Problems in Formulating Specifications
		3.3.3 Problems in Communicating Requirements
		3.3.4 Problems in Understanding Requirements
	3.4 Practical Approaches to Analysis and Specification
		3.4.1 General Aspects
		3.4.2 Tool Support and Automation
		3.4.3 Viewpoint Analysis
		3.4.4 Viewpoints – Analysis versus Specification
		3.4.5 Use Case Analysis
		3.4.6 Functional, Non-Functional, and Development Requirements Specifications
	3.5 Communication Aspects – the Role of Prototyping
		3.5.1 Prototyping – an Introduction
		3.5.2 Software Prototyping
		3.5.3 Requirements Prototyping
		3.5.4 Practical Rapid Prototyping of System Requirements
		3.5.5 Animation Prototyping – Concepts and Application
	3.6 Review
	3.7 Exercises
	3.8 References and Further Reading
Chapter 4: Software and Program Design Concepts
	4.1 Design Fundamentals
		4.1.1 The Design and Development Process – an Introduction
		4.1.2 Fundamental Design Strategies
		4.1.3 How to Generate Abysmal Software – the Good Kludge Guide
	4.2 The Elements of Modular Design
		4.2.1 Introduction
		4.2.2 Modules and Modularization
		4.2.3 Coupling – a Measure of Module Independence
		4.2.4 Cohesion – a Measure of Module Binding
		4.2.5 Size and Complexity
		4.2.6 Some General Comments on Modules
	4.3 Program Control Structures – the Influence of Structured Programming
		4.3.1 Introductory Comments
		4.3.2 Fundamental Control Structures
		4.3.3 Uncontrolled Branching of Control – the Great GOTO Debate
	4.4 Structured Software Designs
		4.4.1 Background
		4.4.2 Problem Decomposition Using Abstract Machines
		4.4.3 Example Implementation
	4.5 Object-Oriented Design
		4.5.1 An Introduction
		4.5.2 Object-Oriented Design – the Identification Process
		4.5.3 Relationships and Communication between Objects
		4.5.4 Object Interfaces
		4.5.5 Object-Oriented Design – Implementation-Related Issues
		4.5.6 Reuse and Runtime Flexibility Issues
		4.5.7 Composite Objects – Aggregation
		4.5.8 Devising the Object Model – a Responsibility-Based Technique
	4.6 Functionally Structured Design and Functional Flow Modeling
		4.6.1 Software Design and Structured Charts – Limitations
		4.6.2 The Materials Flow Model of Software Processing
		4.6.3 Software Design Using Functionally Structured Techniques
		4.6.4. Organizing the Execution Sequence of the Software Machines
		4.6.5 Functional Flow Design Using Graphical Techniques
	4.7 Design Patterns
		4.7.1 Introduction and Basic Concepts
		4.7.2 Program-Level Patterns
		4.7.3 System-Level Patterns for Real-Time Embedded Systems
	4.8 Review
	4.9 Exercises
	4.10 Useful Reading Material
Chapter 5: Multitasking Systems – an Introduction
	5.1 The Task Model of Software
		5.1.1 Modeling – What and Why
		5.1.2 Modeling Executing Software – the Single-Task Structure
		5.1.3 Multiple Tasks – Why?
		5.1.4 Using Interrupts to Concurrent Task Operations
		5.1.5 Introduction to the Operating System
	5.2 Controlling Task Execution – Scheduling
		5.2.1 Scheduling and Time Slicing Operations
		5.2.2 Scheduling and Priority-Driven Operations
		5.2.3 System Responsiveness and Mixed Scheduling Policies
	5.3 Sharing Resources in Multitasking Systems
		5.3.1 Problems with Sharing Resources
		5.3.2 The Binary Semaphore
		5.3.3 The General or Counting Semaphore
		5.3.4 Semaphore Weaknesses
		5.3.5 The Mutex
		5.3.6 The Simple Monitor
	5.4 Contention Problems in Multitasking Systems
		5.4.1 Resource Contention and Deadlocks
		5.4.2 The Priority Inversion Problem
		5.4.3 The Priority Ceiling Protocol
	5.5 Inter-task Communication
		5.5.1 Introduction
		5.5.2 Task Coordination and Synchronization without Data Transfer – General Aspects
		5.5.3 Task Interaction without Data Transfer
		5.5.4 Data Transfer without Task Synchronization or Coordination
		5.5.5 Task Synchronization with Data Transfer
	5.6 Review
	5.7 Background Reading Material
Chapter 6: Diagramming – an Introduction
	6.1 Diagrams – Why?
		6.1.1 Introduction
		6.1.2 Diagrams as a Design Tool
		6.1.3 Diagrams for Design Documentation
		6.1.4 Diagrams for Maintenance
		6.1.5 Diagrams for Communication
	6.2 The Essentials of Software Diagrams
		6.2.1 Fundamentals
		6.2.2 Basic Qualities
		6.2.3 Real-Time Systems Diagramming – Matching Ends to Needs
		6.2.4 Practical Diagramming Techniques – a General Comment
	6.3 Review
	6.4 Exercises
	6.5 References and Further Reading
Chapter 7: Practical Diagramming Methods
	7.1 Introduction
	7.2 Diagrams for Functionally Structured Methods
		7.2.1 Context Diagrams
		7.2.2 Entity-Relationship Diagrams (ERDs)
		7.2.3 State Transition Diagrams and State Transition Tables
		7.2.4 Functional and Data Flow Diagrams
		7.2.5 Specifying Program Structures – Structure Charts, Flowcharts, and Program Description Languages
		7.2.6 Message Sequence Diagrams
		7.2.7 SDL (Specification and Description Language) Process Diagrams
		7.2.8 Event-Response Lists
	7.3 UML Diagrams for Object-Oriented Designs
		7.3.1 Use Case Diagrams
		7.3.2 Deployment Diagrams
		7.3.3 Packages and Package Diagrams
		7.3.4 Class Diagrams
		7.3.5 Object and Object Communication Diagrams
		7.3.6 Wiring Objects Together – Ports and Interfaces
		7.3.7 Statecharts
		7.3.8 Sequence Diagrams
		7.3.9 Activity Diagrams
		7.3.10 Components and Component Diagrams
		7.3.11 Artifacts
	7.4 Extensions, Variations, and Project-Specific Diagrams
	7.5 Diagrams and the Design Process
	7.6 Review
	7.7 Exercises
	7.8 References and Further Reading
Chapter 8: Designing and Constructing Software – Code-Related Issues
	8.1 Fundamental Design and Construction Methods
		8.1.1 Introduction
		8.1.2 An Evaluation of Design and Construction Methods
	8.2 Code Development and Packaging
		8.2.1 Code Development and the Physical Software Model
		8.2.2 Software Construction Methods – General
		8.2.3 Introduction to Component Technology
		8.2.4 Code Packaging and Components
		8.2.5 Classes, Packages, and Artifacts
	8.3 Important Features of Programming Languages
		8.3.1 Introduction
		8.3.2 Choosing a Programming Language – the Real Questions
		8.3.3 High-Level Languages – General Requirements
		8.3.4 Modularity, Encapsulation, and Information Hiding
		8.3.5 Program Syntax and Layout Rules – the Readability Factor
		8.3.6 Variable Usage – Scope, Visibility, Lifetime, and Declaration.
		8.3.7 Data Types – Concepts and Uses
		8.3.8 Program Flow Control
		8.3.9 Interfacing to Other Languages
		8.3.10 Exception Handling
		8.3.11 Accessing Processor Hardware – Low-Level Facilities
		8.3.12 Assembly Language Programming
		8.3.13 Miscellaneous Items
	8.4 Choosing a High-Level Language for Embedded Systems
		8.4.1 Basic Requirements
		8.4.2 Assessed Languages – Background
		8.4.3 Assessed Languages – Comparison and Comment
		8.4.4 Python and MicroPython
	8.5 Review
	8.6 Important and Useful Reading
Chapter 9: Software Analysis and Design – Methods and Methodologies
	9.1 The Development Process
		9.1.1 General Description
		9.1.2 Methods, Methodologies, and Tools
	9.2 Viewpoint Analysis for Deriving Requirements
		9.2.1 Viewpoint Analysis and CORE
		9.2.2 CORE Fundamentals
		9.2.3 Detailed Aspects and Notation
		9.2.4 Design Example – Steam Propulsion System
		9.2.5 A Comment on Analysis Tools
	9.3. Design Implementation Using Functionally Structured Techniques
		9.3.1 Overview of the Design Process
		9.3.2 Developing the Ideal Model
		9.3.3 Developing the Practical Model
	9.4 Object-Oriented Analysis and Design
		9.4.1 Design Example – Dipmeter Wireline Logging Tool
		9.4.2 A Practical OOAD Development Process
		9.4.3 Defining System Usage
		9.4.4 Developing the Subsystem Structures
		9.4.5 Developing the Ideal Model Object Structures
		9.4.6 Developing the Specification Model Object Structures
		9.4.7 Developing the Individual Processor Object Models
		9.4.8 Developing the Multitasking Model
		9.4.9 Developing Individual Tasks
		9.4.10 Packaging the Software
	9.5 Model-Driven Architecture
		9.5.1 Fundamental Concepts
		9.5.2 The PIM in Detail
		9.5.3 Example Structural Model – from PIM to PSM to Code
		9.5.4 Closing Comments
	9.6 Model-Based Design (MBD)
		9.6.1 MBD versus MDA
		9.6.2 MBD – an Overview
		9.6.3 Applying the MBD Process – a Brief Outline
	9.7 Agile Software Development
		9.7.1 Introduction and Basic Concepts
		9.7.2 Agile Methods for Embedded Applications – the Interface Issue
		9.7.3 The Issue of Project Development Methods – Agile versus Embedded
		9.7.4 Practical Incremental Development Methods for Embedded Systems
	9.8 Review
	9.9 Further Useful Reading
Chapter 10: Analyzing and Testing Source Code
	10.1 Introduction
		10.1.1 General Concepts
		10.1.2 Software Evaluation Issues
		10.1.3 Software Testing – the Broader Issues
	10.2 Static Analysis
		10.2.1 Introduction
		10.2.2 Manual Static Analysis Methods
		10.2.3 Automated Static Analysis Methods
	10.3 Source Code Metrics – Code Size, Content, and Complexity
		10.3.1 General
		10.3.2 Halstead Software Metrics
		10.3.3 The McCabe Cyclomatic Complexity Metric
	10.4 Dynamic Analysis – Testing and Coverage Analysis
		10.4.1 Overview of Dynamic Testing
		10.4.2 Dynamic Testing in a Manual Environment
		10.4.3 Dynamic Testing in an Automated Environment
		10.4.4. Coverage Analysis
		10.4.5. Practical Automated Dynamic Analysis
	10.5 Integration Testing
		10.5.1 Fundamentals
		10.5.2 Integration and Test Strategies (1) – Combined Module and Integration Testing
		10.5.3 Integration and Test Strategies (2) – Integration Testing Based on Unit Calls
		10.5.4 Integration Complexity
	10.6 Metrics for OO Designs
		10.6.1 General Aspects
		10.6.2 Inheritance, Polymorphism, and Testing Issues
	10.7 Review
	10.8 Further Reading
Chapter 11: Development Tools
	11.1 An Outline of the Modern Development Process for Embedded Systems
	11.2 The Software Development Process for Embedded Systems
		11.2.1 The Software Production Cycle
		11.2.2 Programming the Target Microcontroller
		11.2.3 Simplifying the Process – Processor Configuration Tools
		11.2.4 Finding and Fixing Software Problems
		11.2.5 The Basics of Efficient Development Processes
	11.3 Software Debugging – What and Why?
		11.3.1 Debugging – Fundamental Concepts
		11.3.2 Debugger – Basic Requirements and Operation
		11.3.3 Development and Debugging Environments
	11.4 Software Debugging on the Host
		11.4.1 Host System Debugging – a Broad Overview
		11.4.2 The Pros and Cons of Host System Debugging
	11.5 Software Debugging on the Target – Software-Based Techniques
		11.5.1 General
		11.5.2 A Simple Monitor Program
		11.5.3 In-Target Source-Level Debugging
		11.5.4 The Last Comment
	11.6 Software Debugging in the Target – Hardware-Based Methods
		11.6.1 Introduction
		11.6.2 A Basic Test Tool – the Bus Monitor
		11.6.3 The Logic Analyzer
		11.6.4 The In-Circuit Emulator
	11.7 Software Debugging in The Target – Combined Hardware/Software Techniques
		11.7.1 Host/Target Interactive Debugging – Software Tracing
		11.7.2 On-Chip Debugging Methods – Overview
		11.7.3 Simple Static On-Chip Debugging Methods
		11.7.4 Dynamic OCD Schemes
	11.8 Debugging in Host-As-Target Combinations
		11.8.1 Background
		11.8.2 PC-Based Targets – The Embedded PC
		11.8.3 A PC as a Target
	11.9 Testing Multitasking Software
		11.9.1 Basic Issues
		11.9.2 Practical Tool Aspects
	11.10 Installing Code on the Target – Non-Volatile Software (Firmware)
		11.10.1 Overview
		11.10.2 The PROM Programmer
		11.10.3 EPROM Emulators
		11.10.4 In-Circuit Programming
	11.11 Integrated Development Toolsets
		11.11.1 Backend Toolsets
		11.11.2 Fully Integrated Real-Time Development Environments
	11.12 Review
Chapter 12: Mission-Critical and Safety-Critical Systems
	12.1 Introduction
		12.1.1 Overview of Critical Systems
		12.1.2 How Critical is Critical?
		12.1.3 Improving System Reliability and Availability – General Strategies
	12.2 System Specification Aspects
		12.2.1 The Specification Problem – Again
		12.2.2 Why Mathematics?
		12.2.3 Formal Methods – General Concepts
		12.2.4 Formal Specification Languages
		12.2.5 An Example Formal Specification Using VDM
	12.3 Numerical Issues
		12.3.1 Problems in Disguise
		12.3.2 Making Measurements
		12.3.3 Basic Number Representation and Arithmetic
		12.3.4 The Limitations of Finite Number Systems – General Points
		12.3.5 Infinite Numbers, Model Numbers, and Error Bounds
		12.3.6 Problems in Floating-Point Working
		12.3.7 Problems in Fixed-Point Working
		12.3.8 Internal Representation and Binary Notation
	12.4 Application Software Aspects
		12.4.1 Basic Design and Programming Issues (or Doing It Right in the First Place)
		12.4.2 Dealing with Runtime Problems
	12.5 Real-World Interfacing
		12.5.1 Background
		12.5.2 Fault Types and Identification – Inputs
		12.5.3 Fault Detection Methods – Inputs
		12.5.4 Fault Handling – Outputs
	12.6 Operating Systems Aspects
		12.6.1 General
		12.6.2 Protection Techniques
		12.6.3 Tasking Models and Scheduling
		12.6.4 Operating Systems and Critical Distributed Applications
	12.7 Processor Problems
		12.7.1 Overview
		12.7.2 Power-On Aspects
		12.7.3 Runtime Issues
	12.8 Hardware-Based Fault Tolerance
		12.8.1 General Aspects
		12.8.2 Fault-Tolerant Structures
		12.8.3 Matching Structures to Requirements
	12.9 Review
	12.10 References and Further Reading
	12.11 Some Important Standards
Chapter 13: Performance Engineering
	13.1 Why Performance Engineering Is Important
		13.1.1 Time as a Design Driver
		13.1.2 Ignore Performance at Your Peril – Reactive versus Proactive Techniques
	13.2 Performance Engineering – Requirements, Targets, and Achievables
	13.3 Top-Down (Requirements-Driven) Performance Modeling
		13.3.1 Specifying Targets – the Project-Management Analogy
		13.3.2 Performance Targets and Time Budgeting in Real-Time Systems
	13.4 Bottom-Up (Results-Driven) Performance Modeling
	13.5 Middle-Out (Risk-Driven) Performance Modeling
	13.6 Some Practical Issues in Performance Engineering
		13.6.1 A General Comment
		13.6.2 Modeling and Simulation Options
	13.7 Review
	13.8 References and Further Reading
Chapter 14: Documentation
	14.1 Documentation – What and Why?
		14.1.1 The Role of Documentation
		14.1.2 Documentation – Its Structure
		14.1.3 A Model for System Documentation
	14.2 Software Life Cycle Documentation – Overview
	14.3 System Functional Specifications
		14.3.1 Overview
		14.3.2 Block Diagram Description
		14.3.3 Functional Diagram Description
		14.3.4 Requirements Specification
	14.4 Software System Specifications
	14.5 Source Code Aspects
		14.5.1 Source Code Documentation – a Philosophy
		14.5.2 Source Code Documentation – Practice
		14.5.3 Source Code Review Documentation
	14.6 Configuration Management and Version Control
		14.6.1 General Aspects
		14.6.2 More on Source Code Version Control
	14.7 Review
	14.8 Further Information
Glossary of terms
Index