Customer Reviews

SystemC: From the Ground Up, Second Edition

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

 

 

This is a good book on SystemC, but it is not a good book for beginners. The book is overly complicated and provides levels of detail in its examples that are unnecessary to make the point or teach the subject.

For example, when discussing ports the book says the following:

DEFINITION: A SystemC interface is an abstract class that inherits from sc_interface and provides only pure virtual declarations of methods referenced by SystemC channels and ports. No implements or data are provided in a SystemC interface.

DEFINITION: A SystemC channel is a class that implements one or more SystemC interface classes and inherits from either sc_channel or sc_prim_channel. A channel implements all the methods of the inherited interface classes.

DEFINITION: A SystemC port is a class templated with and inheriting from a SystemC interface. Ports allow access of channels across module boundaries.

Huh?

This line of teaching led me into the bowels of SystemC and was unnecessary as a start. One can just say, "A port allows communication between blocks. Let's look at sc_in and sc_out to start".

I needed to get another book to recover from this instruction.

The examples in the book are generally OK and there is a website that has executable versions. Unfortunately, there needed to be more careful editing in the examples. The HelloWorld example has an obvious syntax error (an undeclared module is instantiated) and would never have run if it had been compiled.

I could not find the video mixer example that they used to teach ports on the web, and thus couldn't make progress.

Overall, this is a good book if you know SystemC and are interested in the details of how it is implemented. I would use it to learn the language, and it cannot act as a language reference guide.

I have been working as an firmware engineer for many years. As a new advernture, I am involved in investigating various algorithm modeling technique which can provide a good performance for firmware development. Obvioously, SystemC is a good candidate because of its ability to do transaction level based modelling. The question is how to pick up the language. First I tried the technical reference manual and white papers provided by the official system C website. It is quite an eye-openning experience but I think I need more. So I went to Amazon to see what was avaliable. I came across this book and the "System C Primer" book. I bought both.

The major difference between these two books is in the author's perspective. The author in this book approaches from a software background. He visualizes the whole systemC environment as a multi-threaded kernel. To learn the language is to become familiar with the different "API's" and "system calls". It is great for engineers who come from a fw/sw background. However, for engineers coming from the hw background, this book does not spend much time covering the topic on how to write SystemC model that is close to the hardware implementation (RTL or gates). They will be disappointed if this is their goal. I would recommend them to try the other book.

After saying that, I believe the safest bet probably is to get both books so you can have a full spectrum of knowledge of what the language can do for you. Then you will not get stuck knowing only one aspect of the language and you can decide which "hat" to wear according to your need.

Before this book had come out, there were only a couple SystemC books available, and after reading them both, I still had no real grasp of how to write a basic program in SystemC. This book basically connected all the dots for me, and I was able to start writing a testbench in SystemC. For the best beginner's regimen, read this book cover-to-cover a couple times and get the "SystemC Golden Reference Guide" by Doulos for use as a syntax reference when you are actually writing your code.

In a nutshell: While helpful in learning the basics of SystemC, the book leaves a lot of questions in the reader's mind.

The book does a good job touching on syntax, important SystemC classes, and usage semantics (how modules are connected to other objects.) Unfortunately, like other readers have already commented, the code-listings in the book are heavily trimmed -- many leave out declarations and other critical code to actually the thing to work. It's hard to strike a balance between code-brevity and excessive verbosity. On the plus side, all code-snippets in the book are downloadable (in COMPLETE form) from the publisher's website -- it's a shame the author didn't put a complete code-listing in the book, every now and then, just to help novice C++ readers.

This brings me to my major criticism of the book. The author has a habit of explaining away many topics in terms of C++ and terminology. You'll need an ADVANCED background in C++ and a working knowledge in OOP (object-oriented programming.) For readers lacking that background, the explanations and arugments sound like magical hand-waving arguments.

To be fair, the inner-workings of the SystemC library use extremely advanced C++ techniques. The SystemC library hides some of this complexity, but shoehorning a concurrent/hardware-simulation language on top of the C++ programming language is no easy feat. Consequently, the book cannot avoid bringing in a lot of C++ details about SystemC's implementation.

As some of the other reviewers have noted, this book is not perfect. But having reviewed it in 2004 in IEEE Design and Test, soon after it came out, it is still the best starting point for anyone wanting to learn SystemC and apply it. The other books available are useful, the primers and guides are handy, and the IEEE 1666 LRM is definitive, but as a collection of practical discussed examples and explanations of various issues in building models, this is the best starting point. I have recommended it to colleagues and they have all found it very useful in getting started with SystemC. The presentations that the authors have made at North American SystemC User Group meetings (NASCUG) are also a valuable extra learning resource, and these are worth checking out (..), along with many of the other presentations.

First, I'd like to say that I'm officially ignoring the bad pun in the book's title, because SystemC doesn't work at the level of a system's power supply or ground. It is designed as a behavioral modeling system. Unlike VHDL or Verilog, it's not a language in itself, but a set of C++ libraries. That gives the system a head start since there's already a big pool of debuggers, libraries like Boost and STL, and other support tools for it.

It also lets the authors get down to the uniqueness of SystemC features, without having to teach all of object oriented programming and C++ at the same time. Black and Donovan do an adequate job of covering basic SystemC features. This includes the ports and signals that handle communication in hardware modeling, with semantics that programmers may struggle with. In the struggling department, programmers will spend a fair bit of time getting their minds around evaluate-update channels. That's where the developer sees that variable assignment is not at all the same thing as loading a value onto a signal wire, even if SystemC uses the same operator for both.

The pace is moderate and the authors deliberately emphasize clarity over depth of coverage - great for beginners, but not so great when someone comes to this book with the wrong expectations. And, despite the useful parts, a few things got in my way. On p.91, for example, the authors observe that it feels object-oriented to overload the stream << operator for setting signal sensitivities. First, the stream << is already an overloaded definition of the arithmetic << operator. Sensitivity semantics are quite unrelated to anything about streams. Second, although I taught graduate-level OO design for five years, I have no idea why this should "feel" more OO than method calls. Some non-OO languages like VHDL support overloading; some fully OO languages like Java don't. If they meant that it felt more like idiomatic C++, fine, but equating OO with C++ is silly, at best.

Some of the hardware-oriented advice is questionable, too. One example appears on p.187, where the authors suggest that simulation performance can be improved by using time-delay wait() rather than even-based wait(). Well, yes, but I really hope that SystemC modelers don't do the same in their hardware. Pervasive use of one-shot delays was already a hanging offense back in the 1970s - they generally mean that the designer doesn't understand the design's timing. And, before you object that "it's only a model," remember that VHDL and Verilog started as modeling languages but are now synthesis languages, too. SystemC is already becoming a synthesis language. Maybe time-delay wait() isn't in the synthesizable subset, but Black and Donovan rarely draw the distinction.

SystemsC is still new enough that mentoring is hard to come by. Most people learning it will learn it from books and play-time with a SystemC compiler, with some examples if they're lucky. This book is helpful for the beginner, especially for someone with more software than hardware in their background. Still, I'm still waiting for a book with more strengths and fewer weaknesses.

//wiredweird

Rounded up to four stars, because there are so few competing books and because it's especially patient with the hardware-challenged reader.

This is a good SystemC introduction. The examples are clear and concepts are explained well. My only complaint (other than a syntax error in the "HelloWorld" example) is that I would really like to see a section on SystemC's macro system in general, since a truly conscientions C++ programmer will be using the SystemC library without the macros. But, I haven't seen any book address this topic. So, my review is otherwise all positive.

This is an extremely USEFUL addition to SystemC books that are out there. I have been using system C for modeling for about an year and still had some gaps in my understanding of SystemC simulation. This book does a fairly good job of filling this gap. Highly recommended.

I have read through this book cover to cover twice in an attempt to tease out gems of insight. The information is there, but the extremely compact writing style and poor layout make the endeavor difficult. In addition, the examples are very superficial. When I've got a question about SystemC I consult the LRM (IEEE 1666) and I rarely go back to this book.

If you charge >$100 for a book this small and advertise downloadable code examples, and even refer to them in the book. At least have the decency to spend the 1 hour it would take to actually put them online. Other than that, the content is very terse. The only reason I got this book was because of the lack of other material. It would be trivial to write a better book. The author even used a ton of space in the back for basic C++ material. I'm guessing to make sure it broke the 200 page mark. And this book is really small form factor...

the website: [...] (embarrassing)