This textbook summarizes contemporary knowledge and paradigms of real-time systems in a monographic way. It fits an undergraduate-level course since it starts with basic hardware and low-level real-time system characteristics.
Being a textbook, the body of the text gives the necessary theoretical and programming-oriented knowledge. All of the chapters close with review questions, exercises, and programming projects. The book’s companion site provides programming code and offers a chance for further development and improvement.
Chapters 1 and 2 describe basic concepts useful to beginner students in software engineering, computer science (CS), and information technology (IT), namely central processing unit (CPU) architecture, internal memory, and input/output (I/O) methods. Chapter 2 outlines the features of multicore processors and multiprocessors. Chapter 3 discusses distributed real-time systems and briefly showcases the theoretical background, that is, finite-state machines (FSMs). The foundations of distributed operating systems (OSs) and middleware are covered, along with the basic notion of scheduling; some modern examples illustrate the applications as a modern car communication system.
Chapter 4 is an introduction to the domain of real-time OSs. Task management, inter-task communication, and inter-process communication are shown based on UNIX. The chapter concludes with a brief look at two open access and one proprietary OS. Chapter 5 begins with a case study or design exercise of a distributed real-time OS, starting with the kernel. It describes how to build up a kernel in a didactic way, considering queueing, interrupt handling, and then task synchronization and communication. Since the goal is experimental design and development, the problems and resolutions are depicted by code chunks. The previous chapter describes the required theoretical and application framework so that this chapter can illuminate, by code examples, task synchronization, communication, and management. A subsection demonstrates the approach for testing experimental OSs.
Chapter 6 addresses the fundamental services of distributed real-time OSs and real-time middleware. The chapter analyzes the various layers of the communication protocols needed for message passing. For the case study project, the presented program code demonstrates how to implement tasks in the data link layers. The chapter overviews middleware modules, that is, task group management, clock synchronization, and leader election. All of the modules are illuminated by code chunks that can be utilized in the accompanying programming projects. Chapter 7 discusses scheduling algorithms in the context of “a single processor for independent tasks that do not share resources.” The necessary scheduling and queueing methods are described. The costs of the periodic, aperiodic, and sporadic tasks are investigated. The chapter closes by showcasing some scheduling algorithms in the form of program code.
Chapter 8 deals with algorithms related to dependent task scheduling. The formal representation of aperiodic tasks to give inputs to the scheduling algorithms is a directed acyclic graph (DAG). As an outstanding case, the application of a real-time OS for the Mars Pathfinder is expounded by demonstrating a problem in scheduling and its resolution. Finally, the chapter illustrates the algorithms with program code and an extension of the semaphore mechanism. Chapter 9 reviews the scheduling tasks in multiprocessor systems: partitioning, global scheduling, and hybrid methods. The author mentions opportunities for further research in this area. Algorithms are again represented with program code.
Chapter 10 covers software and systems engineering notions that apply to real-time systems. As a textbook for an introductory undergraduate course, the chapter discusses software development life cycle models (waterfall, V-model, spiral model). The author outlines the techniques that are needed for both structured and object-oriented methodologies to carry out requirement analysis. Formal methods in the detailed and physical design phase that can be used are as follows: FSMs, timed automata, and timed Petri nets. Distributed real-time systems create a higher level of complexity because of timing, deadline handling, and network delays. The unified modeling language (UML) is useful from several viewpoints, but there is a critique in the book: UML capability does not fit the design of a predictable system considering the scheduling and real-time modeling issues. A customized methodology is demonstrated that uses a combination of data flow diagrams (DFDs) and FSMs.
Chapter 11 looks at three apt languages for real-time programming: C/POSIX, Ada, and Java. The essential facilities of the languages to employ for real-time programming are delineated. Chapter 12 overviews the fault-tolerant approaches in both real-time and non-real-time systems. The basic idea is that redundancy is required considering hardware, information, time, and software. The chapter reviews the research on fault tolerance and static and dynamic scheduling. Chapter 13 systematically goes through the design and realization of a distributed real-time system in the form of a software case study.
The author demonstrates the steps of requirement specification, analysis, and detailed design. The structure of the textbook and the building up of the chapter show readers how the theoretical background and practice can be handled in a unified framework. In classrooms, the theory and the practice can be studied together using the case study, and programming exercises make it possible for students to actively participate.