Rosetta-lang

The Rosetta system-level specification language is a design language targeting complex, heterogeneous systems with the specific aim of supporting system-level design. Specific language design objectives include:

* Constraint representation
* Heterogeneous system representation and specification composability
* Well-defined formal semantics and support for formal analysis
* Scalability to large designs

Rosetta is currently undergoing standardization by the IEEE Design Automation Standards Committee as project P1699.

History

The Rosetta effort emerged from a meeting in of the Semiconductor Industry Council's System-Level Design Language committee in 1996. The objective of the meeting was to define requirements for a next-generation design language that would address perceived shortcomings in existing languages such as VHDL and Verilog. Specific concerns included inability to represent constraints, lack of a formal semantics, inability to represent heterogeneous systems, and heavy reliance on simulation for analysis. In response to these requirements, three major approaches were pursued:

* Extending hardware description languages including VHDL and Verilog
* Extending programming languages including C and C++
* Defining new languages

The first approach ultimately resulted in SystemVerilog and extensions to VHDL while the second resulted in SystemC, all of which are now IEEE standards and are being adopted by the semiconductor industry.

Rosetta resulted from the third approach with development beginning under the auspices of the Semiconductor Industry Council and The Air Force Research Laboratory. Originally referred to simply as SLDL (System-Level Design Language), the language was transferred to VHDL International and renamed Rosetta to reflect the heterogeneous nature of its specifications. Eventually, VHDL International (VI) and The Open Verilog Initiative (OVI) merged to form Accellera, an industry sponsored consortium whose responsibility is developing electronic design automation (EDA) standards. After a number of years working through Accellera, Rosetta was transferred to IEEE Design Automation Standards Committee (DASC) where it is now being developed by the Rosetta Working Group under IEEE project P1699.

Structure

Rosetta is structured around three sub-languages that support defining various specification elements. The "expression language" defines basic functions and expressions used as terms and values in specifications. The expression language is a non-strict, purely functional, typed language in the spirit of Haskell. Functions are referentially transparent, encapsulated expressions and cannot have side effects. All Rosetta expressions have types that are determined statically. The type system is based on lifted sets where each type contains at least the bottom or undefined value. Any set can be used to define a type and any function that returns a set can be used to define a type former. Because type definitions can contain general Rosetta expressions, the type system is dependent.

The "facet language" defines individual specifications and specification composition to define systems. "Facets" and "components" define system models from one engineering perspective. Each facet is written by extending a "domain" that provides vocabulary and semantics for the model. Facets are defined by declaring items and defining properties for those items. As such, Rosetta is a declarative language and constructs cannot be guaranteed to evaluate to a value, although some facets can be evaluated. Using the design abstractions provided by its domain, a facet describes requirements, behavior, constraints, or function of a system. Facets are heterogeneous and may be defined using any of the predefined or user defined domains. The Rosetta semantics denotes each facet to a coalgebra that defines its model-of-computation. Because Rosetta is reflective, facets can be composed and transformed to define complex systems. A common specification technique is to write facets for different aspects of a system and then compose those aspects using product and sum operations to define the complete system.

The "domain language" defines specification domains otherwise known as specification types. The collection of domains forms a complete lattice ordered by homomorphism with the empty or "null" domain as its top element and the inconsistent or "bottom" domain as its bottom. There are three primary domain types. Units-of-semantics domains define basic units of specification. For example, the state_based domain defines the concept of state and next state without constraining the values or properties. Model-of-computation domains extend unit-of-semantics domains to define general computational models such as finite_state, continuous_time, discrete_time and frequency. Engineering domains extend model-of-computation domains to provide specification capabilities for specific engineering domains.

Applications

Rosetta's original application domain was system-on-chip semiconductor systems. Since its early days, Rosetta has significantly expanded its domain to include design domains such as hydraulic and mechanical systems, networking systems, security and trust, and software defined radios.

Further reading

Rosetta is influenced heavily by the non-strict, purely functional language Haskell, the Larch family of specification languages, and PVS.

References

(1) http://www.rosetta-lang.org