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