The more I think about language, the more it amazes me that people ever under-
stand each other — K
The last thing this world needs is one more design language. This is an
odd statement to open a book about one more design language, but it is true
nonetheless. What the world does need are solutions to problems that help pro-
duce cheaper, more reliable engineering solutions. Although the introduction of
VHDL and Verilog revolutionized digital hardware design, today they represent
venerable, established solutions to RTL design problems. The time has come to
move ahead to new solutions to the new problems introduced by heterogeneity,
resource constraints, rapidly evolving implementation fabrics, safety and security
requirements, and system-level complexity. More of yesterday’s solutions will not
solve today’s system-level design problems.
Rosetta was inspired by a problem whose solution demanded a paradigm
shift — the design of “systems on chip,” or system-level design of electronic sys-
tems. In 1997, the Semiconductor Industry Council met in Dallas, Texas to discuss
potential solutions to the system-level design problem. Speciﬁcally, the industry
was beginning to see the edges of what its desig n methods and tools were capa-
ble of supporting. The ability to fabricate systems was growing exponentially,
outpacing even Moore’s Law. However, the ability to design systems was growing
only linearly; the causes were deemed to be lack of formal semantics in modeling
languages and processes, inability to account for performance requirements dur-
ing desig n, inability to predict emergent behaviors in heterogeneous systems; and
too much reliance on simulation, among others.
During two days in Dallas in 1997, the Industry Council deﬁned a collec-
tion of requirements for a language to support system-level design. This consen-
sus of original motivating requirements still hangs on my wall — representation
of performance requirements; precise, formal semantics; support for speciﬁca-
tion heterogeneity; and reduced reliance on simulation. Although the name has
morphed from system-level design (SLD) to elect ronic system-level (ESL), the
problem remains the same.
Almost ten years and one technology boom-and-bust cycle later, we present
Rosetta. Through it all, we have tried to hold Rosetta to initial requirements while
responding to the unspoken, e volving needs of system-level designers. Rosetta is
formal as embodied in co-algebraic semantics supporting both simulation and
modern formal analysis techniques. Rosetta represents performance constraints
and supports complexity management using abstract, declarative speciﬁcation.
However, above all other things, Rosetta supports heterogeneous speciﬁcation.
This is the linchpin for effective support for system-level design decision making.
Rosetta’s most important contribution to system design is heterogeneity.
Heterogeneity means simply that not all elements of a speciﬁcation are repre-
sented using the same semantic basis. It is embodied by the use of continuous-
time semantics for analog circuits, state-based semantics for digital systems, and
temporal logic for constraints all within the same desig n. What Rosetta provides
is a language and semantics for writing such speciﬁcations and integrating them
to predict system behavior. Support for heterogeneity is the enabling capability
for system-level design. Without it, we are wasting our time.
Heterogeneity was woven into Rosetta’s fabric from the ﬁrst discussions of its
semantics. Rather than establish a speciﬁcation model for all systems, we have
tried to establish a language framework for deﬁning and integrating speciﬁcation
models. The expression language and type system provide a computation-neutral
mechanism for declaring things and deﬁning their properties. Being lazy and
largely non-strict, the expression language is a means for describing calculations,
rather than computations. The facet system provides means for choosing a mod-
eling semantics, deﬁning models using the expression language to specify proper-
ties, and composing models to deﬁne complete systems. Finally, the domain and
interaction systems provide mechanisms for deﬁning modeling semantics and
interactions between models in different semantics. Because models are homoge-
neous and nonorthogonal under composition, we can write models for different
system aspects and understand their mutual dependencies and interactions.
What this book attempts to do is provide a gentle introduction to Rosetta
and the modeling techniques it supports. After working through the text, I hope
that you will be able to begin writing Rosetta speciﬁcations in the base Rosetta
design domains. What this book does not do is provide deep insight into Rosetta’s
semantics or advanced usage. It is not an attempt to replace the Rosetta standard,
but instead to provide a path to understanding why the language is designed as it
is. It is best to walk before we run, both as a reader and an author!
In the grand scope of electronic system-level design, Rosetta is still a young
language. The standards process has started and early adopters are moving
forward. There is much left to discover and more work to be done. I hope that
ultimately this book will pique your interest in getting involved with the language
speciﬁcation and tool development efforts.
System-Level Design with Rosetta