The history of the Rosetta system-level design language spans the last decade. Indeed, the history of Rosetta mirrors the history of system-level design over that decade as well. The seminal Dallas meeting in 1997, as discussed by Perry Alexander in his Preface, crystallised the requirements for those system just emerging at that time, which also marked the beginning of the system-on-chip (SoC) revolution. The first generation of algorithmic system design tools were in active use, and researchers were exploring the meaning of such concepts as ‘multiple models of computation.’ The first commercial behavioural synthesis tools were struggling to demonstrate a real value to designers. The first intellectual property (IP) based SoC construction, simulation and analysis tools were trying to find an audience. And tentative experiments with C/C++ and Java as system modelling languages were a response to the perceived inadequacies of hardware design languages (HDLs).

The Dallas meeting and subsequent system-level design language (SLDL) meetings in San Jose and Italy established a set of requirements that became fixed beacons during the tumultuous system-level decade that followed. That decade saw the first generation of commercial behavioural synthesis and SoC construction tools fail in the marketplace. It also saw the system-level design language ‘wars’ end with a relative truce, and an industry consensus emerge on using SystemC as the imperative system design language for modelling complex hardware and software components, and for building system-level simulation models. Throughout this tumult, the need for additional capabilities in system-level design remained a constant.

In particular, the need for a notation to capture declarative aspects of system design—especially design constraints; to allow the composition of the specifications for heterogeneous subsystems; and to facilitate more formal analysis of both specification and implementation—were the subjects of many research projects—including the Rosetta project.

But Rosetta did not start out as a research project. It started as an industry-sponsored language development effort, later coming under the umbrella and sponsorship of the Accellera language-based design standards group. Interest within Accellera in Rosetta rose and fell as interest in the first phase of system-level design waxed and waned. It was fortuitous indeed that, complementing the inconsistent commitment of commercial EDA, systems and semiconductor companies to the Rosetta concept, the academic community, especially in the persons of Perry Alexander and Peter Ashenden, rose to provide a continuous level of engagement, detailed technical work, and semantic integrity in pursuing the definition of Rosetta further.

As Accellera continued to focus on the shorter term and arguably more pragmatic agenda of the commercial EDA industry and large design companies, in the form of languages such as SystemVerilog, now IEEE 1800-2005, and Property Specification Language (PSL), now IEEE 1850, it became increasingly clear that Accellera was no longer the most appropriate organisation to continue sponsoring Rosetta. Thus the language was returned to the academic community for continued specification and evolution, under the leadership of Perry Alexander. This has allowed the language to be fully specified, and has allowed the writing of this book, System-Level Design with Rosetta. As every new language seems to require at least one book to be written to promote understanding and further interest and use, so this milestone has now been achieved with System-Level Design with Rosetta.

How can we best summarise the status of Rosetta in 2006? As this book makes clear, it is a well-defined research language. There are some early tools available, and the prospect of more coming. It has a small pool of academic users, but currently very little industrial or designer usage. The availability of this book will play a big part in increasing the pool of users, in heightening interest and in encouraging more tools to emerge. What Rosetta needs above all is design use and feedback based on that use, so that it can enter a virtuous cycle—a period of rapid development and improvement based on real usage. As with any new design language, use validates the concept of it.

To use Rosetta, readers need to understand it. Here Perry Alexander’s book provides a comprehensive and well-written look at the language. After a general introduction, in Section I, to system-level specification and the Rosetta concept, the book is split up into four further sections that build up the Rosetta language starting with the basic expression language, through the concepts of facets, domains, and finally, several case studies illustrating Rosetta’s application.

In particular, Chapter 1 lays the groundwork for the Rosetta concept of a specification notation, illustrating this with a simple example of the basic modelling concepts, facets, and domains. It also discusses vertical and decomposition concepts in specifications and models, and ways of usage. The final section in Chapter 1 discusses how best to use the book to learn Rosetta. It will be worthwhile for the reader to read Chapter 1 carefully and to return to it for refreshing the basic concepts whenever the details in the rest of the book begin to seem overwhelming.

Section II has several chapters on the basic language constructs: value, types, expressions, and functions. Although not a formal syntax definition, careful explanation and copious examples make the base language clear. The concept of a ‘facet’ is the subject of Section III, and the section opens with a basic explanation of the notion and use of what will strike many readers as a new idea through simple examples. Here the concept of declarative modelling as opposed to imperative languages becomes much clearer.

In Section IV, the important notion of heterogeneous modelling domains and the composition of domains into heterogeneous specifications is explained in detail. Many examples illustrate what will be new ways of looking at modelling for most readers.

Perhaps the most important section is Section V, containing three case studies. The first line of Chapter 16 really encapsulates the idea of the whole book: “The best way to understand system-level modelling is to model systems”. The first study is for an RTL specification, drawing on any knowledge of traditional RTL design that readers may have. The second study is of a TDMA wireless receiver, specifying it first with models for function, power consumption and constraints, and then illustrating refinement from specification to implementation in CMOS, FPGA, and software. The last case study is for a system-level network and access control. These three studies show the range and power of applying the Rosetta concept.

With such an introduction to Rosetta, the most important next step for the community of readers is to then start using it. This can be done even in the absence of tools or a way to reuse the Rosetta specifications. Mapping the concept of a new design and its natural language specification into the precision of a specification language such as Rosetta will be useful even without carrying it further—to clarify the specification, to clearly identify constraints, to bring out multiple heterogeneous design domains, and to demonstrate which requirements are most important. Based on such experiments, feedback on the usefulness of the Rosetta language, its constructs, and suggestions for its improvement will all be valuable for further evolution. At some point the arrival of tools will assist early users in the reuse of such specifications in formal analysis, in verification, and even possibly in implementation flows.

The arrival of the first book on Rosetta is a major milestone in the long history of the evolution of this language. I congratulate Perry Alexander on his work as demonstrated herein, and recommend this book to anyone curious about the language and wishing to study it further and apply it.

At the end of the first decade of system-level design exploration for complex SoC and embedded systems, it seems clear, as in the opening quote, that we have not arrived at the end of this topic nor even at the beginning of the end. This book truly is a marker that we are at the “end of the beginning”. As Churchill said (albeit in a very different context), “Let us go forward together” into the next phase of system-level design.

Grant MartinPleasanton, CaliforniaApril, 2006