U.S. patent application number 09/756568 was filed with the patent office on 2002-09-05 for process for fast cell placement in integrated circuit design.
Invention is credited to Andreev, Alexander E., Grinchuk, Mikhail I., Scepanovic, Ranko.
Application Number | 20020124233 09/756568 |
Document ID | / |
Family ID | 25044053 |
Filed Date | 2002-09-05 |
United States Patent
Application |
20020124233 |
Kind Code |
A1 |
Andreev, Alexander E. ; et
al. |
September 5, 2002 |
Process for fast cell placement in integrated circuit design
Abstract
A process for re-designing IC chips by altering the positions of
cells from a first to a second IC chip layout. An x,y grid is
established for the first and second IC layouts such that each cell
has identifying x,y coordinates in the first layout. Columns are
established in the second layout based on the bounds of the second
layout in the x-direction. The cells are sorted to the columns in
the order of cell x-coordinates to establish new x-coordinates for
each cell based on the x-coordinates of the respective column. The
cells are sorted in each column to establish y-coordinates for each
cell based on the height of the cells in the column and the height
of the column.
Inventors: |
Andreev, Alexander E.; (San
Jose, CA) ; Scepanovic, Ranko; (San Jose, CA)
; Grinchuk, Mikhail I.; (Mountain View, CA) |
Correspondence
Address: |
LSI Logic Corporation
1551 McCarthy Blvd.
M/S: D-106 Patent Department
Milpitas
CA
95035
US
|
Family ID: |
25044053 |
Appl. No.: |
09/756568 |
Filed: |
January 8, 2001 |
Current U.S.
Class: |
716/124 ;
716/119; 716/132 |
Current CPC
Class: |
G06F 30/392
20200101 |
Class at
Publication: |
716/11 ; 716/9;
716/10; 716/8 |
International
Class: |
G06F 017/50 |
Claims
What is claimed is:
1. A process for altering a distribution of N cells in a first
integrated circuit chip layout to position the cells in a second
integrated circuit chip layout, the first and second layouts each
having respective bounds, the process comprising steps of: a)
establishing an x,y grid for the first and second integrated chip
layouts such that each cell has identifying x,y coordinates in the
first layout and a height in the y-direction; b) establishing K
columns based on the bounds of the second layout in the
x-direction, K being an integer; c) sorting the cells to the K
columns in order of cell x-coordinates to establish x-coordinates
for each cell based on the x-coordinates of the respective column,
each column having a height in the y-direction; and d) sorting the
cells in each column to establish y-coordinates for each cell based
on the height of the cells in the column and the height of the
column.
2. The process of claim 1, wherein step (c) is performed by: c1)
calculating a minimum column height H.sub.min for all columns, and
c2) applying a recursive algorithm to distribute cells of each
column to x-positions between adjacent columns.
3. The process of claim 2, wherein the recursive algorithm
identifies a plurality of positions between adjacent columns, and
identifies maximum and minimum non-overlapping ranges of
x-coordinates for each position.
4. The process of claim 2, wherein
H.sub.ave.ltoreq.H.sub.min<(H.sub.av- e+h.sub.max), where
H.sub.ave is the average height of the columns and h.sub.max is the
height of the cell of the chip having the maximum height.
5. The process of claim 2, wherein step (c1) is performed by:
ordering the columns in order of cell x-coordinates, defining an
index for each column based on the number of cells in the column
and the order position of the column, the index for the
highest-ordered column being smaller than N and not smaller than
N-1, defining the height of each column based on the sum of the
heights of all cells in the column, and setting H.sub.min equal to
the smallest sum of cell heights for all of the columns.
6. The process of claim 2, wherein step (c2) is performed by
calculating an average integer between column integers of
respective first and second columns, calculating maximum and
minimum possible boundary positions between first and second halves
of the first column based on the average integer, partitioning an
ordered list of cell integer numbers for cells in the first column
into first and second segments such that a cell having an integer
that is an average between the maximum and minimum integers of the
cells defines a partition point, setting the cell whose integer is
te average to an integer between the maximum and minimum possible
boundary positions, and recursively distributing the cells of the
first and second segments to the first and second halves of the
column.
7. The process of claim 1, wherein step (d) is performed by steps
of: d1) computing a distance real_D[i] between identifying
y-coordinates of adjacent cells of each column based on the first
layout, d2) computing a distance min_D[i] in the y-direction
between the adjacent cells based on the heights of the adjacent
cells, and d3) computing an overlap over_D[i] based on a difference
between real_D[i] and min_D[i].
8. The process of claim 7, further including the step of: d4)
adding a correction factor corr D[i] to the y-coordinate of each
cell.
9. The process of claim 8, wherein step (d4) is performed by:
defining a tree having a plurality of vertices V, calculating
over_D[V] as equal to over_D[i], if V is the lowest terminal node
of the tree, or equal to over_D[V1]+over_D[V2] if V is not the
lowest terminal node of the tree, where V1 and V2 are descendants
of V, if over_D[V1]<0, calculating corr_D[V1]=-over_D[V1], and
calculating corr_D[V2]=corr_D[V]-corr_D[V1], if
over_D[V2].ltoreq.0, calculating corr_D[V2]=-over_D [V2], and
calculating corr_D[V1]=corr_D[V]-corr_D[V2]; if both over_D[V1] and
over_D[V2] are greater than zero, calculating corr_D[V1] and
corr_D[V2] as solutions to:
corr.sub.--D[V]=corr.sub.--D[V1]+corr.sub.--D[V2], 2 corr_D [ V 1 ]
over_D [ V 1 ] = corr_D [ V 2 ] over_D [ V 2 ] ,and setting
corr_D[i] equal to the respective corr_D [V].
10. The process of claim 1, further including, before step (c):
shifting the x-coordinates of each cell in the x-direction by an
amount within a selected range.
11. A computer useable medium having a computer readable program
embodied therein for addressing data to alter a distribution of N
cells in a first integrated circuit chip layout to position the
cells in a second integrated circuit chip layout, the computer
readable program comprising: computer readable program code for
causing the computer to establish an x,y grid for the first and
second integrated chip layouts such that each cell has identifying
x,y coordinates in the first layout and a height in the
y-direction; computer readable code for causing the computer to
establish K columns based on the bounds of the second layout in the
x-direction, K being an integer; computer readable code for causing
the computer to sort the cells to the K columns in order of cell
x-coordinates to establish x-coordinates for each cell based on the
x-coordinates of the respective column, each column having a height
in the y-direction; and computer readable code for causing the
computer to sort the cells in each column to establish
y-coordinates for each cell based on the height of the cells in the
column and the height of the column.
12. The computer readable medium of claim 11, further including:
computer readable code for causing the computer to calculate a
minimum column height H.sub.min for all columns, and computer
readable code for causing the computer to apply a recursive
algorithm to distribute cells of each column to x-positions between
adjacent columns.
13. The computer readable medium of claim 12, wherein the computer
readable code that causes the computer to apply the recursive
algorithm also causes the computer to identify a plurality of
positions between adjacent columns and maximum and minimum
non-overlapping ranges of x-coordinates for each position.
14. The computer readable medium of claim 12, wherein
H.sub.ave.ltoreq.H.sub.min<(H.sub.ave+h.sub.max), where
H.sub.ave is the average height of the columns and h.sub.max is the
height of the cell of the chip having the maximum height.
15. The computer readable medium of claim 12, wherein the computer
code that causes the computer to calculate a minimum column height
includes: computer readable code for causing the computer to order
the columns in order of cell x-coordinates, computer readable code
for causing the computer to define an index for each column based
on the number of cells in the column and the order position of the
column, the index for the highest-ordered column being smaller than
N and not smaller than N-1, computer readable code for causing the
computer to define the height of each column based on the sum of
the heights of all cells in the column, and computer readable code
for causing the computer to set H.sub.min equal to the smallest sum
of cell heights for all of the columns.
16. The computer readable medium of claim 12, wherein the computer
code that causes the computer to apply a recursive algorithm to
distribute cells includes: computer readable code for causing the
computer to calculate an average integer between column integers of
respective first and second columns, computer readable code for
causing the computer to calculate maximum and minimum possible
boundary positions between first and second halves of the first
column based on the average integer, computer readable code for
causing the computer to partition an ordered list of cell integer
numbers for cells in the first column into first and second
segments such that a cell having an integer that is an average
between the maximum and minimum integers of the cells defines a
partition point, computer readable code for causing the computer to
set the cell whose integer is te average to an integer between the
maximum and minimum possible boundary positions, and computer
readable code for causing the computer to recursively distribute
the cells of the first and second segments to the first and second
halves of the column.
17. The computer readable medium of claim 11, wherein the computer
readable code that causes the computer to apply a recursive
algorithm includes: computer readable code for causing the computer
to compute a distance real_D[i] between identifying y-coordinates
of adjacent cells of each column based on the first layout,
computer readable code for causing the computer to compute a
distance min_D[i] in the y-direction between the adjacent cells
based on the heights of the adjacent cells, and computer readable
code for causing the computer to compute an overlap over_D[i] based
on a difference between real_D[i] and min_D[i].
18. The computer readable medium of claim 17, further including:
computer readable code for causing the computer to add a correction
factor corr_D[i] to the y-coordinate of each cell.
19. The computer readable medium of claim 18, wherein the computer
readable code causing the computer to add a correction factor
includes: computer readable code that define a tree having a
plurality of vertices V, computer readable code for causing the
computer to identify if V is the lowest vertex in the tree,
computer readable code for causing the computer to calculate
over_D[V] equal to over_D[i], if V is the lowest terminal node of
the tree, computer readable code for causing the computer to
calculate over_D [V] equal to over_D [V1]+over_D[V2] if V is not
the lowest terminal node of the tree, where V1 and V2 are
descendants of V, computer readable code for causing the computer
to calculate whether either or both over_D[V1] and over_D[V2] is
greater than 0, computer readable code for causing the computer to
calculate corr_D[V1]=-over_D[V1], and corr
D[V2]=corr_D[V]-corr_D[V1], if over_D[V1].ltoreq.0, computer
readable code for causing the computer to calculate corr_D
[V2]=-over_D[V2], and corr_D[V1]=corr_D[V]-corr.sub.-D[V- 2], if
over D[V2].ltoreq.0 computer readable code for causing the computer
to calculating corr_D [V1] and corr_D[V2] as solutions to:
corr.sub.--D[V]=corr_D[V1]+corr_D[V2], 3 corr_D [ V 1 ] over_D [ V
1 ] = corr_D [ V 2 ] over_D [ V 2 ] ,if both over_D[V1] and
over_D[V2] are greater than zero, and computer readable code for
causing the computer to set corr_D[i] equal to the respective
corr_D[V].
20. The computer readable medium of claim 11, further including:
computer readable code for causing the computer to shifting the
x-coordinates of each cell in the x-direction by an amount within a
selected range.
Description
BACKGROUND OF THE INVENTION
[0001] This invention relates to cell placement, and particularly
to the placement of cells within approximated coordinates during a
redesign or modification of an integrated circuit (IC).
[0002] It is common in IC design to base new designs on ICs already
developed for a prior use. One problem in redesigning ICs is that
some cells of the prior design must be placed in close proximity in
the new design. This is particularly important where two cells
cooperate to perform certain tasks. If one cell is moved quite far
from the other, wire lengths may affect metal layer routing,
parasitic capacitance and signal timing.
[0003] Present automated processes for redesigning integrated
circuits often move cells quite far from the original location,
resulting in adverse effects resulting from increased wire length.
Moreover, automated processes are not capable of performing
re-design where the number of rows or columns of cells in a given
direction is altered from one design to another. For example, a
re-design that adds to the number of y-oriented columns of elements
increases the number or length in the x-direction. Thus, expansion
or contraction of a design along rows (x-direction) requires a
corresponding addition or subtraction to the number of columns
(y-direction) of cells. Automated processes are not helpful to
perform changes in columns. Accordingly, there is a need for an
automated process, operating under the control of a computer, that
performs transformation of existing IC designs to new designs by
approximated coordinates of the cells to correct the placement of
the cells in correspondence with existing design rules.
SUMMARY OF THE INVENTION
[0004] In accordance with the present invention, the distribution
of cells in a first integrated circuit chip layout is altered to
position the cells in a second integrated circuit chip layout. An
x,y grid is established for the first and second integrated chip
layouts such that each cell has identifying x,y coordinates in the
first layout and a height in the y-direction. A number of columns
is established in the second layout based on the bounds of the
second layout in the x-direction. The cells are sorted to the
columns in the order of cell x-coordinates to establish new
x-coordinates for each cell based on the x-coordinates of the
respective column. Each column has a height in the y-direction. The
cells are then sorted in each column to establish y-coordinates for
each cell based on the height of the cells in the column and the
height of the column.
[0005] In some embodiments of the process, the cells are sorted to
the columns by calculating a minimum column height H.sub.min for
all columns. A recursive algorithm is applied to distribute the
cells of each column to x-positions between adjacent columns.
[0006] According to another aspect of the process, the recursive
algorithm identifies a plurality of positions between adjacent
columns, and identifies maximum and minimum non-overlapping ranges
of x-coordinates for each position.
[0007] According to another aspect of the invention, the cells are
sorted in each column to establish y-coordinates by computing a
distance real_D[i] between identifying y-coordinates of adjacent
cells of each column based on the first layout. A distance min_D[i]
is computed in the y-direction between the adjacent cells based on
the heights of the adjacent cells. An overlap over_D[i] is computed
based on a difference between real_D[i] and min_D[i].
[0008] According to another aspect of the invention, a correction
factor corr_D[i] is added to the y-coordinate of each cell.
[0009] According to another aspect of the invention, a computer
useable medium contains a computer readable program comprising code
that causes the computer to alter the distribution of cells from
the first layout to the second layout.
BRIEF DESCRIPTION OF THE DRAWINGS
[0010] FIGS. 1-3 are flow diagrams useful in explaining the process
of the present invention.
DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0011] The present invention is directed to a process of
transformation of the placement of cells in an integrated circuit
(IC) chip where the design shape or number of columns are changing.
The process may be carried out by a computer under the control of a
computer readable program comprising code on a computer readable
medium. The invention makes it possible to re-use IC designs for
new purposes simply by optimizing the floorplan or layout of the
existing IC chip and transform it to a new design without the need
to perform cell placement. Using the techniques of the present
invention, new placement layouts are designed that are
topologically similar to the original layout.
[0012] FIG. 1 is a general flow diagram illustrating the process
according to the present invention. The flow diagram illustrates
the process steps carried out by the computer under the control of
a computer readable program code on a computer medium, such as a
hard disk, floppy disk, or the like. The process employs the
definition of the existing placed cells, such as by an identifying
x,y coordinates for each cell. Because each cell occupies space in
both the x- and y-directions, the identifying x,y coordinates
might, for example, be the coordinates of the geometric center
(also called the "center of gravity") of the cell. The present
invention employs the same x,y grid layout for both the original
(existing) IC chip design and the IC chip being designed, and
changes the x,y coordinates of the cells to fit the new design. The
process starts at step 100 with the definition of the shape of the
new IC chip and the number of columns K of cells in that chip. At
step 102, a list is input containing the x,y coordinates for each
cell C[i] in the original or existing chip, and the height h[i] of
each cell. The height h[i] is identified in numbers of grid
elements of the x,y grid.
[0013] At step 104, the distribution of the cells is optimized to
the new design and overlap is removed, as illustrated in greater
detail at FIGS. 2 and 3. Cell distribution optimization is
performed broadly by determining a minimum column height H.sub.min
for all of the columns in the new chip, and locating column
bounds.
[0014] As shown in FIG. 2, determination of the minimum column
height begins at step 112 by applying a random x-shift is applied
to the x-coordinates of each cell of the existing design. The
x-shift is preferably smaller than the width, in the x-direction,
of a column that extends in the y-direction. In preferred
embodiments, the x-shift is randomly distributed between 0.0 and
1.0 microns, where one micron is much smaller than a column width.
The list is then sorted at step 114 in increment order of
x-coordinates, thereby forming a list of cells of C[0], C[1], . . .
,C[N-1]
[0015] where N is the number of cells. At steps 118 to 128 the list
is segmented into K segments of approximately equal height in the
y-direction to derive a list of indices I, where
0=I[0]<I[1]< . . . <I[K-1]<I[K]=N,
[0016] and each k-th segment contains cells
C[I[i]], C [I [i]+1] . . . , C[I[i+1]-2], C[I[i+1]-1].
[0017] Each k-th segment forms a column k having a minimum height
H[k] calculated as
H[k]=h[I[i]]+h[I[i]+1]+ . . . +h[I[i+1]-1],
[0018] where h[i] is the height of cell C[i] in numbers of y grid
elements. The maximum value H.sub.MAX of H[k] for all columns
(i.e., H.sub.MAX is maximum H[k], taken over all columns of k=0 . .
. K-1) gives the maximum possible height for correct placement of
cells. The goal is to minimize this possible height, that is, to
find the minimum H.sub.max, where the minimum is taken over all
possible segmentations of the list of cells.
[0019] The value of H.sub.max is minimized by first defining the
average column height H.sub.ave at step 118. The average column
height is derived from the sum of the heights of all cells in the
IC chip, H=h[0]+. . . +h[N-1], and the number of columns K,
H.sub.ave=H/K. From this, the minimum possible height of the
columns, H.sub.min is equal to or greater than the average column
height H.sub.ave, and is smaller than the average column height
H.sub.ave plus the height, h.sub.max, of the one cell C[i] having
the maximum height:
H.sub.ave.ltoreq.H.sub.min<(H.sub.ave+h.sub.max)
[0020] Selection of H.sub.min is accomplished at step 120 by
determining whether the list of cells can be split into K segments
of a height not greater than Z, where Z is an integer number of
grid elements such that
H.sub.ave.ltoreq.Z<(H.sub.ave+h.sub.max). More particularly, for
a given value of Z, the values are assigned for each index in the
list that was derived at step 114, as follows:
[0021] I[0]=0;
[0022] I[1]=maximum number such that I[0].ltoreq.I[1].ltoreq.N and
h[I[0]]+h[I[0]+1]+ . . . +h[I[i]-1].ltoreq.Z;
[0023] I[2]=maximum number such that I[1].ltoreq.I[2].ltoreq.N and
h[I[1]]+h[I[1]+1]+ . . . +h[I[2]-1].ltoreq.Z; . . .
[0024] I[K-1]=maximum number such that
I[K-2].ltoreq.I[K-1].ltoreq.N and h[I[K-2]]+ . . .
+h[I[K-1]-1].ltoreq.Z;
[0025] I[K]=maximum number such that I[K-1].ltoreq.I[K].ltoreq.N
and h[I[K-1]]+ . . . +h[I[K]-1].ltoreq.Z.
[0026] If I[K] is smaller that N-1, then Z is too small and the
process is repeated with larger values for Z until the above
relationships are satisfied. The starting value of Z for this
procedure is H.sub.ave, rounded up to the nearest multiple of the
grid unit. At step 122, the resulting smallest value of Z is the
value for the minimum column height H.sub.min.
[0027] The boundaries of the columns are identified by distributing
the cells among columns and defining the column boundaries. The
input to this procedure is the number K of segments derived in step
114, the number N of cells, the minimum column height H.sub.min,
and the height of each cell h[0], . . . , h[N31 1]. The goal is to
distribute cells C[0], . . . , C[N-1] into K columns 0, . . . ,
K-1. This is performed at step 124 by a recursive procedure which
distributes cells C[i], . . . , C[j] in columns k, . . . , 1.
Initially a recursive algorithm DISTRIBUTE(i, j ,k, l) is performed
to calculate I[k], . . . , I[l+1]. The distribution of the entire
set of N cells to K columns can then be performed by execution of a
similar recursive algorithm DISTRIBUTE(0, N-1, 0, K-1).
[0028] If i=j or if k=l, no recursion is necessary. If i=j, there
is only one cell, so the cell is placed midway between the k-th and
l-th columns. Hence, the cell is placed at index kl, which is about
midway between indices k and l. More particularly, index
kl=floor(k+l+1)/2, and is the greatest integer rounded down from
(k+l+1)/2. If k=l, there is only one column, so all cells are
assigned to the column. Thus, I[k]=i, and I[k+1]=j+1, so k+1=l.
[0029] In the usual case, there will be more than one cell and more
than one column. Consequently, j>i and l>k. The object is to
place cells having indices between i and j into locations having
indices between the k and l columns. Broadly, cells i, i+1, . . . ,
j are divided among indices of k, k+1, . . . , l. This is
accomplished at step 126 by dividing the list of cells into two
parts and distributing the cells in the first part into index
positions k, k+1, kl-1, and distributing the cell in the second
part into index positions kl, kl+1, . . . , l, where kl is the
index described above that is about midway between columns k and l
and ij is an index of an average possible cut-point in partitioning
the list of cells. Distribution is performed using the same
DISTRIBUTE algorithm described above.
[0030] The partitioning is performed by calculating values of
IA[k], IA[k+1], . . . , IA[l], IA[l+1] and IB[k], IB[k+1], . . . ,
IB[l], IB[l+1], where the values of IA are the maximum possible
boundaries and the values of IB are the minimum possible
boundaries. The maximum and minimum boundaries for the cut-point
are calculated at step 128 using the following algorithm. The
maximum boundaries are calculated by:
[0031] IA[k]=i;
[0032] IA[k+1]=maximum integer such that IA [k].ltoreq.IA
[k+1].ltoreq.j+1, and h[IA[k]]+ . . .
+h[IA[k+1]-1].ltoreq.H.sub.min;
[0033] IA[k+2]=maximum integer such that
IA[k+1].ltoreq.IA[k+1].ltoreq.j+1- , and h[IA[k+1]]+ . . .
+h[IA[k+2]-1].ltoreq.H.sub.min; . . .
[0034] IA[l]=maximum integer such that
IA[l-1].ltoreq.IA[l].ltoreq.j+1, and h[IA[l-1]]+ . . .
+h[IA[l]-1].ltoreq.H.sub.min;
[0035] IA[l+1]=maximum integer such that
IA[l].ltoreq.IA[l+1].ltoreq.j+1, and h[IA[l]]+ . . .
+h[IA[l+1]-1].ltoreq.H.sub.min.
[0036] It will be appreciated by inspection of the above equations
that the IA index is not larger than j+1, and the sum of the
heights of the cells at each index position is smaller than the
minimum column height H.sub.min. Similarly, the minimum boundaries
for the cut-off point are calculated by:
[0037] IB[l+1]=j+1;
[0038] IB[l]=minimum integer such that
IB[l+1].gtoreq.IB[l].gtoreq.i and
h[IB[l]]++h[IB[l+1]-1].ltoreq.H.sub.min;
[0039] IB[l-1]=maximum integer such that
IB[l].gtoreq.IB[l-1].gtoreq.i, and h[IB[l-1]]+ . . .
+h[IB[l]-1].ltoreq.H.sub.min; . . .
[0040] IB[k+1]=maximum integer such that
IB[k+2]>IB[k+1].gtoreq.i and h[IB[k+1]]+ . . .
h[IB[k+2]-1].ltoreq.H.sub.min;
[0041] IB[k]=maximum integer such that
IB[k+1].gtoreq.IB[k].gtoreq.i and h[IB[k]]+ . . .
h[IB[k+1]-1].ltoreq.H.sub.min.
[0042] The process of defining values for IA and IB is similar to
the process described above in step 120. Index I[kl] in the middle
between columns k and l (indices I[k] and I[l]) is identified
as
I[kl]=ij=floor{(IA[kl]+IB[kl])/2},
[0043] rounded down to an integer of a grid unit. The process of
boundary location is repeated using indices of (i, ij-1, k, kl-1)
and (ij, j, kl, l) instead of (i, j, k, l). This breaks the lists
of indices into quarters, so the cells are divided among four
ranges of columns between k and l.
[0044] Thus the process performs the following steps:
[0045] 1) calculate kl (the average integer between k and l);
[0046] 2) calculate maximum and minimum possible boundaries of
columns (IA and IB);
[0047] 3) calculate ij as an average integer between IA[kl] and
IB[kl]; and
[0048] 4) recursively distribute the first and second halves of the
cells and columns lists using the cut-points ij and kl,
respectively.
[0049] As a result of the distribution of cells at indices
associated with the columns, each cell (or more accurately, the
center of gravity of each cell is assigned an x-coordinate. Next,
new y coordinates are assigned.
[0050] If a column is empty, no y-coordinates are needed. If only
one cell appears in a column, the cell is placed in the middle of
the column. The principal case occurs where a column contains m
cells where m.gtoreq.2. In this case, at step 130 the cells of each
column are sorted in incremental order of y-coordinates (centers of
gravity) from C[0], C[1], . . . , C[m-1]. At step 132 a linear
transformation is made for the y-coordinates for all of the cells
C[0], C[1], . . . , C[m-1] in the column so that the bottom of the
first cell is placed at the bottom of the column and the top of the
last cell is placed at the top of the column. This linear
transformation makes use of the y-coordinate, Y[i], of the center
of gravity of each i-th cell. In the final placement, the top and
bottom cell positions will not change from that performed by the
linear transformation of step 132.
[0051] In arranging the cells in each column, overlap may occur
between cells. Steps 134-140 illustrate the process of eliminating
overlap between cells of a column. At step 134, the distance in the
y-direction between the centers of gravity of adjacent cells,
Y[i+1] and Y[i], are calculated as
real.sub.--D [i]=Y[i+1]-Y[i],
[0052] and the minimum distance between the top edge of cell C[i]
and the bottom edge of C[i+1] are calculated from the heights h[i]
and h[i+1] of each cell
min.sub.--D[i]=(h[i]+h[i+1])/2.
[0053] At step 136 the overlap of successive cells C[i] and C[i+1]
in the column is calculated as
over.sub.--D[i]=real.sub.--D[i]-min.sub.--D[i],
[0054] where i is not the top (m) cell, 0.ltoreq.i<m. If
over_D[i] is negative, cells C[i] and C[i+1] overlap, and a
correction factor corr_D[i] must be calculated to add to the height
of the node to remove the overlap.
[0055] At step 138, the correction factor corr_D[i] is computed
using a binary tree having m-1 terminal vertices V[0], V[1], . . .
, V[m-2]. The set of all terminal vertices in any subtree of the
tree is some interval in the list. From the tree, over_D[V] and
corr_D[V] are calculated.
[0056] More particularly, for each vertex V, a number over_D[V] id
calculated as
[0057] over D[V]=over D[i], if V is the i-th terminal node V[i],
or
[0058] over_D[V]=over_D[V1]+over_D[V2], otherwise.
[0059] where V1 and V2 are descendants of V.
[0060] Calculation of corr_D[V] is performed from the root of the
tree, initializing corr_D[V]=0. For a given node V having
descendant nodes V1 and V2, calculation of corr_D[V1] and
corr_D[V2] are calculated as follows:
[0061] 1) if over_D[V1].ltoreq.0, then corr_D[V1]=-over_D[V1], and
corr_D[V2]=corr_D[V]-corr_D[V1];
[0062] 2) if over_D[V2].ltoreq.0, then corr_D[V2]=-over_D[V2], and
corr_D[V1]=corr_D[V]-corr_D[V2];
[0063] 3) if both over_D[V1] and over_D[V2]are greater than zero,
corr_D[V1] and corr_D[V2] are the solutions to the following
simultaneous equations:
corr.sub.--D[V]=corr.sub.--D[V1]+corr.sub.--D[V2], 1 corr_D [ V 1 ]
over_D [ V 1 ] = corr_D [ V 2 ] over_D [ V 2 ] .
[0064] The correction factor corr_D[i] is equal to the respective
correction corr_D[V].
[0065] At step 140, the new y-coordinates for the center of gravity
for each cell Y[i+1] are calculated based on the y-coordinate of
the next lower cell Y[i], the original distance between the centers
of gravity of Y[i] and Y[i+1], the distance between adjacent cells,
real_D[i], and the calculated correction factor, corr_D[i]:
[0066] Y[i+1]=round(Y[i]+real_D[i]+corr_D[i]-h[i+1]/2)+h[i+1]/2
where round(Y[i]+real_D[i]+corr_D[i]-h[i+1]/2) is a function of
Y[i]+real_D[i]+corr_D[i]-h[i+1]/2 rounded down to the nearest grid
position.
[0067] The present invention may be applied to cell distribution in
IC chips of irregular shape, if each column is continuous and not
divided into pieces. Application to irregular shaped chips will
require small modifications to the process since the minimum height
of the columns is already known. Another possible generalization of
the process can be achieved by replacing H.sub.min in the equations
with a larger value of Z, where Z is some multiple of grid
units.
[0068] The present invention provides an automated process,
operating under the control of a computer, for redesigning
integrated circuits to transform existing IC designs to new designs
and establish coordinates for the cells in the new design, thereby
maintaining the cells in conformance with existing design rules.
The process is effective in operation and provides new coordinates
for cells in the re-designed chip without resort to layout
procedures.
[0069] Although the present invention has been described with
reference to preferred embodiments, workers skilled in the art will
recognize that changes may be made in form and detail without
departing from the spirit and scope of the invention.
* * * * *