MAY/JUNE 2006 (Vol. 23, No. 3) pp. 248-249
0740-7475/06/$31.00 © 2006 IEEE
Published by the IEEE Computer Society
Published by the IEEE Computer Society
The first transaction, but not the last
PDFs Require Adobe Acrobat
Without a doubt, the most important recent trend in modeling for electronic system-level (ESL), or system-level, design is the systematic working out of what it means to model at a higher level of abstraction. This has been a subject of debate in the system-level design and modeling communities for more than a decade. The arrival of SystemC as a modeling language, with the accompanying proof-of-concept simulator, opened up the possibility of consistent modeling at various levels within a more widely accepted notation.
However, one person's abstraction could be another person's poison. That is, without agreement on what it means to model components and systems at higher levels, models with abstract interfaces would be as difficult to interoperate as Spice and RTL models without bridges, backplanes, or transformers of some kind to convert the mutually incomprehensible notations into a mutually interoperable form.
Some groups, such as the Open SystemC Initiative (OSCI), have attempted to bring transaction-level modeling (TLM) into a mutually accepted set of levels, interfaces, and abstractions. But as of February 2006, there still is no set of sufficient and accepted definitions to enable true TLM interoperability among the diverse sets of EDA tools, IP blocks, and components, and among system and semiconductor design teams. Several industry efforts, among them OSCI's, are working to fill this gap. But in the meantime, you can gain an understanding of what is current and practical in industry from Transaction-Level Modeling with SystemC: TLM Concepts and Applications for Embedded Systems, the new book from Frank Ghenassia and his colleagues at STMicroelectronics.
Ghenassia's book reports on the pioneering experiences with TLM at STMicroelectronics. Indeed, STMicroelectronics has been a leader in defining and applying TLM in a practical way since the notion first came up for discussion. Before this book, you would have had to trawl through conference proceedings from several continents to find the information that STMicroelectronics authors have been compiling into several different papers. Now, this information is available in a single book. Furthermore, this is the first book of its kind dealing specifically with and focusing on TLM in SystemC.
Given the confusion about TLM, and the proliferation of different definitions of it, a book on TLM must use a consistent definition. Ghenassia's book provides the definition in the first chapter of Section 3, p. 14:
Components are modeled as modules with a set of concurrent processes that calculate and represent their behavior. These modules exchange communication in the form of transactions through an abstract channel … TLM defines a transaction as the data transfer (i.e. communications) or synchronization between two modules at an instant (i.e. SoC event) determined by the hardware/software system specification.
This is an interesting definition in that it does not focus solely on low-level data transport, or the use of interface method calls, which distinguishes it from other views on TLM. Nevertheless, using their own definition is the prerogative of pioneers in this area.
The book consists of seven chapters: three foundational, three application oriented, and one on design automation flows to knit the TLM-based design process together. The first chapter gives an overview and brief history of TLM, concentrating on its use at STMicroelectronics, the design flows created, the abstractions used, and the lessons learned. The second chapter dives into much more detail on TLM and is, in many ways, the most important chapter of the book—it documents the TLM modeling principles, discusses the types of TLM models (untimed and timed, programmers' view, and programmers' view with timing) and the relationship between these models and others in the design flow. The third chapter moves TLM modeling into the SystemC domain, placing it in the context of a variety of design languages, and showing via specific language-based examples how to build TLM models in SystemC. This chapter also gives the results of various experiments conducted at STMicroelectronics and shows the simulation performance advantages of using TLM.
The next three chapters discuss specific applications of TLM: for embedded software development, for functional verification (including some early work on formal verification, as well as emulation), and for architecture analysis and system debugging. These chapters are of direct interest to specialists in these areas and illustrate the wide scope for applying TLM modeling in the design process. The final chapter, on design automation, engages EDA practitioners and largely focuses on the emerging Structure for Packaging, Integrating, and Reusing IP within Tool Flows (Spirit) standard for IP metadata and constructing system platform models. This chapter ends up being quite specific to those companies (such as STMicroelectronics) that are following the Spirit approach to designing complex IP-based SoCs.
A different set of authors writes each chapter, with Ghenassia providing overall editing and coauthoring the first two chapters. With such a variety of authors, the book is more a collection of interlinked chapters than a single focused monograph. Thus, if you're interested in a particular topic, such as architecture analysis, you could read the first three chapters and then go straight to the one on architecture analysis.
Despite containing much useful information for anyone who would like to learn and apply TLM modeling, the book could stand some improvements. The language is somewhat clumsy at times, and further editing for grammar and style would have made it more understandable in parts. The book could definitely have benefited from a consolidated reference list, with more references from those topic areas that have none or few, and less reliance on Web site references, which often become dated or erroneous very quickly (especially those from EDA vendors). Finally, some repetition becomes apparent on a cover-to-cover read, but it's less of an issue for those who dive into the specific chapters they're most interested in.
Nevertheless, I recommend this book for anyone who wants to discover and benefit from advances in the application of TLM in a practical industrial setting. The tales of the pioneers in any field can greatly benefit those neophytes who are just setting off for the goldfields, and their accumulated knowledge is a great heritage to pass on. And for those engineers designing complex SoC devices who are not considering using TLM modeling—this book is a valuable guide that shows precisely why you should be paying attention to TLM. This is probably not the last book on TLM, but it is a worthy representative of the first.