Updates
Latest Tweet
What's New?
Check out for latest innovation, a computer based training video collection
Like this Page
Real-Time Design Patterns: Robust Scalable Architecture for Real-Time Systems Review by wiredweird
Not just for real-time
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