Rosetta provides support for system-level design
From EE Times
By Perry Alexander and David Barton
Support for higher abstraction levels is becoming increasingly important because of dramatic increases in system complexity. Rosetta, under development by VHDL International's System-Level Design Language (SLDL) committee, is an emerging design language that provides that support by taking a fresh approach to system-level design.
Any language proposing to support system-on-chip design must address two important design characteristics. These are the integration of information from multiple heterogeneous sources and the ability to work at high levels of abstraction with incomplete information.
Rosetta provides language support for defining and combining models from multiple domains using multiple-domain semantics. In addition, it supports modeling and analysis at levels of abstraction much higher than those of current RTL-based languages. Its semantics are formally defined and it is highly extensible to support adaptation to emerging systems.
Rosetta allows modeling at high levels of abstraction, modeling of heterogeneous systems and support for model composition. By allowing the user to define and compose models, it allows flexibility and heterogeneity in design modeling and supports meaningful integration of models representing all aspects of system design.
Furthermore, Rosetta's formal semantics provide an unambiguous means for defining and composing models. Finally, the default Rosetta syntax provides a user-friendly mechanism designed to be comfortable for today's existing HDL user base.
Facets and models
The Rosetta design methodology is based on the facet-modeling concept. A facet is a model of a component or system that provides information specific to a domain of interest. To support heterogeneity in designs, each facet may use a different domain model to provide domain-specific vocabulary and semantics. Facets are written to define various system aspects and are then assembled to provide complete models of components, component aggregations and systems.
The definition of facets is achieved by directly defining model properties or by combining previously defined facets. The former technique allows users to choose a specification domain and specify properties that must hold in that domain. The latter technique allows users to select several models and compose a system model that consists of elements from each facet domain. The abstract semantics of Rosetta are based on this specification and combination of models representing information from various design domains.
The syntax of Rosetta facets is designed to be familiar to engineers using existing hardware description languages. What makes the facet model different than traditional HDL approaches is the identification of specific domains.
A primary difficulty in addressing the system-on-chip problem is combining information from multiple domains within a single design activity. The domain concept allows this by enabling each model to reference a base set of concepts that supports definition of information in one particular design area.
For example, in a trigger specification the continuous domain provides the concepts of time, instantaneous change, ordering and state. Such concepts are important to continuous-time modeling, but may not be important when modeling power consumption or area. Such models reference the constraints domain for defining such information.
The Rosetta semantic model is important because it reflects how system engineers currently tackle their problems. The syntax makes the semantics approachable.
But the real contribution of Rosetta is the semantics of designing and composing component models. Through the use of domains, users are provided with design vocabulary specific to their domain of expertise rather than forcing the domain expert to work in a language that is too general or otherwise unsuitable for his or her needs.
Heterogeneity in system design not only emerges when defining multiple facets of the same system, but also when describing systems structurally by combining components. VHDL provides a structural definition capability that is mimicked in the Rosetta semantics using a concept called relabeling.
When one facet is included in another, an instance of that facet is created by relabeling or renaming the facet. Facet parameters are used as ports and channel data types used to model communication between components.
Like single components, Rosetta systems may include component models from multiple design domains. Thus, Rosetta provides a mechanism for defining and understanding systems comprised of components from analog, digital, mechanical and optical domains in the same semantic framework.
Furthermore, users may define new specification domains to extend Rosetta to address new domains and new modeling techniques for existing ones. Such a capability is extremely important for the future of any potential system-design language.
Unfortunately, it is not sufficient to simply model domain-specific information in isolation. Cross-domain interaction is the root cause of many systems failures and difficult design problems. System-level design requires understanding the collective behavior of interconnected components from different design domains, not simply the component-level behaviors. Further, interaction also occurs between different models at the component level. Rosetta provides methodologies for explicitly modeling and evaluating such interactions by defining how definitions from individual domains affect each other. There are two fundamental approaches for modeling interaction between design domains in current design practice. The first is to choose a single domain to represent all system models. Analysis tools from that domain are then used to model entire systems.
The problem with this approach is that the modeling domain always favors one domain over all others. Designers or tool builders must force information represented quite naturally in one domain into a potentially less suitable representation. The net result is a model that cannot be analyzed or a system model that ignores certain domains.
The second approach to addressing model interaction is to rely on human observation to detect and analyze interactions between domains. Models are developed and maintained using separate representations and semantics. Human designers are required to constantly observe and predict interactions.
This approach is the most common in today's environment and will most probably always exist to some extent. However, Rosetta attempts to provide semantic support for this activity by providing a mechanism for specifying and thus analyzing domain interactions.
Rosetta provides the special domain and interaction semantic constructs for defining domains and domain interactions respectively. The domain construct simply provides a mechanism for identifying a facet as a domain model. Syntax is provided in Rosetta to allow users to identify and define domains quickly, but their semantics is the same as a facet.
When a facet includes a domain, it extends that domain to represent a specific component or system model. When facets using domains involved in an interaction specification are included in a definition the interaction specification is automatically included.
Like a domain, an interaction is also a facet. Using Rosetta's reflection capabilities, an interaction defines when specifications in one domain imply specifications in another. An interaction is a facet that accepts two domains as parameters. It then defines when information in one domain is pertinent in another.
Rosetta currently provides semantics for mathematical specifications and state-based (finite and infinite), discrete time and continuous time specification.
Support for specification of testing requirements, constraints and mechanical systems are being developed. Interactions are defined for many supported domains with others under development.
It is important to note that Rosetta's semantics are defined independently from its concrete syntax. Although a facet does have a defined syntactic representation, its semantics were defined initially and syntax developed to address usability and readability issues. Other syntactic representations are not precluded and are being encouraged.
To assure usage across domains and throughout the design life cycle, Rosetta is vendor- and tool-independent while providing support for importing and exporting models from various CAD languages and tools. The Rosetta semantics and language are being jointly developed by the SLDL Committee, AverStar and the University of Kansas Information and Telecommunications Technology Center with guidance and support from the European Chips and Systems Initiative, the Semiconductor Industry Council, Darpa and the United States Air Force.
Currently, the Rosetta language and associated tool set are being used for system-level test vector generation, component retrieval and reuse and analysis of mechanical subsystems.
For more information, contact ITTC.