Cadstone's Bedrock product line and design services support a broad cross section of system-level design activities. A standard set of analysis tools is available for parsing, type checking, evaluating and synthesizing synthesizing models. We can rapidly deploy custom synthesis and analysis tools using the Bedrock tool suite when standard solutions are not applicable. For sophisticated customers desiring to build their own tool suites, the Bedrock tool suite can be licensed directly for developing in-house custom solutions.
Cadstone's design and education services provide assistance in the deveopment process. Desgin services are available for developing specific solutions, custom synthesis and analysis tools, or assisting clients with these tasks. Education services provide tutorials on Rosetta usage, system-level design semantics, and system-level design tool development.
Cadstone Bedrock Toolset
The Cadstone Bedrock Toolset provides a complete set of Rosetta synthesis and analysis tools to support the entire system’s level design process. The Front-end Analysis tools provide parsing, linking and static analysis capabilities. The Expression Interpreter provides interpretation and simplification capabilities for single Rosetta statements. Finally, the Facet and Interaction Evaluator provides complete analysis capabilities for full Rosetta models.
Inputs and outputs are formatted in XML to facilitate easy integration with third party tools. Command options for all tools are specified at the command line or through XML formatted configuration files. Informational and diagnostic messages generated by tools are presented in XML format with an option to print ASCII text for command line processing. The major data structure used by parsing tools can be imported from and exported to an XML format for integration with third party tools.
Cadstone System Design Services
Cadstone provides a wide range of design and education services for Rosetta-based system-level design. Cadstone design services provide clients with assistance ranging from help with specific design tasks to support for the Bedrock Toolset. Cadstone offers three major classes of services:
- System Design - Assistance with the design or analysis of specific systems.
- Tool Design - Implementation of specific analysis or synthesis tools using the Bedrock Tool Suite
- Bedrock Support - Assistance with customer implementations using the Bedrock Tool Suite
Cadstone education services provide clients with tutorials ranging from basic Rosetta modeling through advance model composition, verification and synthesis techniques. Tutorial offerings planned include:
- Introduction to Rosetta Modeling - The basics of Rosetta modeling and Bedrock tool usage
- Advanced Rosetta Modeling - Model composition, writing domains, writing interactions and other advanced topics
- Using Bedrock - The basics of using Bedrock to develop custom Rosetta tools
- Introduction to System-Level Modeling Semantics - An under-the-hood look at Rosetta and how it works
Rosetta Intermediate Form
The heart of the Bedrock tool framework is a Rosetta Intermediate Form that serves as input to all tools. The intermediate form is a collection of standard data structures that interface to powerful interpreter development components. The Cadstone Bedrock Parser generates intermediate form from Rosetta source input . From there, type checkers, linkers, analysis and synthesis tools take over to perform specific tasks.
For users who wish to define their own front ends, the intermediate form has an associated XML Schema for data representation. Using the XML form, users may interface with graphical interfaces, Rosetta synthesizers, or any other external tool. For users who wish to develop tools that directly interface with the intermediate form, an interface definition is provided that follows the Rosetta reflection standard.
Top >>
Bedrock Parser and Linker
The Cadstone Bedrock Parser and Linker, and Object Model provide a basis for developing Rosetta analysis tools without expending resources on basic infrastructure development. Traditional analysis tools for languages like VHDL and Verilog require signficant resources to develop front-end analysis toolos. The Cadstone Bedrock tool suite eliminates this need by providing standard front-end tools for a fixed, one-time cost.
The Bedrock Parser implements syntax checking for the Rosetta language, generating a common abstract syntax tree (AST) data structure used by all downstream tools. This data structure, called the Rosetta Object Model (ROM), provides a clean, consistent interface with the parsing tools. The Bedrock Linker implements a mechanism for finding and combining model libraries that includes support for local and distributed libraries.
Together, the Cadstone Bedrock Parser and Linker provide a platform for basing the development of other Rosetta tools. Using the Bedrock Parser and Linker dramatically reduces development time by providing off-the-shelf tool libraries and defining common interfaces for integrating new capabilties. Designed for integration with other capabilities, the Front-End Model Processing tools use proven XML capabilities for defining data interfaces. These data interfaces may be used to integrate third-party tools or to integrate the Cadstone Rosetta Tool Suite into graphical development environments.
The Cadstone Bedrock Parser is a top-down, recursive, LL(K) parser implementing the most recent advances in parser technology and the Rosetta syntax. The Rosetta Parser accepts a Rosetta specification as input and generates a ROM data structure representing the specification’s abstract syntax tree. Once parsed, the source code is discarded and the AST used for efficient manipulation and analysis by downstream tools. The Rosetta Parser is built upon the Parsec parser combinator library, a highly efficent and mature parser construction tool. The AST structure is an internal data structure common to all Cadstone tools and may be exported as an XML document for processing by external, third-party tools. Similarly, error and diagnostic messages are produced using a standard XML form for external tool processing.
The Rosetta Linker implements a distributed library system that allows users to bring together Rosetta packages. The Rosetta Linker accepts a Rosetta specification in AST form, attempts to find all library elements used by the specification, and gnereates an annotated AST with references to external pacxkages resolved. Supporting both local and remote library access using established URI standards, the Rosetta Linker supports widely distributed specification and analysis activities. This allows Rosetta developers to reference libraries written by colleagues in different physical locations and reference vendor libraries remotely.
Top >>
Bedrock Rosetta Static Analysis Tools
The Cadstone Bedrock Static Analysis tool suite supports automatic type and consistency checking prior to in-depth model analysis. Cadstone Bedrock Static Analysis tools allow designers to catch common consistency errors well before significant analysis resources are expended. Furthermore, the Cadstone Bedrock Static Analysis tools operate affectively on abstract, incomplete models early in the design cycle allowing requirements errors well before they become costly systems errors. Traditional simulation-based analysis tools require complete models and significant simluation resources to catch similar errors.
The Cadstone Bedrock Static Analysis tools accept a fully elaborated Rosetta specifiation in AST form and generates diagnostic messages indicating type errors and other static consistency errors. The Cadstone Bedrock Static Analysis Tools implement both traditonal type checking algorithms and a powerful inference system for resolving complex typing and consistency issues. The inference system may also be used for other types of static and semantic checking.
If the Cadstone Bedrock Static Analysis tools cannot make a decision concerning an analysis goal, the goal is passed forward to the calling environment or to other tools as specified by the implementation. This allows users to define custom analisys tools that can be integrated into the Cadstone tool suite. Goals passed out of the Bedrock Static Analysis tools will be represented using XML for easy integration into other Cadstone or third-party tools.
The Cadstone Bedrock Static Analysis provide a capability for applying transformations to the abstract syntax tree. Rules may be provided by the user on domain by domain basis. Thus, new static semantic checks may be added to the standard type checking and constraint checking activity. Using the rule structure, tool users may also integrate other type checking and constrain checking algorithms buy using rules to define when the algorithm should be applied and performing an external call to additional checking algorithms.
Top >>
Bedrock Rosetta Evaluators
The Cadstone Bedrock tool suite provides an extensive collection of tools for evaluating Rosetta specifications both operationally and through formal verification. The Cadstone Bedrock Expression Interpreter and Simplifier operate on individual expressions providing traditional interpretation capabilities for the Rosetta expression language. The Cadstone Bedrock Facet Simulator and Evaluator provide capabilities for evaluating complete Rosetta specifications. Each tool provides a powerful stand alone analysis capability and enables implementation of sophisticated downstream tools.
Rosetta Expression Interpreter and Simplifier
The Cadstone Bedrock Expression Interpreter and Expression Simplifier provide a basis for interpreting basic Rosetta expressions and enable constructing back-end analysis tools and augmented type-checking capabilities. The Bedrock Expression Interpreter provides a capability for converting interpretable Rosetta expressions to values in their declared context. The Bedrock Expression Simplifier provides a capability for converting Rosetta expressions into a canonical normal form.
The Bedrock Expression Interpreter and Simplifier provide a platform for evaluating basic expressions and developing powerful downstream processing tools. Both take ROM data structures produced by the Bedrock Parser and generate results suitable for use internally or export to external tools and environments via XML. By providing a common evaluation framework, downstream analysis tools can be seamlessly integrated and intermediate results exchanged between analysis tools.
Bedrock Expression Interpreter
The Bedrock Epression Interpreter provides a basic capability for determing values for Rosetta expressions. The Bedrock Expression Interpreter is not a simlator, but instead provides evaluation for individual Rosetta expressions that can be used to develop other Rosetta analysis capabilities. Rosetta provides a powerful expression language for defining calculations similar to traditional mathematics. The Bedrock Expression Interpreter accepts an instantiated Rosetta expression and attempts to evaluate it to a value in the context of its definition. In this sense, the Bedrock Expression Interpreter can be thought of as a Rosetta calculator that solves individual Rosetta equations and terms.
The Bedrock Expression Interpreter is designed to be highly extensible to afford cost effective application in new Rosetta domains and provide new mechanisms for solving equations. It is implemented as a collection of extensible, composable interpreters implementing various solution algorithms across numerous domains. Current interpreter technologies include lazy evaluation, boolean satisfaction, theorem proving and rewriting. When an expression is input to the interpreter, the appropriate domain-specific interpreter is automatically called to evaluate the expression. When new domains are added, new interpreters can be constructed or can be generated for interpreting expression in the new domain. Because Bedrock Rosetta Expression Interpreters are modular and composable, new parsers can easily be integrated representing new speification domains and language features.
The Bedrock Expression Interpreter uses conservative techniques to determine if an expression can be evaluated to a value. Thus, expressions identified as interpretable are guarranteed to be interpretable while some of those excluded may be semantically interpretable, but cannot be identified syntactically. User options are provided to control how expressions are determined to be interpretable. Identification techniques analyze functions and sub-expressions to determine if they have associated evaluable specifications or are pre-defined constants.
The primary inputs to the Bedrock Expression Interpreter are a parsed expression in ROM form representing the expression to be evaluated and a symbol table representing the expression’s context. The primary output will be an expression in AST form representing the resulting value and diagnostic messages in XML form. Interpreter options will be provided via command line options or an XML configuration file. An XML interface for AST elements will be provided to support integration with third party tools.
Bedrock Expression Simplifier
The Bedrock Expression Simplifier applies a collection of Rosetta simplification routines to an expression in its declared context, reducing it to a simplified, normal form. In early design stages where Rosetta is most applicable, complete information is frequently unavaiable. At the same time, assessing available information for inconsistencies and errors is vital to the design process. Simplifying Rosetta expressions provides a window into the correctness of requirements early in the design phase. Furthermore, reducing expressions to a normal form provides an interface to downstream analysis tools. The Bedrock Expression Simplifier’s interface is identical to the Bedrock Expression Interpreter. The difference being that the output of the Bedrock Expression Simplifier is not specified to be a Rosetta value. The Bedrock Expression Simplifier reduces an expression to a normal form that may or may not be a value.
The Bedrock Expression Simplifier provides an enabling technology useful for evaluating collections of term expressions that define facets. By reducing expressions to a normal forn, tools for evaluating facets can target a single expression format. This allows Cadstone Bedrock tools to address a single input form rather than attempting to solve all forms in the general case. This also allows integration of commercial off-the-shelf decision procedures, inference tools, SAT solvers and model checkers. As such, the cost of producing full facet analyzers is substantially reducde.
Top >>
Bedrock Facet Evaluation
The Cadstone Bedrock Facet Evaluators provide a basis for solving collections of expressions that define facet models in order to understand the meaning and consistency of those models. The Bedrock Facet Evaluators represent the ultimate in Rosetta anslysis providing the user with means for understand individual specifications and collections of specifications under composition. Using the Bedrock Facet Evaluator, users will for the first time understand the impacts of high-level requirements decisions and understand systematic effects of local decision decisions.
The Bedrock Facet Simulator takes advantage of a prescriptive subset of the Rosetta language suitable for traditional simulation. The Bedrock Facet Interpreter uses traditional equation solving techniques to attempt to evaluate and/or simulate facet models. Because Rosetta is not an executable language, the Bedrock Facet Simulator is limited to a subset of the language. Various subsets will be supported with associated analysis and inference tools. The Bedrock Interaction Interpreter allows simultaneous analysis of different component and system models with the ability to merge analysis results to determine model consistency.
Bedrock Facet Simulator
The Bedrock Facet Simulator provides a capability for simulating a basic subset of Rosetta specifications using state-based models of computation. If a Rosetta facet model is defined by asserting relationships between the current statte and current inputs and the next state, the Bedrock Facet Simulator is an appicable tool. Models where the Bedrock Facet Simulator is particularly useful include abstract state machines and sequential systems, analog systems, safety and liveness, security, power analysis and heat dissipation.
The Bedrock Facet Simulator accepts a facet model and sets of data streams associated with facet inputs. Like traditional simulation, the facet is instantiated and solved for each set of inputs sequentially. The resulting state is used as the initial state for the next calculation. By observing state and output values, the user can explore the behavior of state-based systems. Because such Rosetta models may be abstract and incomplete, the Bedrock Facet Simulator is particularly useful in early requirements analysis processes, making the Bedrock Facet Simulator a central tool in the evaluation process.
The Bedrock Facet Simulator uses a prescriptive subset of Rosetta to define models that are similar in nature to models defined for other hardware description languages. Specifically, the Bedrock Facet Simulator supports specification of systems whose terms constrain values of variables and parameters in a future state using equality. For example, terms of the form x’=x+1 where a variable in the next state is equal to an expression of variables in the current state are allowed. The Bedrock Expression Interpreter is used to evaluate the right-hand-side expression to determine a value for the left-hand-side variable in the next state. Due to the prescripive form of the terms, the Bedrock Expression Interpreter can obtain the appropriate value.
The Bedrock Facet Simulator allows the engineer to evaluate individual models for different models separately and following their composition. When exploring power consumption and functional correctness for example, Separate model simulation reveals properties in individual models during debugging and testing. Composite model simulation reveals properties resulting from heterogeneous model composition. Specifically, a power-aware functional model can be generated and simulated to see the effects of function on power consumption. Such models are generated using the Bedrock Interaction Interpreter.
Bedrock Facet Interpreter
The Cadstone Bedrock Facet Interpreter addresses a larger, less restrictive collection of Rosetta specifications than the Bedrock Facet Simulator. However, it may not generate a unique next-state description for any give set of inputs. Like the Bedrock Facet Simulator, the Bedrock Facet Interpreter accepts a facet and a collection of input data streams for facet inputs. Neither the input streems nor the facet model need be complete descriptions. Partial data is allowed to support exploration of high-level requirements specifications to discover inconsistencies and errors. The Bedrock Facet Interpreter produces a sequence of state descriptions that define properties that are known in each subsquent state. The designer can explore these properties to understand design characteristics early in the requirements analysis process. As more details are added, the Bedrock Facet Interpreter provides more information to the designer.
When exploring high-level requirements, the Bedrock Facet Interpreter is exactly the right tool. As requirements frequently represent abstract ideas and properties, providing too much detail is harmful. Using the Bedrock Facet Interpreter, only the detail required by the user is necessary. The Bedrock Expression Simplifier is used to get facet terms in a normal form. Collections of terms are then examined to determine if important properties are present or error properties are absent. If desired properties hold, enough detail has been provided by the requirements to assure correct implementation. If undesired properties hold, requirements are known to be in error. If properties cannot be derived, then the user knows that not enough detail is present in the specification.
The Bedrock Facet Interpreter can also be used to check design refinements to ensure preservation of requirements. When a requirements model is refined towards an implementation, the original properties can be checked in the refined design to determine if they are conserved. Checking in this manner allows the user to be confident that they are defining their system correctly and moving towards a correct system.
The Bedrock Facet Interpreter uses term rewriting traditional simultaneous equation solving techniques to find consistent assignments for facet variables and parameters under the constraints of terms and other values. The Bedrock Facet Interpreter can be used to provide a simulation capability and will support nondeterministic system exploration. Such systems frequently occur at high levels of abstraction during system-level design activities.
Top >>
Bedrock Interaction Interpreter
The Cadstond Bedrock Interaction Interpreter provides a capability for evaluating the results of interactions between domains in a system specification. Traditional specification analysis systems look at systems one domain at a time, not allowing the user to explore impacts of local decisions on systems-level propertiesl The Bedrock Interaction Interpreter uses the Bedrock Exression Evaluator and the Bedrock Facet Interpreter along with specification composition techniques to understand how specifiations written in completely distinct domains impact each other. Examples of such interactions include the impacts of heat dissipation on packaging, software execution on power consumption, and functional design decisions on security.
The Interaction Interpreter centers on specification sums defined in the Rosetta specification. Essentially, a facet product defines when two specifrications simultaneously define the same system. Thus, for the system to be correct, both specifications must be simultaneously satisfiecd. If those specifications are orthogonal, having no interact, the problem is simple. In systems-design, this situation rarely, if ever occurs.
When defining specification compositions between domains, Rosetta uses an interaction to define how specifications react to each other. An interaction is a specification that defines how information is translated from one domain into another. When a facet is interpreterd, the interaction is used to translate interpretation results to other domains. Thus, traditional tools can be used to analyze the specification with this new information.
The Bedrock Interaction Interpreter provides exactly the modeling capability required by the system engineer. For example, given a power model and a functional model with an interaction defined between them, the Interaction Interpreter generates a single model encorporating both sets of requirements. The impact of functional design changes on power consumption is immediately known. In contrast, current tools require exceptionally detailed models to find similar problems, delaying the discovery of important errors. With the Cadstone toolset, this delay can be avoided resulting signficant cost savings. No other tool suite offers this advanced capability.
Top >>
Software Delivery and Integration
The Bedrock Facet Simulators and Interpreters are built upon a highly extensible and flexible interpreter infrastructure. The infrastructure allows Cadstone to quickly and effectively field new simulators and interpreters for new Rosetta domains. In many cases, customers will be able to design and develop their own domain specific interpretation capabilities. The Bedrock Infrastructure provides both an interpretation capability and a powerful theorem prover for native Rosetta specifications.
Software Distribution
Software distribution will take the form of executable libraries and executable command line tools. Executable libraries will support integration with third party analysis tools. Command line tools will support direct execution of software components and integration into third party tools.
Software will be available under the Windows XP, Macintosh OS X, and RedHat Linux environments. Versions supported will include the current MS Windows version, RedHat and Macintosh OS X. Every effort will be made to maintain executables in current operating system environments. However, software is dependent on third party interpreter and compiler tools that must be upgraded before Cadstone software. Every effort will be make to keep customers informed of update status.
Software Interfaces
The Cadstone toolset is packaged as a library of system calls with documented API interfaces. The toolset is highly flexible and design to be integrated into value-added solutions. We have selected XML as our tool interchange format due to its growing acceptance in the larger computing community and due to its highly flexible representation capabilities.
An XML form of the internal Rosetta Object Model will be used to integrate the Rosetta front-end model analysis tools with customer developed back-end tools. The XML output will be generated from the parser directly as an abstract syntax tree representation or from the semantic analysis tools as an augmented abstract syntax tree. In addition to representing the syntactic form of the Rosetta source, the augmented AST will include links between instances and declarations in the XML model as well as annotations of semantic information. The augmented XML AST will support generation of application specific data structures that allow fast reference to semantic information when a symbol is encountered in a model. Rosetta tool builders may use the XML structure directly, or generate native data structures in their programming language of choice.
Tool outputs, including diagnostic information, will also take the form of XML structures to facilitate processing and display in down-stream Rosetta tools. The output XML will provide detailed debugging and diagnostic information describing the results of tool execution. This will range from simple identification of syntax and semantic error during source parsing and linking as well as detailed dump information describing the status of complex static and dynamic checking.
Tool inputs depend on the specific application. Most include: (i) standard Rosetta source code; (ii) parsed Rosetta in XML form; or (iii) other information in XML form. The Rosetta parser will accept Rosetta source for application specifications and library files. An intermediate parsed form for libraries will be supported in future releases. Downstream tools will accept native parser structures and parsed Rosetta in XML form. Tool options for all tools will be expressed using XML to facilitate easy integration with user defined tools and environments.
Top >>
