1. APPLICATION OF DESIGN PATTERNS FOR HARDWARE DESIGN
Authors: R. Damaševičius, G. Majauskas, V. Štuikys
Speaker: Prof. Vytautas ŠTUIKYS,
Software Engineering Department,
Kaunas University of Technology,
Kaunas, Lithuania
Phone:

2. Content Reuse Context & Motivation
Domain Analysis: Framework and Findings
Soft IP-Based System-Level Design Processes & Design Patterns (DP): Their Relationship
Implementation Using Metaprogramming (MPG)
MPG and DP-Based Design Framework
Experiments
Evaluation and Problems
Conclusions

3. Reuse Context & Aim of the Presentation
Reuse equations:
(1) Promises =
Quality + Productivity + Time-To-Market
(2) Reuse =
Domain content + Technology + ...
(3) Technology =
Component-based reuse + Generative reuse
(4) Activities =
Design Domain Analysis (DDA) + ...
Our aim:
To bridge DDA with automatic tools

4. Domain Analysis: A General Framework

5. Domain Analysis: A Summary of Findings
Trends:
Shift towards Integration-based Design
Blurring boundaries between HW & SW design
Well-understood sub-domains:
Communication-based design using well-proven communication models (Handshake, FIFO, etc.)
Fault-tolerant design using well-proven redundancy models (TRM, etc.)
Solutions for common design problems (System-Level Design Processes and Design Patterns)
Explicit separation of variant and invariant parts
Multi-language approach

6. HW Design Processes Based on Soft IP
Register Transfer-Level Design Processes
System-Level Design Processes

7. Layers of System-Level Design Processes
Specification layer: domain analysis and specification of design problems
inheritance, encapsulation, etc.
Generalization layer: analysis and specification of generic design solutions
separation of concerns
composition
Implementation layer: solutions of design problems using reuse technology
wrapping, etc.

8. Design Pattern: Definitions
The design pattern is ...
… “descriptions of communicating objects and classes that are customized to solve a general design problem in a particular context”
[E. Gamma et al., 1995]
… “both a description of a thing which is alive, and a description of the process which will generate that thing”
[C. Alexander, 1979]

9. System-Level Design Processes and Design Patterns: Relationship
Our definition:
A System-level HW design process is a common well-defined HW design activity aimed at designing a system from soft IPs at a high level of abstraction
A HW Design Pattern is the UML-based specification of a System-Level HW Design Process based on a well-proven design model

10. Design Patterns in Hardware Design
Pattern-like solutions proposed by others
models of computation/control: Finite State Machine
communication models: protocol, bus, communication co-processor
wrappers: reliability, bus, protocol, memory wrappers
Design patterns adapted from SW design:
Abstract Factory, State [Yoshida]
Resource Manager [Vanmeerbeeck et al.]
Composite, Object Adaptor, Abstract Factory and Decorator [Åström et al.]
Singleton [Charest and Aboulhamid]
New HW design patterns:
Bus-Protocol, DLX Processor Architecture [Doucet and Gupta]

11. Application of the OO Concepts for VHDL
Abstract class (interface) - VHDL entity
A class that implements an abstract class - VHDL architecture
The composition relationship - VHDL port map statement
Class attributes - VHDL ports and signals
Class methods –VHDL processes or procedures

12. Wrapper Design Pattern
Allows adapting an interface and behavior of the IP component to the context of a given application

13. Specification of Design Patterns Using Metaprogramming
Metaprogramming (MPG):
provides a means for manipulating with other programs as data at a higher level of abstraction
uses two different languages in the same generic specification
Metaprogram: a program generator for a narrow domain of application
Domain language (DL) (e.g., VHDL): describes domain functionality
Metalanguage (ML) (e.g., Java): describes generalization and domain program modifications at a higher level of abstraction

14. Summary of Metaprogramming Principles
CI – Component Instance
R – Requirements for modification/generalization
S – Separation of concerns
P – Parameterization
I – Integration of concerns
MP – Metaprogram

15. Framework of Our Approach: Implementation
(0) Design Domain Analysis (DDA): SL Design Process/ Design Pattern, Requirements and soft IP
(1) Metaprogramming: describe the domain program modifications depending upon the values of the generic parameters
(2) Parsing: use the soft IP interface as values of generic parameters for metaprograms
(3) ML processing: generate the soft IP wrapper

16. Experiments Based on Well-proven Models
Communication interface synthesis
Handshake Wrapper [see paper DAC 03]
FIFO Wrapper - next slide [for details INFORMATICA, see Ref. in DAC03]
Fault-tolerant design [submitted, not presented here]
Space Redundancy Wrapper
Time Redundancy Wrapper
Data Redundancy Wrapper

17. FIFO Wrapper Generator: Implementation
FIFO protocol is used in the producer-consumer communication model to smoothen bursts in the requests for a service

18. Evaluation of Design Specification
Advantages of using HW Design Patterns:
raise the level of abstraction
capture the design content immediately and intuitively using UML diagrams
enable the automated design validation and code generation
Shortcomings:
do not provide with a full HW design specification for its implementation

19. Evaluation of MPG-based Implementation
Metaprogramming (MPG):
bridges the Design Domain Analysis with Domain Generators
allows to adapt soft IPs to the context of application using well-proven domain models
increases the reusability and productivity when customizing third-party soft IPs

20. Problems yet to be solved
How the System-Level (SL) Design Processes described as the UML-based HW Design Patterns (DPs) could be (semi-) automatically transformed into metaprograms?
How the physical constraints (e.g., the timing ones) should be reflected in an OO model (DP)?
How the entire DP could be directly synthesized to RTL?
What is a more precise model for describing correspondence between soft IP-based SL Design Processes and DPs?
What is the best way for implementing DPs: MPG-based, OO-based or other?

21. Conclusions
The well-proven dimension of a SL Design Process (e.g. wrapping) is a Design Pattern
The Design Pattern brings the design content
Both soft IP and metaprogramming bring technology
Our methodology puts together the design content and technology, thus enabling better reuse, higher quality and productivity
Future work will focus on the discovery of other HW design patterns and the development of the HDL code generators for their implementation

22. APPLICATION OF DESIGN PATTERNS FOR HARDWARE DESIGN
Thank You
for Your attention !