Rosetta-lang

The Rosetta system-level specification language is a design language for complex, heterogeneous systems. 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 was undergoing standardization at various times.

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 computer simulation for analysis. In response to these requirements, three major approaches were pursued:

1. Extending hardware description languages including VHDL and Verilog
2. Extending programming languages including C and C++
3. Defining new languages

The first approach ultimately resulted in SystemVerilog and extensions to VHDL while the second resulted in SystemC, all of which became Institute of Electrical and Electronics Engineers (IEEE) standards for the semiconductor industry. Rosetta's original application domain was system on a chip semiconductor systems.^[1]

Rosetta resulted from the third approach with development beginning under the auspices of the Semiconductor Industry Council and the Air Force Research Laboratory. Originally developed by Perry Alexander and others at the University of Kansas, it was known simply as System-Level Design Language.^[2] Standardization was transferred to VHDL International by 2000 and renamed Rosetta (after the Rosetta Stone) to reflect the heterogeneous nature of its specifications. Eventually, VHDL International and the Open Verilog Initiative merged to form Accellera, an industry sponsored consortium for electronic design automation (EDA) standards. A draft standard of Rosetta was published in November 2003 through Accellera.^[3] Standardization was transferred to IEEE Design Automation Standards Committee (DASC) where it was developed by the Rosetta Working Group under IEEE project P1699 starting in March 2007.^[4][5] A draft of a language reference manual was published in April 2008, with editor Peter Ashenden of Australia.^[6] The project was withdrawn in June 2013.^[7]

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.

Since its early days, Rosetta expanded to include design domains such as hydraulic and mechanical systems, networking systems, security and trust, and software defined radios.

Further reading

Rosetta was influenced heavily by the non-strict, purely functional language Haskell, the Larch family of specification languages, and Prototype Verification System (PVS). A book devoted to the language was published in November 2006.^[8]

References

External links

• http://www.rosetta-lang.org