Conference PaperPDF Available

A formal high level synthesis approach for DSP architectures

Authors:

Abstract

An approach is presented for high-level synthesis of digital signal processing (DSP) algorithms. Two features are provided by the approach: completeness and correctness. A given algorithm is represented in a newly developed language termed the algorithm specification language (ASL). ASL had the ability to describe any general algorithm. An automatic procedure is used to transform an ASL representation into a specific realization specification using a correctness preserving set of transformations. The realization format is based on representing the digital architectures by another language called the realization specification language (RSL). Logic programming is used as a user interface for the synthesis procedure
v2.2
A FORMAL HIGH LEVEL SYNTHESIS APPROACH FOR DSP ARCHITECTURES
Khaled
hl.
Elleithy and Magdy
A.
Bayoumi
The Center For Advanced Computer Studies
University of Southwestern Louisiana
Lafayette, L.4
70504,
U.S.A.
ABSTRACT
In this paper, we introduce a novel approach for high level syn-
Lhesis for DSP algorithms. Two features are provided by the
approach:
completeness
and
correctness.
A
given algorithm will be
represented in a new developed language termed Algorithm
Specification Language (ASL). ASL has the abilit,y to describe any
general algorithm.
An
automatic procedure is used to transform an
ASL representation into a specific realization specification using a
correctness preserving set of transformations. The realization format
is based on representing the digital architectures by another
developed language called Realization Specification Language(RSL).
Logic Programming is used
as
a user interface for the synthesis pro-
cedure.
1.
Introduction
Although Digital Signal Processing (DSP) has emerged
as
a
major technological application area, DSP design tools has not pro-
gressed enough to meet the challenges of the new applications require-
ments. The difficulty of developing such tools is that the chip design
involves several levels of abstraction; starting from system level
specification to the geometrical layout. The lowest level of this spec-
trum is understood sufficiently well to be fairly automated, while,
developing design methods for high level synthesis is still in its
infancy stage.
Synthesising a
VLSI
architecture for a DSP algorithm starting
from a behavioral description have been reported in a number of
researches. Works reported in
[l-41
depend on using only a single
fixed architecture. Works reported in
[5-101
do not produce efficient
architectures
as
a result of huge underutilized communications.
Haroun and Elmasry
[11]
introduced an approach to overcome the
previous problems. Generalized Signal flow graphs (GSFG) are used
to describe the input algorithm. A number of restrictions should be
satisfied by the used GSFG.
High level synthesis approaches
for
DSP algorithms don’t only
suffer from the previous drawbacks, but also they don’t address two
focal points:
Completeness
and
Correcfness.
Reported approaches
aren’t capable of transforming a general DSP algorithm to a digital
Architecture. There are approachs to transform the class of linear
recursive algorithms to digital circuit, approaches to transform regu-
Inr
itcrative algorit,hms to svqtolic
arravs.
and approaches
fc..
synthesising a specific algorithm. For the correctness aspect a form
approach is required for the synthesis process to assert the correetn,
of
the high level synthesis techniques.
In this paper, we introduce a novel approach for high level
sy~
thesis that provides two main features:
completeness
and
correctnes.5
Completeness means the ability to use the approach for any general
algorithm. Correctness is achieved by using a set of transformation.
that are proved to be correct. A formal framework for the synthesis
procedure will be developed which can be easily automated.
2.
System Overview
The proposed framework for synthesising any DSP algorithm is
shown in Figure
1.
The system is composed from two subsystems:
synthesis subsystem and user-interface subsystem.
2.1
Synthesis Subsystem
(1)
The given algorithm is specified in
a
new language, termed ASL,
which is based on precursive functions. ASL is capable of specifying
any algorithm using a-limited number of constructs. Although the
constructs are very primitive, complex constructs can be used through
a developed cell library. Units that have been designed through this
design methodology can be added to the cell library.
(2)
A transformation technique is developed to transform an algo-
rithm represented in ASL to a specific realization language, termed
RSL. The RSL version specifies the components and connectivity of
the digital architecture that realizes the algorithm. Every construct
in ASL has an isomorphic representation in RSL, which is the basis
of
the automated transformation. That transformation algorithm is
proved to be correct. Everything in the system
is
built from certain
primitives. The proofs of correctness are applied to these primitives.
A hierarchical proof is used for ensuring correctness at different levels.
(3)
A library of the basic functions is defined starting from the initial
functions to be used in the definition
of
larger functions. This
approach is useful for building a cell library to support the
automated synthesis system. All the basic functions that have been
designed using the proposed approach can be used
for
specifying
other functions. This technique supports a hierarchical design metho-
dology in the sense that the specification can be stopped at any level
as
long as the lower levels were previously defined. When
Basic
func-
tiozls
are used to represent another functions, each
Basic
function
is
written in a
M
.
2.2
User Interface Subsystem
The user interface environment that is used
for
the synthesis
process will be implemented
as
a logic programming environraent.
The logic programming environment supports specifying, simulating,
and testing Digital Signal Processing (DSP) systems. Backtracking
and
pattern matching of Prolog are employed for simulation and
.I,-.I
I
~g,
respcctively. Prolog provides homogeneity to the developed
-\
-I
6
in
as
it
supports hierarchical development and mixing of
description at various hierarchical levels. It can be employed
for
many DSP algorithms and applications development.
Two transformation algorithms are used to link the synthesis
subsystem and the user interface subsystem. The purpose of these
two algorithms is to allow the user to use the system through the
logic programming environment without the need to know the details
of
ASL and RSL. The two algorithms are
as
follows:
897
CH2847-2/90/0000-0897
$1.00
0
1990
IEEE
Authorized licensed use limited to: University of Bridgeport. Downloaded on February 24,2010 at 12:55:48 EST from IEEE Xplore. Restrictions apply.
Prolog
Source
Simulation
(Design
Evaluation)
ransfor matio
Algorithm
output
Product
then the unbounded minimization
of
z
is an n-argument function
.I.
I
I
defined
as
follows:
Fig.
1.
System Overview.
(1) The first algorithm is used to transform between Prolog and
ASL.
This transformation algorithm allows the user to specify his algo-
rithm in terms of Prolog.
(2)
The second algorithm is used
to
transform between the RSL and
prolog. This algorithm allows
us
to have the output circuit specified
in Prolog.
3.
Algorithm Specification Language
(ASL)
Several researches have been reported for specifying the input
algorithm. Imperative languages have been used such
as:
For-
tran
[
121, Pascal
[
131,
ISPS
[
14,151, and VHDL
[
161. Applicative
languages have been used such
as:
Recursion equation based
specification[l7] and Temporal Logic[l8,19].
The design specification language must be simple and semanti-
cally well characterized. It must permit writing specifications using
a
few predefined objects and concepts
as
possible. Specifications must
not be prematurely committed to particular implementations.
Current hardware specification languages are far from this ideal.
The idea of representing an algorithm using a
junctional
representation
was introduced by Kleene[2O] in which any function
from numbers(strings) to numbers(strings) can be constructed using
very primitive functions and combining them in a specific manner.
Our approach for specifying an algorithm depends on using
F-
recur-
sive
junctions
as
a framework.
The Language consists of
Initial Functions
and
Operations.
Initial functions are very primitive functions. Three initial functions
are used:
(1)
The
zero
function which returns the value zero.
(2) The
projection
function has a
K
argument and we use it to
choose argument i.
(3) The
successor
function which increments its input by one.
Three operations are used
to
construct larger functions from smaller
functions:
(1)
(2)
(3)
(4)
(5)
(6) It is complete.
A complete description of the language syntax can be found in[2l]
Simple and semantically well characterized
It permits writing specifications using a few predefined objects
and concepts.
It is a suitable tool for formal synthesis.
It supports a hierarchical design methodology.
It supports formal verification of the initial specification.
4.
Realization Specification Language (RSL)
4.1
Realization Specification Language
The realization introduced here is described at the architectural
level. The specification describes two elements of a circuit: the com-
ponents and the connectivity. The physical parameters of the circuit
are not addressed at this level of specification. The timing is not
expressed explicitly, but implicitly in terms of
registers
.
The sym-
bol
p
is used to represent a register.
If
it is required to initialize the
register to a certain value
8,
then this is represented
as
PB.
(1)
If unit is a certain component that is used in the system, and inp
is any input
for
unit, then we can use this input explicitly using the
following syntax:
unit,.,
Also
an output(out)
of
unit can be used
as
follows:
unit
OY’
(2)
Identifiers starting with upper case letters are used to represent
units that will be further expressed at lower levels. Identifiers starting
with lower case letters will be used to express Basic functions.
Identifiers starting with lower case letters are used also to represent
constants, while those starting with upper case letters are used to
represent temporary variables used in computation.
(3)
Register
If it is required to use a register
Q
that is initialized to a
value
@,
then this is expressed
as
pf.
As
an Example the expression
p$suc(I)
means that
suc
unit has the register
1
connected to its input
with a value
2
as
the register initial value.
Init
statement is a
RSL
expression that can be used separately to express that register
alhpa
is
initialized to value
,9
as
follows:
Init(a,@)
Another version of Init can be used to denote the initialization of
more than one register at the same time, this is represented
as
fol-
10\vs:
The previous statement means that
n
registers are initialized in
parallel such that register
a,
is initialized with the value
@,,
register
eZ
is initialized with the value
B2,
etc
...
Notice that using registers is
the only way to represent time in
our
circuits. It is assumed that all
registers are synchronized using a global clock.
In;tp(~,,B,
,
ad2
,
. . .
Q,
.Bn
i
898
Authorized licensed use limited to: University of Bridgeport. Downloaded on February 24,2010 at 12:55:48 EST from IEEE Xplore. Restrictions apply.
('I)
Constant
values are expressed using registers.
If
it is requir.4
to
I~nve
a constant value
(c)
in the circuit,, then this is represented
as
p
If
it is required to represent the zero function directly the following
specification is used:
Result
=
zero
zeroReadY
=
zeroConlra,
4.2
Transformation Algorithm
The transformation algorithm is based on using a one-bone
mapping procedure. The algorithm takes an ASL representation and
transform each ASL's construct to an equivalent RSL representation
and an equivalent architecture implementation. The complete algo-
rithm is given in(2l].
5.Implementation
of
an Inner-product Cell
An example of an Inner-product cell is introduced in this sec-
tion. The cell has three inputs
Q,
6,
and
c,
and an output
d.
The
function of the cell is specified by:
d
=
a*b
i
c
The implementation of this equation is done in two levels. At the
first
level we need to multiply
A
and
B.
The multiplication is done
in a recursive way using repetitive addition. This can be simply
drscrihed by the following high level subroutine:
inultiplication
(n,ni)
begin
iJ
(
n
=
0)
then result
=
ni
else
begin
temp
=
iiiultiplication
((n-l),ni)
result
=
addition
(
temp,
711)
end
end
The second level
of
the process is an implementation of the addition
operation. The addition is done also recursively and can be described
as
follows:
addition (n,m)
begin
q(
n
=
1)
then result
=
m
else
begin
temp
=
addition ((n-l),m)
remit
=
increment (temp)
end
end
TI),.
operation of the cell can
he
described
as
follows:
innrr-product
(a,b,c)
begin
iJ
(
c
=
0)
then result
=
multiplication
(
a,
b)
else
begin
temp
=
inner-product
(a,b,
c-1)
result
=
increment
(
temp
)
end
end
Other representations may be found for the inner-product cell. We
are not trying to find all representations
at
this level, but we want to
mention that different representations can affect the find design. Fig-
ure
2
shows the implementation of the
Inner-product
cell, and
Appendix
I
shows the complete ASL and RSL description of this
example.
6.
Logic Programming Interface
In this section we will show how the algorithm specified in ASL
can be represented in the logic programming environment. The fol-
Ready
E41"
)
P4
Fig.
2.
Iniplenientatiou
of
,ti?
Itirter-product.
Cell
lowing steps represents the transformation algorithm:
(1)
Zero function:
is represented by the following fact:
zero
(0)
(2)
Projection function:
is represented by the following code:
pro.fect(O,l,[
I).
project(l,lX
I
YIX)
projeet(M,(X
I
Y],Result)
'-
MI
is
M-1,
project(M
1,
Y,Result
).
(3)
Successor function:
is
implemented
as
follows:
suc(N,M)
.-
M
is
N+1
(4)
Composition
is implemented
as
follow:
z,
code
z,
code
y
code
(5)
Primitive recursion:
is expressed in the following manner:
code
for
z
code
for
y
z(Arg,,
. . .
,Arg,,O,Result)
-
z(Arg,,
z(Arg,,
. .
.
,Arg,,M,Result)
:-
M1
is
M-1
,
z(Argl,
.
' '
,Arg,,Ml,Tenip),
''
,Arg,,Result).
.v(Av,,
. .
.
,Arg,,Ml,Temp).
(6)
Unbounded minimization:
is represented in the following way:
Conclusions
In this paper
a
procedure
for
transforming general
DSP
algo-
rithm to
a
digital architecture is introduced. The proposed framework
has the following advantages:
(I)
It is suitable
for
large problems since it
does
not require solving
any
NP-C
problems.
(2)
The transformation algorithm is linear.
(3)
It does not require to know the target architecture in advance.
(4)
There are no restrictions imposed on the input description.
899
Authorized licensed use limited to: University of Bridgeport. Downloaded on February 24,2010 at 12:55:48 EST from IEEE Xplore. Restrictions apply.
The technique can be fully automated
The designer is not responsible
for
specifying the operation-
sequencing
and
communications among different units.
The approach
is
applicable to any general algorithm.
Result,
=
zero
Result2
=
muzl(arg,
,
arg,
,
arg,
#
1)
Result,
=
muzdargi
,
arg2,
arq,
#
3)
Result,
=
addldResult2
~
Result,
#
add)
Initp(0,m
,
1.n)
.surronf,n,
=
tern
I
-
p:
snc(I)
Result
-
P~O(~,I,P&~I~~
#
add,,)
Ready
-
egP(I,m)
The addition unit code:
Result,
=
muz,(argl
#
1)
Res&
=
muzdarg,
,
arg2
,
args
#
3)
Result,
-
Q(Result,#suc)
I
Rule,
Initp(0,m
;
1,n)
~uc,,,~,,~
=
Resultydy
I
=
p:
suc(I)
Result
-
add(n,I,p&,,~tl
#
&)
Ready
=
eg?(I,m)
I
Rules+
The inner-product cell code:
Resultl
=
muz,(arg,, arg2, arg,, arg4
#
1)
I
Rule5
Resultp
=
muzdarg,,
wg2,
arg,,
arg,
#
4)
Result,
=
temp(Result,, Result,
#
pro)
Result,
=
muzdarg,, arg2, arg,, arg,
#
4)
Results
=
add-one(Result,
#
X)
Initp(0,m
,
1,n)
suc,,,,,.~
=
resultFndy
I
=
p:
suc(I)
25)
Ready
=
egP(1,m)
(26)
Result
=
inner-product(n,I,p~,,,,,
#add-one)
(27)
References
J.
Rabaey,
Ss.
Pope, and R. Broderson, "An Integrated Automatic
Layout Generation System," IEEE Trans. Computer-Aided Design,
vol.
CAD-4,
pp
285-296,
July
1985
B Petersen,
B.
White, D. Solomon, and
M
Elmasry. "SPIL. A Silicon
Compiler with Performance Evaluation," Proc ICCAD, pp.
500503,
Nov
1986.
P
Rutez et al., "Computer Generation of Digital Filter Banks," IEEE
Trans. Computer-Aided Design, vol CAD-5, pp.
256265,
Apr
1986
J.
Schuck, M. Glesner, and M. Lacken, 'Tirst Results and Design
Experience with Silicon Compiler ALGIC,"
VLSl
Signal Processing
11,
IEEE Press,
NY,
Nov
1986
C Gebotys and M.
I.
Elmasry,
'%SI
Design Synthesis with Testabil-
ity,"
25th
Design Automation Conf., pp.
1621, 1988.
M
McFarland, "Using Bottom up Design Techniques in Synthesis of
Digital Hardware from Abstract Behavioral Descriptions,"
Proc
Twenty-third Design Automation Conf
,
pp.
474480, 1986.
B. Pangrie and Gajski, "State Synthesis
&
Connectivity Binding for
Microarchitecture compilation," Proc. ICCAD
86,
Nov.
1986.
P Paulin,
J.
Knight, and E. Gyrezyc,
"HAL
A multi-paradigm
Approach to Automatic Data Path Synthesis," Proc Twenty-third
Design Automation Conf., pp.
263-270, 1986
A. Parker, J. Pizarro, and
M.
Mlinon,
'MAHA
A program for Data
Path Synthesis," Twenty-third Design Automation Conf
,
pp
461-466,
1986.
N.
Park and A. Parker, "Sehwa. A Software Package for Synthesis of
Pipelines from Behavioral Specifications," IEEE Trans Computer
Aided Design, vol.
7,
pp.
356370,
Mar.
1988.
B. Haroun and M.
I.
Elmasry, "Architectural Synthesis for DSP Silicon
Compilers," IEEE Trans. on Computer Aided Design,
Vol.
8,
pp.
431-
447,
Apr.
1989
T. Tanaka, T. Kobayashi and
0.
Karatsu, "HARP Fortran
to
Sili-
con," IEEE Trans. on computer-aided design, vol
8.,
no
6.,
pp
64%
660,
June
1989.
H Trickey, "Flamel: A High Level Hardware Compiler," IEEE Trans
on
Computer Aided Design, vol. CAD-6, no.
2,
pp.
259-269,
March
1987
L J. Hafer and A C. Parker, "Automated Synthesis of Digital
Hardware," IEEE Trans. Computer,
Vol
C-31,
pp
93-109,
Feb
1982
T
J.
Kowalski and D E Thomas, "The
VLSI
Design Automation
Assistant: Prototype System," Twenty Design Automation Conf
Proc., Miami, pp.
479-483, 1983
L. F Saunders, "The IBM VHDL Design System," Twenty Fourth
Design Automation Conf
,
pp.
484-490, 1987
S.
D Johnson, "Synthesis of Digital Designs from Recursion Equa-
tions," Ph.D. Dissertation, Comp. Sc Dept
,
Indiana Uni
,
1983
G
V
Bochmann, "Hardware Specification with Temporal Loglc Ali
Example."
IEEE Transactions on Computers.
Vol
C-31, March
1982
B
Moszkowski, "A Temporal Logic for Multilevel Reasoning about
Hardware," Computer,
Vol.
18,
pp.
1019,
Feb
1985
S.
C. Kleene, "General Recursive Functions
of
Natural Numbers,"
Mathematische Annalen, pp.
727-742, 1936.
K
M. Elleithy and M. A. Bayoumi "A Framework
for
High Level
Synthesis
of
Digital Architectures from precursive Algorithms,"
Accepted for inclusion in the ACM
1990
Computer Science Conf
,
Washington, DC, Feb
1990
900
Authorized licensed use limited to: University of Bridgeport. Downloaded on February 24,2010 at 12:55:48 EST from IEEE Xplore. Restrictions apply.
... If xi (16i < n ) are n-1 place functions, z is n place functions, y is 2n place function and w!? are n place functions, then z is defined by the following Algorithm Specification Linguage (ASL) [12-141 code: Transformation Algorithm to RSL To transform the system of recursion with respect to several variables to the Realization Specification Language RSL [12][13][14] representation we implement each equation using the same method described in [12][13][14]. Here is the RSL representation of the system: Equation 1 is used to show that we use n registers to be initialized with the arguments (argl, . . . ...
... If xi (16i < n ) are n-1 place functions, z is n place functions, y is 2n place function and w!? are n place functions, then z is defined by the following Algorithm Specification Linguage (ASL) [12-141 code: Transformation Algorithm to RSL To transform the system of recursion with respect to several variables to the Realization Specification Language RSL [12][13][14] representation we implement each equation using the same method described in [12][13][14]. Here is the RSL representation of the system: Equation 1 is used to show that we use n registers to be initialized with the arguments (argl, . . . ...
... To transform the system of nested recursion to RSL we implement each equation using the same method described in [12][13][14]. Here is the RSL representation of the double nested recursion: ...
Conference Paper
Full-text available
The authors introduce a formal approach for synthesis of array architectures. The methodology provides two main features: completeness and correctness. Completeness means the ability to use the approach for any general algorithm. Correctness is achieved by using a set of transformations that are proved to be correct. Four different forms are used to express the input algorithm: simultaneous recursion, recursion with respect to different variables, fixed nesting, and variable nesting. Four different architectures for the same algorithm are obtained. As an example, a matrix-matrix multiplication algorithm is used to obtain four different optimal architectures. The different architectures of this example are compared in terms of area, time, broadcasting, and required hardware
... To transform the system of nested recursion to RSL we implement each equation using the same method described in121314. Here is the RSL representation of the double nested recursion: ...
Data
In this paper, we introduce a formal approach for synthesis of array architectures. Four different fovms are used t o express the input algorithm: simultaneous recursion, recursion with respect t o dsferent vari-ables, fixed nesting and variable nesting. Four different architectures for the same algorithm are obtained. As an example, a matrix-matrix multi-plication algorithm is used t o obtain four different optimal architectures. The dtfferent architectures of this example are compared in terms of area, time, broadcasting and required hardware.
... To transform the system of nested recursion to RSL we implement each equation using the same method described in121314. Here is the RSL representation of the double nested recursion: ...
Data
In this paper, we introduce a formal approach for synthesis of array architectures. Four different fovms are used t o express the input algorithm: simultaneous recursion, recursion with respect t o dsferent vari-ables, fixed nesting and variable nesting. Four different architectures for the same algorithm are obtained. As an example, a matrix-matrix multi-plication algorithm is used t o obtain four different optimal architectures. The dtfferent architectures of this example are compared in terms of area, time, broadcasting and required hardware.
Conference Paper
Full-text available
A formal design methodology is used to design a residue Number System (RNS) processor. An optimal architecture for the residue decoding process is obtained through this design approach. The architecture is modular, consists of simple cells, and is general for any set of moduli
Conference Paper
Full-text available
The major drawback of reported high level synthesis techniques is their limited applicability to a specific class of algorithms without extendibility to general algorithms and the lack of a formal approach to prove the correctness of the such techniques. In this paper, we introduce a novel approach for high level synthesis from μ-recursive algorithms. Two features are provided by the approach: completeness and correctness. Completeness means the ability to use the approach for any general algorithm. Correctness is achieved by using a set of transformations that are proved to be correct. A formal framework for the synthesis procedure has been developed which can be easily automated. A given algorithm will be represented in a new developed language termed Algorithm Specification Language (ASL). ASL has the ability to describe any general algorithm. An automatic procedure is used to transform an ASL representation into a specific realization specification using a correctness preserving set of transformations. The realization format is based on representing the digital architectures by a Realization Specification Language(RSL).
Conference Paper
This paper describes an approach to VLSI design synthesis that uses knowledge-based expert systems to proceed from an algorithmic description of a VLSI system to a list of technology-independent registers, operators, data paths, and control signals. This paper describes how the prototype Design Automation Assistant uses large amounts of expert knowledge to design an architecture with little searching. It also presents the current design of a small microprocessor along with a discussion of improvements currently being added.
Conference Paper
MAHA is a program which implements an algorithm for register level synthesis of data paths from a data flow specification. The algorithm is based on a linear hardware assignment to critical path nodes, followed by a cost-based assignment using the concept of the freedom of a node to be scheduled. Functions with the least scheduling freedom are scheduled first. The program either minimizes cost, subject to a time constraint, or maximizes speed subject to a cost constraint. The implementation of this algorithm is presented using examples from the literature. MAHA is written in Franz LISP, and executes within minutes for problems of practical size on a VAX 11/780.
Conference Paper
A VLSI design synthesis approach with testability, area, and delay constraints is presented. This research differs from other synthesizers by implementing testability as part of the VLSI design solution. A binary tree data structure is used throughout the testable design search. Its bottom-up and top-down tree algorithms provide datapath allocation, constraint estimation, and feedback for design exploration. The partitioning and two-dimensional characteristics of the binary tree structure provide VLSI design floorplans and global information for test incorporation. An elliptical wave filter example has been used to illustrate the design synthesis with testability constraints methodology. Test methodologies such as multiple chain scan paths and BIST (built-in-self-testing) with different test schedules have been explored. Results show that the `best' testable design solution is not always the same as that obtained from the `best' design solution of an area and delay based synthesis search
Conference Paper
This paper presents the IBM VHDL Design System. This set of Computer Aided Engineering (CAE) design tools, built around the VHSIC Hardware Description Language (VHDL) and developed for IBM internal use, along with other design automation tools, is used by IBM design engineers to develop computer hardware. The function and operation of each piece of the system is described. IBM usage and some of the problems encountered are also discussed.
Conference Paper
A novel approach to automatic data path synthesis is presented. This approach features innovations in the synthesis process as well as in the system implementation. The synthesis process exhibits three new features. The first relates to a subtask that performs an expert analysis of the input data flow graph and attempts to evenly distribute operations requiring similar resources. This is done using a novel "load balancing" technique. The second consists of a global preselection of operator cells to fulfill an explicit speed constraint. Finally, the third deals with new techniques for register and multiplexer optimization. These features support extended design space search by taking an explicit performance specification into account. The system implementation is based on the LOOPS multiparadigm programming system. In this approach the overall task can be partitioned into complementary subtasks requiring different programming paradigms. These subtasks will be realized using an object-based paradigm, a knowledge-based expert system paradigm, a functional paradigm, or combinations of all three. Two complete examples are given to demonstrate the functionality of the system and to allow comparison with existing systems.
Conference Paper
This paper reports on a new method for using bottom-up design information in the synthesis of integrated circuits from abstract behavioral descriptions. There are two important ways in which this method differs from traditional top-down synthesis techniques. First, it draws on a newly developed procedural database to collect detailed information on the physical and logical properties of the primitives available for building the design. Second, it uses a different method for representing and organizing knowledge about a design that makes possible estimates of physical placement and wiring in the analysis of that design, even at the abstract register-transfer level. This allows a more accurate evaluation of candidate register-transfer designs without doing a full logic-level or transistor-level layout. It also leads to a simple method for systematically exploring the space of possible designs in order to find the one that best meets the designer's objectives and constraints.