O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

System-Level Design with Rosetta

Book Description

The steady and unabated increase in the capacity of silicon has brought the semiconductor industry to a watershed challenge. Now a single chip can integrate a radio transceiver, a network interface, multimedia functions, all the "glue" needed to hold it together as well as a design that allows the hardware and software to be reconfigured for future applications. Such complex heterogeneous systems demand a different design methodology. A consortium of industrial and government labs have created a new language and a new design methodology to support this effort. Rosetta permits designers to specify requirements and constraints independent of their low level implementation and to integrate the designs of domains as distinct as digital and analog electronics, and the mechanical, optical, fluidic and thermal subsystems with which they interact. In this book, Perry Alexander, one of the developers of Rosetta, provides a tutorial introduction to the language and the system-level design methodology it was designed to support.

Table of Contents

  1. Copyright
    1. Dedication
  2. In Praise of System-Level Design with Rosetta
  3. The Morgan Kaufmann Series in Systems on Silicon
  4. About the Author
  5. Acknowledgments
  6. Foreword
  7. Preface
  8. I. Introduction
    1. 1. Introduction
      1. 1.1. What is System-Level Specification?
      2. 1.2. Rosetta’s Design Goals
      3. 1.3. Anatomy of a Specification
        1. 1.3.1. Facets and Domains
        2. 1.3.2. Vertical Decomposition
        3. 1.3.3. Horizontal Decomposition
        4. 1.3.4. Vertical Decomposition — Revisited
        5. 1.3.5. Usage Requirements and Implications
      4. 1.4. Learning Rosetta
  9. II. The Expression Language
    1. 2. Items, Values, Types, and Declarations
      1. 2.1. Labels, Values, and Types
        1. 2.1.1. Labels
        2. 2.1.2. Values
        3. 2.1.3. Types
      2. 2.2. Item Declarations and Type Assertions
        1. 2.2.1. Item Declarations
        2. 2.2.2. Type Assertions
      3. 2.3. Universal Operations
    2. 3. Expressions
      1. 3.1. Atomic Expressions
      2. 3.2. Function Application
      3. 3.3. Operator Application
      4. 3.4. If Expressions
      5. 3.5. Case Expressions
      6. 3.6. Let Expressions
      7. 3.7. Compound Expressions
    3. 4. Elemental Types
      1. 4.1. The Boolean Type
      2. 4.2. The Number Types
        1. 4.2.1. Numbers
        2. 4.2.2. Complex Numbers
        3. 4.2.3. Real and Imaginary Numbers
        4. 4.2.4. Positive and Negative Numbers
        5. 4.2.5. Integer Numbers
        6. 4.2.6. Natural Numbers
        7. 4.2.7. Positive and Negative Integer Numbers
        8. 4.2.8. Bit Numbers
      3. 4.3. The Character Type
      4. 4.4. The Element Type
      5. 4.5. The Top and Bottom Types
      6. 4.6. Element Literals
        1. 4.6.1. Number Literals
        2. 4.6.2. Character Literals
        3. 4.6.3. Boolean Literals
        4. 4.6.4. The Undefined Literal
      7. 4.7. Operator Result Types
    4. 5. Composite Types
      1. 5.1. Type Formers
      2. 5.2. Set Types
      3. 5.3. Multiset Types
      4. 5.4. Sequence Types
        1. 5.4.1. The String Type
        2. 5.4.2. The Bitvector and Word Types
    5. 6. Functions
      1. 6.1. Direct Function Definition
        1. 6.1.1. Interpretable Functions
        2. 6.1.2. Qualified Interpretable Functions
        3. 6.1.3. Uninterpretable Functions
        4. 6.1.4. Qualified Uninterpretable Functions
        5. 6.1.5. Variable Functions
        6. 6.1.6. Qualified Variable Functions
      2. 6.2. Function Values and Function Types
        1. 6.2.1. Function Values
        2. 6.2.2. Function Types
        3. 6.2.3. Alternative Function Item Declaration
      3. 6.3. Evaluating Functions
        1. 6.3.1. Interpretable Functions
        2. 6.3.2. Curried Function Evaluation
        3. 6.3.3. Uninterpretable Functions
        4. 6.3.4. Qualified Functions
      4. 6.4. Universally Quantified Parameters
    6. 7. Higher-Order Functions
      1. 7.1. Domain, Range, and Return Functions
      2. 7.2. Alternate Higher-Order Function Notation
      3. 7.3. Minimum and Maximum
      4. 7.4. Quantifiers and Comprehension
      5. 7.5. Sequences and Higher-Order Functions
      6. 7.6. Function Inclusion and Composition
        1. 7.6.1. Function Inclusion
        2. 7.6.2. Function Composition
    7. 8. User-Defined Types
      1. 8.1. Defining New Types
      2. 8.2. Defining Types By Extension
        1. 8.2.1. Using Set Formation Operators
        2. 8.2.2. Enumerated Types
      3. 8.3. Defining Types By Comprehension
        1. 8.3.1. Using the Selection Function
        2. 8.3.2. Using the Range Function
        3. 8.3.3. Sets as Types — A Caution
      4. 8.4. Defining Constructed Types
      5. 8.5. Functions as Type Definition Tools
  10. III. The Facet Language
    1. 9. Facet Basics
      1. 9.1. A First Model—An AM Modulator
      2. 9.2. Composing Models—Adding Constraints
      3. 9.3. Combinational Circuits—A Simple Adder
      4. 9.4. Defining State—A 2-bit Counter
      5. 9.5. Defining Structure—A 2-bit Adder
      6. 9.6. Specification Reuse—Using Packages
      7. 9.7. Abstract Specification—Architecture Definition
    2. 10. Defining Facets
      1. 10.1. Direct Facet Definition
        1. 10.1.1. Parameters
        2. 10.1.2. Universally Quantified Parameters
        3. 10.1.3. Declarations
        4. 10.1.4. Domain
        5. 10.1.5. Terms
      2. 10.2. Separable Definitions
      3. 10.3. Facets and Hardware Description Languages
      4. 10.4. Facet Styles
        1. 10.4.1. Property-Based Facets
        2. 10.4.2. Structural Facets
        3. 10.4.3. Mixed Facets
      5. 10.5. Scoping Rules
      6. 10.6. Basics of Facet Semantics
        1. 10.6.1. Facet Semantics
        2. 10.6.2. Facets and Type Semantics
    3. 11. Packages, Libraries, and Components
      1. 11.1. Packages
        1. 11.1.1. Defining Packages
        2. 11.1.2. Separable Definitions
        3. 11.1.3. Using Packages
        4. 11.1.4. The Working Package
      2. 11.2. Libraries
        1. 11.2.1. Library Definition
        2. 11.2.2. Referencing Library Elements
        3. 11.2.3. Predefined Libraries
      3. 11.3. Components
        1. 11.3.1. Defining Components
        2. 11.3.2. Separable Definitions
        3. 11.3.3. Accessing Component Elements
        4. 11.3.4. Using Components
  11. IV. Domains and Interactions
    1. 12. Domains
      1. 12.1. Elements of a Domain
        1. 12.1.1. Units of Semantics
        2. 12.1.2. Computation Models
        3. 12.1.3. Engineering Domain Definitions
      2. 12.2. The Standard Domains
        1. 12.2.1. The Null Domain
        2. 12.2.2. The Static Domain
        3. 12.2.3. The State-Based Domain
        4. 12.2.4. The Finite State Domain
        5. 12.2.5. The Infinite State Domain
        6. 12.2.6. Discrete Time Domain
        7. 12.2.7. The Continuous Time Domain
        8. 12.2.8. The Frequency Domain
      3. 12.3. Domains and Facet Types
        1. 12.3.1. Domains as Types
        2. 12.3.2. The Domain Semi-Lattice
    2. 13. Reflection
      1. 13.1. Template Expressions and AST Structures
      2. 13.2. Interpreting AST Structures
        1. 13.2.1. The value Function
        2. 13.2.2. The typeof Function
        3. 13.2.3. The denotes Function
        4. 13.2.4. The parse and string Functions
      3. 13.3. Domain Declarations
      4. 13.4. Defining Engineering Domains
      5. 13.5. Defining New Model-of-Computation Domains
      6. 13.6. Defining New Unit-of-Semantics Domains
      7. 13.7. Defining Ticked and Dereferencing Expressions
        1. 13.7.1. Calculus Functions
        2. 13.7.2. Dereferencing
      8. 13.8. Consistent Domain Extension
    3. 14. The Facet Algebra
      1. 14.1. Facet Products and Sums
        1. 14.1.1. The Shared Domain
        2. 14.1.2. The Sharing Clause
        3. 14.1.3. Implicit Sharing
      2. 14.2. Facet Homomorphism and Isomorphism
      3. 14.3. Conditional Expressions
      4. 14.4. Let Expressions
      5. 14.5. Higher-Order Facets
    4. 15. Domain Interactions
      1. 15.1. Projection Functions, Functors, and Combinators
        1. 15.1.1. Defining Projection Functions
        2. 15.1.2. Defining Morphisms and Functors
        3. 15.1.3. Defining Combinators
      2. 15.2. Defining Interactions
        1. 15.2.1. Translators
        2. 15.2.2. Functor Definitions
        3. 15.2.3. Combinator Definition
      3. 15.3. Including and Using Interactions
        1. 15.3.1. Translator Usage
        2. 15.3.2. Functor and Combinator Usage
      4. 15.4. Existing Rosetta Interactions
        1. 15.4.1. Semi-Lattice Interactions
        2. 15.4.2. Ad Hoc Interactions
        3. 15.4.3. Composite Interactions
  12. V. Case Studies
    1. 16. Case Studies
      1. 16.1. Methodology
        1. 16.1.1. Identify System-Level Modeling Goals
        2. 16.1.2. Identify Basic Models and Domains
        3. 16.1.3. Define Basic Models
        4. 16.1.4. Construct Composite Models
      2. 16.2. Before Proceeding
    2. 17. Register-Transfer-Level Design
      1. 17.1. Requirements-Level Design
      2. 17.2. Basic Components
        1. 17.2.1. Multiplexer
        2. 17.2.2. Data Store
        3. 17.2.3. Counter and Comparator
        4. 17.2.4. Clock
      3. 17.3. Structural Design
      4. 17.4. Design Specification
      5. 17.5. Wrap Up
    3. 18. Power-Aware Design
      1. 18.1. The Basic Models
        1. 18.1.1. Power Constraints Model
        2. 18.1.2. Power Consumption Model
        3. 18.1.3. Functional Model
      2. 18.2. Composing System Models
        1. 18.2.1. The Composition Approach
        2. 18.2.2. Refining the Power Model
        3. 18.2.3. Transforming the Power Consumption Model
        4. 18.2.4. Refining the Power Models
        5. 18.2.5. Abstracting the Functional Model
      3. 18.3. Constructing the Simulations
      4. 18.4. Wrap Up
        1. 18.4.1. Analysis Results
        2. 18.4.2. Modeling Overview
    4. 19. Power-Aware Modeling Revisited
      1. 19.1. Technology-Specific Functional Models
      2. 19.2. Configurable Components
      3. 19.3. Decomposition
      4. 19.4. Mixed Technology Systems
      5. 19.5. Wrap Up
    5. 20. System-Level Networking
      1. 20.1. The Basic Models
        1. 20.1.1. Types, Constants, and Predicates
        2. 20.1.2. Access Control Requirements Model
        3. 20.1.3. Functional Requirements Model
        4. 20.1.4. Infrastructure Models
      2. 20.2. Composing System Models
      3. 20.3. Constructing the Analysis Models
      4. 20.4. Wrap Up
  13. Bibliography