Customer Reviews

Real-Time Design Patterns: Robust Scalable Architecture for Real-Time Systems

5 star:		(4)
4 star:		(1)
3 star:		(0)
2 star:		(1)
1 star:		(0)

 

 

Douglass' book does present a number of patterns useful in embedded, hardware-rich, and resource-constrained environments. More than that, though, he gives background material and discussion that work in OS and application environments, too.

Chapters 4 to 9 lays out a number of patterns that work well in embedded environments. Patterns for any one aspect of the system (memory, safety/reliability, etc.) are grouped into chapters, allowing easy understanding of the relationships between patterns that differ only subtly. Ch.7, especially, covers a number of related patterns that address to dealock avoidance - good stuff, but a bit more comparison between patterns and discussion of how to select between them would have helped. The discussion on deadlock in general is good too, but a standard OS textbook might cover aspects of deadlock in more detail.

Ch.6, on memory, will be a revelation to people who just use malloc() and free() without thinking. There are lots more ways of handling memory. His discussions of different patterns are good but there's always more to say. Memory pools, for example, may have many different meanings: different memory regions (cache vs. main memory) may have different performance features, or (as in DOS or Windows before about Win95) implications for the instruction sets required for memory access. Harvard and multi-bus architectures may use memory pools to reflect different memory accessibility rules. The "fixed-size buffer" pattern is another great one. I've seen it implemented in hardware, for on-chip buffers in network controllers, and in operating systems where objects of a specific data type are reused frequently. (This can overlap with the pool pattern, when there are different pools for buffers of different fixed sizes.)

Ch.3 talks about patterns in general, and the discussion ranges widely. It includes a fairly good discussion of using multiple patterns in one application, but stops short of the tricky cases where one object participates in two different patterns.

On the whole, this is a very useful book. It does presuppose some background in system (as opposed to software) design. That means it's not for the raw beginner, but it doesn't pretend to be. Some of the discussions of low-level system design suffer from shallowness, and some embedded topics are simply never discussed. Memory structures for block-erasable FLASH, for example, may resemble those used in writable CD-ROMs. Every book has bounds, though, and Douglass has done a good job within the bounds he chose.

//wiredweird

I *strongly* disagree with the other reviewer here. This book IS, of course, a collection of real-time architecture patterns (see the author's other books for tutorial info on these topics), and it is the *ONLY* such collection of design patterns for real-time systems. There is a lot of tutorial and reference material out there on these topics but nothing that serves as a pattern reference for the topics that we real-timers care so much about - safety and reliability architectures, concurrency patterns, resource and memory management, distributed architectures, and so on. Each pattern is provided with useful example of its application as well as the pros and cons of each. Where else can you even find a pattern-oriented discussion of the pros and cons of using priority ceiling versus simultaneous locking versus ordered locking for the protection of resources? And there are patterns discussed here that I haven't seen elsewhere. I feel that I now *finally* really understand the issues of software architecture for real-time systems and have a place to find solutions to my problems on my upcoming project. This book is fantastic for the more-than-beginner and belongs on everyone's reference shelf. Highly recommended!

The title of this book promises insights how to build architecture for embedded real-time systems. Of course the book lists lots of patterns and follows the way such patterns are usually described (Problem, Structure, Consequences). Unfortunately this list is not new at all and the descriptions are not going into a level of detail to really help in practice. E.g. in Concurrency Patterns beside others the round robin pattern and static priority pattern are described. Later under Resource Patterns the priority ceiling pattern is presented. I would recommend reading the book from Burns and Wellings or one about RMA to learn how to build real-time systems. Such books present real-time systems in a much more structured way and present the common problems and solutions in more detail. Patterns are important, but just listing patterns to fill a book is not enough.

This text is being used in a company wide campaign to improve system Software quality and Time to Market.

I have found that many of the older problems as well as more recent ones are usually due to partial realization that the code is indeed using a pattern, but not instantiating all of it. The text continues to be an excellent resource while in training. Waiting for a chance to actually do something with it in practice

This book covers design patterns that address common problems in real time systems (memory leeks, resouce sharing, ISRs ...). As the name implies it does so at an Architecture rather than code level. The book seems to be best targeted toward medium or large systems in that some of the patterns (such as those dealing with distribution) might not apply to simple 8-bit micro system. It may be a difficult read for someone with limited real time development experience in that it covers complex real time problems in a variety of areas.

Software engineer
Good at what you do
Avoid Haiku like the plague