SystemC is a set of libraries written in C++ that provides modeling constructs and associated simulation semantics to support the design of integrated hardware/software systems at higher levels of abstraction. Its simulation kernel is based on the discrete event (DE) model of computation (MoC), which is already familiar to users of hardware description languages such as very high speed integrated circuit (VHSIC) hardware description language (VHDL) or Verilog. Patel and Shukla reference research work from the Ptolemy [1] and FORSYDE [2] projects to make the case for heterogeneous system modeling, using not only discrete events, but also synchronous dataflow, finite state machines, and other well-known MoCs, many of them possibly interoperating in a single system model. Such an approach would allow designers to create models using the most appropriate MoC for each subsystem. While such MoCs could be implemented on top of SystemC discrete event simulation semantics, designers are required to follow well-defined methodologies [3] to ensure fidelity to each MoC’s underlying principles.

Aiming to free designers from implementing the simulation semantics associated with the various MoCs themselves, Patel and Shukla propose a set of simulation kernel extensions for SystemC, including additional modeling constructs, and new simulation engines that directly implement the semantics of particular MoCs. In this book, they cover the design and implementation of extensions supporting three additional MoCs: synchronous dataflow (SDF), finite state machines (FSM), and communicating sequential processes (CSP). The interoperability between the proposed extensions and the original SystemC simulation kernel is also addressed.

While it mainly addresses the extensions to the SystemC simulation kernel, the book also provides a very good introduction to system-level design methodologies and related languages. The well-written preface and the first two chapters provide concise yet meaningful definitions of MoCs, and how they are embedded in modeling and simulation frameworks. In the third chapter, a brief review of SystemC’s DE simulation kernel is given. The central topic of the book is covered in chapters 4 through 7. Chapter 4 describes, very briefly, the software architecture devised by the authors to handle the coexistence of multiple simulation kernels, which is reported as a work in progress. Chapters 5 through 7 cover, respectively, the design and implementation of the specific simulation kernels for the SDF, CSP, and FSM models of computation. Chapter 8 describes an application programming interface (API) created by the authors to support the management of multiple simulation kernels. In chapter 9, a few examples involving multi-MoC modeling and the simulation of simple systems (including an image processing system and the well-known dining philosopher’s problem) are presented as case studies.

This book is not intended for a general audience, but rather for researchers and tool developers in the area of system-level design. Its writing style can be at times very didactic, but readers are often referred to additional literature when it comes to general concepts in a specific area. Designers and tool developers experienced in hardware description languages such as VHDL and Verilog will be able to follow the text, even if they don’t have any background in system-level design, since the preface provides sufficient connection points to relate the new approach with the practices they currently follow.