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 E-mail: vystu@if.ktu.lt Phone: 370-37-300399

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

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

Domain Analysis: A General Framework

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

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

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.

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]

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

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]

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

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

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

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

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

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

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

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

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

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?

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

APPLICATION OF DESIGN PATTERNS FOR HARDWARE DESIGN Thank You for Your attention ! http://soften.ktu.lt/~stuik/dac03/