System-Level Design With Rosetta Book

Acknowledgments     xvii
Foreword     xix
Preface     xxiii
Introduction     1
Introduction     3
What is System-Level Specification?     3
Rosetta's Design Goals     4
Anatomy of a Specification     6
Facets and Domains     6
Vertical Decomposition     8
Horizontal Decomposition     10
Vertical Decomposition - Revisited     11
Usage Requirements and Implications     12
Learning Rosetta     13
The Expression Language     17
Items, Values, Types, and Declarations     19
Labels, Values, and Types     19
Labels     20
Values     20
Types     21
Item Declarations and Type Assertions     22
Item Declarations     22
Type Assertions     25
Universal Operations     25
Expressions     29
Atomic Expressions     29
Function Application     30
Operator Application     31
If Expressions     33
Case Expressions     37
Let Expressions     40
CompoundExpressions     42
Elemental Types     45
The Boolean Type     45
The Number Types     47
Numbers     48
Complex Numbers     48
Real and Imaginary Numbers     52
Positive and Negative Numbers     54
Integer Numbers     55
Natural Numbers     56
Positive and Negative Integer Numbers     57
Bit Numbers     58
The Character Type     59
The Element Type     60
The Top and Bottom Types     60
Element Literals     61
Number Literals     62
Character Literals     64
Boolean Literals     64
The Undefined Literal     64
Operator Result Types     65
Composite Types     67
Type Formers     67
Set Types     68
Multiset Types     73
Sequence Types     78
The String Type     86
The Bitvector and Word Types     87
Functions     91
Direct Function Definition     92
Interpretable Functions     93
Qualified Interpretable Functions      96
Uninterpretable Functions     98
Qualified Uninterpretable Functions     98
Variable Functions     99
Qualified Variable Functions     99
Function Values and Function Types     101
Function Values     101
Function Types     102
Alternative Function Item Declaration     102
Evaluating Functions     103
Interpretable Functions     105
Curried Function Evaluation     108
Uninterpretable Functions     109
Qualified Functions     111
Universally Quantified Parameters     112
Higher-Order Functions     115
Domain, Range, and Return Functions     116
Alternate Higher-Order Function Notation     119
Minimum and Maximum     120
Quantifiers and Comprehension     121
Sequences and Higher-Order Functions     124
Function Inclusion and Composition     126
Function Inclusion     127
Function Composition     129
User-Defined Types     131
Defining New Types     132
Defining Types By Extension     135
Using Set Formation Operators     135
Enumerated Types      136
Defining Types By Comprehension     137
Using the Selection Function     137
Using the Range Function     137
Sets as Types - A Caution     138
Defining Constructed Types     138
Functions as Type Definition Tools     142
The Facet Language     145
Facet Basics     147
A First Model - An AM Modulator     148
Composing Models - Adding Constraints     150
Combinational Circuits - A Simple Adder     151
Defining State - A 2-bit Counter     153
Defining Structure - A 2-bit Adder     155
Specification Reuse - Using Packages     156
Abstract Specification - Architecture Definition     157
Defining Facets     161
Direct Facet Definition     162
Parameters     162
Universally Quantified Parameters     163
Declarations     164
Domain     164
Terms     165
Separable Definitions     171
Facets and Hardware Description Languages     174
Facet Styles     175
Property-Based Facets     175
Structural Facets     177
Mixed Facets      178
Scoping Rules     179
Basics of Facet Semantics     182
Facet Semantics     182
Facets and Type Semantics     184
Packages, Libraries, and Components     187
Packages     187
Defining Packages     189
Separable Definitions     189
Using Packages     190
The Working Package     191
Libraries     192
Library Definition     192
Referencing Library Elements     193
Predefined Libraries     193
Components     194
Defining Components     195
Separable Definitions     196
Accessing Component Elements     197
Using Components     198
Domains and Interactions     201
Domains     203
Elements of a Domain     203
Units of Semantics      204
Computation Models     205
Engineering Domain Definitions     206
The Standard Domains     207
The Null Domain     207
The Static Domain     208
The State-Based Domain     210
The Finite State Domain     214
The Infinite State Domain     217
Discrete Time Domain     218
The Continuous Time Domain     220
The Frequency Domain     224
Domains and Facet Types     225
Domains as Types     225
The Domain Semi-Lattice     227
Reflection     229
Template Expressions and AST Structures     229
Interpreting AST Structures     231
The value Function     232
The typeof Function     233
The denotes Function     233
The parse and string Functions     234
Domain Declarations     236
Defining Engineering Domains     238
Defining New Model-of-Computation Domains     239
Defining New Unit-of-Semantics Domains     239
Defining Ticked and Dereferencing Expressions     241
Calculus Functions     241
Dereferencing     244
Consistent Domain Extension     245
The Facet Algebra     247
Facet Products and Sums     247
The Shared Domain     248
The Sharing Clause     251
Implicit Sharing     254
Facet Homomorphism and Isomorphism     256
Conditional Expressions     257
Let Expressions     258
Higher-Order Facets     260
Domain Interactions     263
Projection Functions, Functors, and Combinators     263
Defining Projection Functions     264
Defining Morphisms and Functors     265
Defining Combinators     266
Defining Interactions     267
Translators     268
Functor Definitions     268
Combinator Definition     268
Including and Using Interactions     269
Translator Usage     270
Functor and Combinator Usage     270
Existing Rosetta Interactions     271
Semi-Lattice Interactions     271
Ad Hoc Interactions     272
Composite Interactions     274
Case Studies     279
Case Studies     281
Methodology     281
Identify System-Level Modeling Goals     282
Identify Basic Models and Domains     282
Define Basic Models     283
Construct Composite Models     283
Before Proceeding     284
Register-Transfer-Level Design     285
Requirements-Level Design     286
Basic Components     289
Multiplexer     289
Data Store     290
Counter and Comparator     291
Clock      291
Structural Design     292
Design Specification     293
Wrap Up     294
Power-Aware Design     297
The Basic Models     298
Power Constraints Model     298
Power Consumption Model     298
Functional Model     300
Composing System Models     301
The Composition Approach     302
Refining the Power Model     303
Transforming the Power Consumption Model     305
Refining the Power Models     306
Abstracting the Functional Model     307
Constructing the Simulations     308
Wrap Up     309
Analysis Results     310
Modeling Overview     312
Power-Aware Modeling Revisited     315
Technology-Specific Functional Models     315
Configurable Components     316
Decomposition     317
Mixed Technology Systems     322
Wrap Up     322
System-Level Networking     325
The Basic Models     325
Types, Constants, and Predicates     326
Access Control Requirements Model     328
Functional Requirements Model      329
Infrastructure Models     330
Composing System Models     334
Constructing the Analysis Models     336
Wrap Up     336
Bibliography     339
Index     343