10.1.1.11.9430
Post on 03-Apr-2018
219 Views
Preview:
TRANSCRIPT
-
7/28/2019 10.1.1.11.9430
1/6
B*-Trees: A New Representation for Non-Slicing Floorplans
Yun-Chih Chang, Yao-Wen Chang, Guang-Ming Wu, and Shu-Wei Wu
Department of Computer and Information Science, National Chiao Tung University, Hsinchu 300, Taiwan
AbstractWe present in this paper an efficient, flexible, and effective data struc-ture, B*-trees, for non-slicing floorplans. B*-trees are based on orderedbinary trees and the admissible placement presented in [1]. Inheritingfrom the nice properties of ordered binary trees, B*-trees are very easyfor implementation and can perform the respective primitive tree op-erations search, insertion, and deletion in only
,
, and
times while existing representations for non-slicing floorplans need atleast
time for each of these operations, where
is the number ofmodules. The correspondence between an admissible placement and itsinduced B*-tree is 1-to-1 (i.e., no redundancy); further, the transforma-tion between them takes only linear time. Unlike other representationsfor non-slicing floorplans that need to construct constraint graphs forcost evaluation, in particular, the evaluation can be performed on B*-trees and their correspondingplacements directly and incrementally. Wefurther show the flexibility of B*-trees by exploring how to handle ro-tated, pre-placed, soft, and rectilinear modules. Experimental results on
MCNC benchmarks show that the B*-tree representation runs about 4.5times faster, consumes about 60% less memory, and results in smallersilicon area than the O-tree one [1]. We also develop a B*-tree basedsimulated annealing scheme for floorplan design; the scheme achievesnear optimum area utilization even for rectilinear modules.
1 IntroductionDue to the growth in design complexity, circuit sizes are getting
larger. To cope with the increasing design complexity, hierarchical de-sign and IP modules are widely used. The trend makes module floor-planning/placement much more critical to the quality of a VLSI design.
A fundamental problem to floorplanning/placement lies in the repre-sentation of geometric relationship among modules. The representationprofoundly affects the operations of modules and the complexity of afloorplan/placement design process. It is thus desired to develop an effi-cient, flexible, and effective representation of geometric relationship forfloorplan/placement designs.
1.1 Previous WorkFloorplans can be divided into two categories, the slicing struc-ture [12, 15] and the non-slicing structure [1, 6, 9, 14]. A slicing struc-ture can be represented by a binary tree whose leaves denote modules,and internal nodes specify horizontal or vertical cut lines. Wong andLiu proposed an algorithm for slicing floorplan designs [15]. They pre-sented a normalized Polish expression to represent a slicing structure,enabling the speed-up of its search procedure. However, this represen-tation cannot handle non-slicing floorplans. Recently, researchers haveproposed several representations for non-slicing floorplans, such as se-quence pair [6], bounded slicing grid (BSG) [9], and O-tree [1].
Onodera et al. in [11] used the branch-and-bound method to solvethe module placement problem. This approach has very high time com-plexity and is thus feasible for only small problem sizes. Murata etal. in [6] proposed the sequence-pair representation for rectangular mod-ule placement. The main idea is to use a sequence pair to represent thegeometric relation of modules, place the modules on a grid structure,
and construct corresponding constraint graphs to evaluate cost. Thisrepresentation requires
space to encode a sequence pair and
!
This work was partially supported by the National Science Council of Tai-wan under Grant No. NSC-89-2215-E-009-055. E-mail:
"gis87512, ywchang,
gis85815, gis8867555#
@cis.nctu.edu.tw.
there are
$ '
combinations in total, where
is the number of mod-ules. Further, the transformation between a sequence pair and a place-ment takes
time. Nakatake el al. in [9] presented a grid basedrepresentationBSG. The BSG structure utilizes a set of horizontal andvertical bounded-length lines to cut the plane into rooms and representsa placement by these lines and rooms. BSG incurs redundancies. Itscomplexity is similar to that of the sequence pair. The sequence pairand BSG were then extended to handle pre-placed modules and softmodules in [2, 7, 8, 10].
Guo et al. in [1] proposed a tree based representation, called O-trees.
The number of O-tree combinations is only $
' 0 2 ' 4 7 8 9
. Further,the transformation between the representation and a floorplan takes only
time. However, the tree structure is irregular, and thus some prim-itive tree operations, such as search and insertion, are not efficient. Toreduce the operation complexity, the tree is encoded by a sequence of
bits and a permutation of
bits.
7n
8n
9n
10n
11n 3n
4n
5n
6n
1n
2n
0n6b
b0
b1b2
b10
b5
b3 b4
11b
b9
b7
b8
(a) (b)
Figure 1: (a) An admissible placement. (b) The (horizontal) B*-treerepresenting the placement.
1.2 Our Contributions
To handle non-slicing floorplans, we propose in this paper an orderedbinary-tree based representation, called B*-trees. Given an admissibleplacement[1], we can represent it by a unique horizontal and a uniquevertical B*-trees. (See Figure 1(b) for the horizontal B*-tree for the ad-missible placement shown in Figure 1(a).) The admissible placementhere means that it is compacted and can neither move down nor moveleft. Inheriting from the particular characteristics of the ordered binarytree, the B*-tree has many advantages compared with other representa-tions. We summarize the advantages of B*-tree as follows:
A Based on ordered binary trees, the B*-tree is very fast and easyfor implementation. Since the number of branches in a B*-tree isfixed (i.e., two branches), it can be implemented by either a staticdata structure or a dynamic one. By using static memory, wecan search and insert a node in
time while the O-tree needs
time. Note that an O-tree is irregular and its number of
branches is unpredictable (see Figure 2(b)); thus, it incurs higheroperation complexity and/or significant encoding cost.
A The B*-tree is very flexible for handling the floorplanning prob-lems with various types of modules (e.g., hard, pre-placed, soft,and rectilinear modules)directly and efficiently. In contrast, otherrepresentation cannot handle some special modules well. Todeal with soft modules using sequence pair, for example, pre-vious work in [8] transformed it to the convex problem (which isNP-hard [13]), processed the soft modules, and then transformedback to the sequence pair.
A B*-trees do not need to construct constraint graphs for area costevaluation. In contrast, the sequence pair and O-tree representa-
Permission to make digital/hardcopy of all or part of this work for personal or
classroom use is granted without fee provided that copies are not made or
distributed for profit or commercial advantage, the copyright notice, t he title of thepub licati on an d its date appear, and notice is given that copying is by permiss ion of
ACM, Inc. To copy otherwise, to republish, to post on servers or to redistribute to
lists, requires prior specific permission and/or a fee.DAC 2000, Los Angeles, California
(c) 2000 ACM 1-58113-188-7/00/0006..$5.00
-
7/28/2019 10.1.1.11.9430
2/6
-
7/28/2019 10.1.1.11.9430
3/6
positions for inserting a node are limited to the external nodes (see Fig-ure 3) to facilitate the update of the encoding tuple. Inserting a node to aposition other than external positions makes the update of the encodingtuple difficult and time-consuming. The inflexibility might cause the O-tree to deviate from the optimal during solution perturbations, and thusinevitably limit the quality of a floorplan design. We consider this in-flexibility a major drawback of the O-tree representation. It will be clearin the next subsection that this deficiency can be fixed by using B*-trees.
3n
4n
5n
6n7n 8n 9n 10n
11n
1n
2n
0n
external node
internal node
root
Figure 3: The internal and external insertion positions. To facilitate theupdate of the encoding tuple, O-trees allow a node to be inserted only atthe external positions.
3.2 The B*-Tree RepresentationGiven an admissible placement
u, we can represent it by a unique
(horizontal) B*-tree . (See Figure 1(b) for the B*-tree representing theplacement shown in Figure 1(a).) A B*-tree is an ordered binary treewhose root corresponds to the module on the bottom-left corner. Simi-lar to the DFS procedure, we construct the B*-tree for an admissibleplacement u in a recursive fashion: Starting from the root, we first re-cursively construct the left subtree and then the right subtree. Let
U
denote the set of modules located on the right-hand side and adjacent toI
U. The left child of the node
Ucorresponds to the lowest module in
U
that is unvisited. The right child of
U
represents the module locatedabove and adjacent to
I U, with its
v
-coordinate equal to that ofI U
andits x -coordinate less than that of the top boundary of the module on theleft-hand side and adjacent to I
U, if any.
The B*-tree keeps the geometric relationship between two modulesas follows. If node
is the left child of node
U, module I
must be
located on the right-hand side and adjacent to module I U in the admissi-ble placement; i.e.,
v
E
v
U T U. Besides, if node
is the right childof
U, module I
must be located above and adjacent to module IU, with
thev
-coordinate ofI
equal to that ofI
U
; i.e.,v
E
v
U
. Also, since theroot of represents the bottom-left module, the
v
- and x -coordinates ofthe module associated with the root
v
P x
E
P
.As shown in Figure 1, we make
the root of
sinceI
is on thebottom-left corner. Constructing the left subtree of
recursively, wemake
the left child of
. Since the left child of
does not exist, wethen construct the right subtree of
(which is rooted by
). The con-struction is recursively performed in the DFS order. After completingthe left subtree of
, the same procedure applies to the right subtree of
. Figure 1(b) illustrates the resulting B*-tree for the placement shownin Figure 1(a). The construction takes only linear time.
Note that a B*-tree can also be constructed by transforming an O-tree to a binary tree, under several additional construction rules for somespecial module placements to make the theorem to be presented below
hold. However, constructing a B*-tree in this way is not as efficient asthe aforementioned procedure.
We have the following lemma which leads to Theorem 1.
Lemma 1 For a module IU
in an admissible placement, the correspond-ing node
Uin its induced B*-tree has a unique parent if
Uis not the
root.
Theorem 1 There is a 1-to-1 correspondence between an admissibleplacement and its induced B*-tree.
In other words, for an admissible placement, we can construct a uniqueB*-tree, and vice versa. The nice property of the 1-to-1 correspondence
between an admissible placement and its induced B*-tree prevents thesearch space from being enlarged with duplicate solutions.
4 Operations on ModulesWe adopt the contour data structure presented in [1] to facilitate the
operations on modules. The contour structure is a doubly linked listfor modules, describing the contour curve in the current compaction di-rection. A horizontal contour(see Figure 4) can be used to reduce therunning time for finding the x -coordinate of a newly inserted module.Without the contour, the running time for placing a new module wouldbe linear to the number of modules. By maintaining the contour struc-
ture, however, thex
-coordinate of a module can be computed in
time [1]. Figure 4 illustrates how to update the horizontal contour afterinserting a new module.
0
1 34
10
9
811
7
b b b
b
b
b
b b
b
old contour
newlyaddedmodule
new contour
horizontal contour
verticalcontour
Figure 4: Adding a new module on top, we search the horizontal con-tour from left to right and update it with the top boundary of the newmodule.
To cope with rotated modules, when inserting a deleted node intoa B*-tree, we can perform the operation twice at each position to finda better solution, one for the original orientation, and the other for therotated one. In the following, we shall discuss the floorplanningproblemwith pre-placed, soft, and rectilinear modules.
4.1 Pre-placed ModulesIntuitively, if there exists a pre-placed module which cannot be lo-
cated on its fixed positions during compaction, we would discard thissolution. Unfortunately, this approach is not effective. A better ap-proach is to change an infeasible solution to be feasible. Therefore, we
handle the situation in this way: if there exists a pre-placed module thatcannot be located on its fixed positions during compaction, we exchangethe pre-placed module with another so that the pre-placed module can belocated on its fixed positions. There are two subproblems to be solved:(1) how to choose the module that swaps with the pre-placed module,and (2) how to locate the pre-placed one on its fixed position.
We say a module to be ahead (behind) another if its bottom-leftv
-coordinate is smaller (larger) than that of another. Similarly, a moduleis lower (higher) than another if its bottom-left x -coordinate is smaller(larger) than that of another. A coordinate (
v
P x ) dominates another co-ordinate (
v
P x
), denoted by v
P x
v
P x
, iffv v
and x
x
.
LetI U
be a pre-placed module, (v k
U
P x
k
U
) denote its fixed coordinate, andl
U E G I
y vk
U
P x
k
U
v
P x
S . If there are modules ahead or lower
thanI
U
so thatI
U
cannot be placed at (v k
U
, xk
U
), we would exchangeI
U
with the module inl
Uthat is most close to (
v k
U
P x
k
U
).To identify the modules in
l
U, we first trace back
from the node
U
until detecting a node
whose corresponding module I
is dominatedby (
vk
U
P x
k
U
). We add
intol
U . Then, we trace down the subtree of
and add all modules dominated by (v k
U
P x
k
U
) intol
U. Note that when
we trace down the subtree of
, once we find a node o
that is not
dominated by (v k
U
P x
k
U
), all the nodes in the subtree of o
will not be
dominated by (v
k
U
P x
k
U
). Afterl
Uis determined, the module that is most
close to (v k
U
P x
k
U
) is chosen for exchange.Figure 5(a) shows a placement with a pre-placed module
I and its
fixed position (v k
, xk
). I cannot be placed at (v k
P x
k
) since the positionhas been occupied by module
I
' . Therefore, we must choose a modulefor exchange with I . Following the aforementioned procedure, we have
-
7/28/2019 10.1.1.11.9430
4/6
66,( )xf fy
6b
11bb0
b1b2
b10
b9
b7
b5
b3b4
b8
b5
b1
b2
b0
b36b b4
b10
b9
b8 11b
b7
66,( )xf fy
(a) (b)Figure 5: (a) A placement with a pre-placed module. (b) Place
I at its
fixed position (v k
P x
k
).
l
E G I
7 P
I
' S . SinceI
' is most close to (v
k
P x
k
), we exchange
' and
in and transform to its corresponding placement. Figure 5(b)shows the resulting exchange of I ' and I , with I being placed at its
fixed position (v k
P x
k
). Note that, to save the execution time, we do notidentify all feasible modules (e.g.,
I
) for the exchange.A nice property of the B*-tree lies in the incremental cost update.
The DFS order of before the exchange is (
P
P
,
7 7P
P
7
,
7P
'P
,
P
9P
). The positions of
I
P
I
P
I
P
I
7 7P
I
P
I
7
, andI
7
remain unchanged after the exchange since they are in the front ofI
' inthe DFS order. Therefore, we do not need to recompute the area cost
from scratch.4.2 Soft Modules
With its area beingfixed, the width and height of a soft module is freeto be changed under its aspect ratio constraint. Our method for handlingsoft modules consists of two stages: the first stage picks a soft modulefor processing (deleting and inserting a node associated with the mod-ule), and the second stage adjusts the shapes of the other soft modules.To insert a node, most existing work tries all possible combinations ofwidths and heights. To avoid the time-consuming process of trying allpossible combinations, we shall find the best shape directly.
6b
b0
b1
b2
b10
b5
b3 b4
11b
b9
b7
b8
(a)
7n
8n
9n
10n
11n3n
4n
5n
6n
1n
2n
0n
(b)
Figure 6: (a) An admissible placement. (b) The vertical B*-tree repre-senting the placement.
To compact along the x direction, we introduce the vertical B*-tree
, and call the B*-tree described in Section 3.2 the horizontal B*-tree,denoted by
. Given an admissible placement
u, we can construct a
unique
. Let U
denote the set of modules located above and adjacentto I
U. The construction is similar to constructing a
described in Sec-
tion 3.2 with the only difference in direction. The left child of the node
U corresponds to the leftmost module in U that is unvisited. The rightchild of
Urepresents the module located on the right-hand side and ad-
jacent to IU, with its x -coordinate equal to that of I
Uand its
v
-coordinateless than that of the right boundary of the module below and adjacentto
IU
, if any. Figure 6(b) gives the vertical B*-tree for the admissibleplacement shown in Figure 6(a).
After inserting a node associated with a soft module, we compute itssurplus space in the
v
and x directions for stretching its width and height
under its aspect ratio constraint. Let
U
(
U
) denote the set of mod-ules affected by shifting the soft module I
Uin the horizontal (vertical)
direction andI
U
itself. (Note that we can shift a module either up or right
in an admissible placement.) The modules in U
are those associated
with the nodes in the left subtree of I U in and I U itself. The modulesin
U
can be similarly defined in .Let
q
x
U zf
U
0P x
U zf g h t
(q
v
U zf
U
0P
v
U zf g h t
) be the range on the vertical(horizontal) contour that could be affected by pushing I U forward in thehorizontal (vertical) direction. We have
x
U zf gi h E ~ G
x
W
y
I
p
U
S (1)
x
U zf
U
0
E ~ G
x
y
I
p
U
S (2)
and
v
U zf g h
E ~ G
v
T
y
I
p
U
S (3)v
U{ z f U
0
E ~ G
v
y
I
p
U
S Q (4)
Let
v
(
x
) be the maximumv
( x ) coordinate on the vertical (hor-izontal) contour in the range U E
q
x
U z f U
0 P x
U z f g h t (q
v
U z f U
0 P
v
U z f g h t ),and
b
(
b
) denote the distance between
v
(
x
) and the maxi-
mumv
( x ) coordinate on the vertical (horizontal) contour. Also, let
U
(
U
) be the set of modules on the right-hand (upper) side of IU
and theirvertical (horizontal) boundaries overlap with the interval
q
x
U
P x
U
W
Ut
(q
v
U
P
v
U T U t),
v
!
U
E ~ G
v
y
I
p
U
S ( x!
U
E ~ G
x
y
I
p
U
S )
denote the minimumv
( x ) coordinate of the modules in
U
(
U
), and
b
E
b
v
!
U
v
U
T U
P
b
U
E
b
P otherwise P
b
E
b
x
!
U
x
U
W
U
P
b
U
E
b
P otherwise Q
We have
T U E
TU
b
P
b
e fU
0
`
g
U
`
e f g h
g
P
b
g
U
e fU
0
g
P
b
g
U
e f g h
P
W
U E
W
U
b
P
b
ef
U
0
`
U
g
`
ef g h
X U ef
U
0 P
b
U
g
ef
U
0
XU
e f g h
P
b
U
g
e f g h
Q
Modifying the shape of a module, we change its width first, thenchange its height after compacting along the x direction, and compactalong the
v
direction at last. Changing width and height at the sametime may cause confusion as there may be surplus space in both of the
v
and x directions.After changing the shape of the inserted soft module, we then change
those of other soft modules. We first compute the surplus space in thev
and x directions for each soft module. Instead of computing the surplusspace from the contour, we find the space between the soft module andits neighboring ones. After inserting a soft module
I U, we compute the
surplus space of a soft moduleI
in thev
and x directions from
and
respectively.
Let-
(-
) be the surplus space ofI
in the horizontal (verti-cal) direction, and
v
(
x ) be the maximumv
( x ) coordinate on the vertical(horizontal) contour. We have
-
E
v
!
v
T
P
b
E
v
v
T
P otherwise P
-
E
x
!
x
W
P
b
E
x
x
W
P otherwiseQ
Substituting
b
for -
and
b
for -
, we can obtain thenew
T
andW
similar to the equations shown above.Similar to the processing of the inserted soft module, we change the
widths and heights of the soft modules one at a time. After changingtheir widths, we compact in the vertical direction. Then we continue tochange their heights and compact in the horizontal direction at last.
-
7/28/2019 10.1.1.11.9430
5/6
b1
b2
(a) (d)
b1 b2
(c)
b1
b2
(b)
b1b2
Figure 7: Four cases of an L-shaped module after rotation. Each is par-titioned into two parts by slicing it along the middle vertical boundary.
4.3 Rectilinear ModulesWe can partition a rectilinear module into several rectangular sub-
modules by slicing from left to right along each vertical boundary. Wefirst consider L-shaped modules and then extend to general rectilinearmodules.
An L-shaped module I can be partitioned into two rectangular sub-modules by slicing
I along its middle vertical boundary. As shown in
Figure 7, I 7 and I ' are the sub-modules of I , and we say I 7 P I 'p
I .During placement, we must guarantee that the two sub-modules
I
7 andI
' abut, andI
maintains its original shape. To ensure that the leftsub-module
I
7 and the right sub-moduleI
' ofI
abut, we impose thefollowing location constraint(LC for short) for I 7 and I ' :
: Keep I ' as I 7 s left child in the B*-tree.
Since modules are placed in the DFS order, keeping I ' as I 7 s leftchild in the B*-tree guarantees that
I
7 andI
' are placed in sequence.The
relation ensures that thev
-coordinate ofI
' s left boundaryequals that of I 7 s right boundary. For example, the two sets of sub-modules
I
7 P
I
' andI
P
I shown in Figure 8(a) abut. The sub-modules
I
andI
are placed at the correct positions whileI
7
andI
'
are not sinceI
7 andI
' do not conform to their original L shape. We sayI
7 andI
' tobe mis-aligned. To slove the mis-aligned problem, we must adjust the
x coordinate of I 7 or I ' . For the I 7 and I ' shown in Figure 8(a), forexample,
I
7 must be pulled up until the x coordinate ofI
7 s top (bot-tom) boundary equals that of
I
' s for the L shape shown in Figure 7(a)(Figure 7(d)).
b1
0
1
2
b2
b3b4 b2
b1
1
0
2
b3
b4
LC relations
(a) (b)
Figure 8: Suppose thatI
7 P
I
' andI
P
I are two sets of sub-modules
corresponding to two L-shaped modules. (a) A placement in whichI
7P
I
' and I P I abut. However, I 7 and I ' are mis-aligned. (b) Theircorresponding nodes in the B*-tree keep the
relation betweenI
7
andI
' (as well asI
andI
).
For each L-shaped module, there are four orientations after rotation,as shown in Figure 7. Whenever we perform a rotation on an L-shapedmodule, we must repartition it into two sub-modules and maintain theLC relation between them. See Figure 7 for the sub-modules after repar-titioning.
A rectilinear module is convex if any two points within the modulecan be connected by the shortest Manhattan path which also lies withinthe module; it is concave otherwise. A convex module I can be par-
titioned into a set of sub-modules I 7 P I ' P Q Q Q P I 0 by slicing I from leftto right along each vertical boundary. Considering the
relation, wekeep the sub-module I
U
7 as IUs left child in the B*-tree to ensure that
they are placed side by side along thev
direction, where ` b `
.To ensure that I 7 P I ' P Q Q Q P I 0 are not mis-aligned, we may need to adjustthe x coordinates of the sub-modules, like what we did for L-shapedmodules. For a concave module, we can fill the concave holes of themodule and make it convex. Then, the operations remain the same asthose for a convex module.
5 The AlgorithmOur floorplan design algorithm is based on the simulated annealing
method [4]. The algorithm can consider not only hard modules, but also
pre-placed, soft, and rectilinear ones.We perturba B*-tree (a feasible solution) to another B*-tree by using
the following four operations.A Op1: Rotate a module.A Op2: Move a module to another place.A Op3: Swap two modules.A Op4: Remove a soft module and insert it into the best internal or
external position.
We have discussed Op1 in Section 4. Op2 deletes and inserts a module.If the deleted node is associated with a rectangular module, we simply
delete the node from the B*-tree. Otherwise, there will be several nodesassociated with a rectilinear module, and we treat them as a whole andmaintain their
relations. Op4 deletes a soft module, tries all possibleinternal and external positions, inserts it into the best position, changesits shape and the shapes of the other soft modules (see Section 4.2).Op2, Op3, and Op4 need to apply the
e andl
operationsfor inserting and deleting a node to and from a B*-tree. We explain thetwo operations in the following.
5.1 DeletionThere are three cases for the deletion operation.
A Case 1: A leaf node.A Case 2: A node with one child.A Case 3: A node with two children.
In Case 1, we simply delete the target leaf node. In Case 2, we removethe target node and then place its only child at the position of the re-moved node. The tree update can be performed in
time. In Case
3, we replace the target node
by either its right child or left child
.Then we move a child of
to the original position of
. The processproceeds until the corresponding leaf node is handled. It is obvious thatsuch a deletion operation requires
W
time, whereW
is the height ofthe B*-tree. Note that in Cases 2 and 3, the relative positions of themodules might be changed after the operation, and thus we might needto reconstruct a corresponding placement for further processing. Also,if the deleted node corresponds to a sub-module of a rectilinear module
I
, we should also delete other sub-modules ofI
.
5.2 InsertionWhen adding a module, we may place it around some module, but
not between the sub-modules that belong to a rectilinear module. Wedefine three types of positions as follows.
A
Inseparable position: A position between two nodes associatedwith two sub-modules of a rectilinear module.
A
Internal position: A position between two nodes in a B*-tree, but
is not an inseparable one.A
External position: A position pointed by a NULL pointer.
Only internal and external positions can be used for inserting a newnode. For a rectangular module, we can insert it into an internal or anexternal position directly. For a rectilinear module
I
consisting of thesub-modules
I
7 P
I
' P Q Q Q P
I
0 ordered from left to right, the sub-modulesmust be inserted simultaneously, and I
U
7 must be the left child of IU
tosatisfy the
relation.The simulated annealing algorithm starts by randomly choosing an
initial B*-tree. Then it perturbs a B*-tree (a feasible solution) to an-other B*-tree based on the aforementioned Op1Op4 until a predefinedfrozen state is reached. At last, we transform the resulting B*-tree tothe corresponding final admissible placement.
6 Experimental ResultsWe implemented two algorithms in the C++ programming language
on a 200 MHz SUN Sparc Ultra-I workstation with 256 MB memory.
One is the iterative, deterministic algorithm used in [1], and the otheris the aforementioned simulated annealing algorithm. The deterministicone is served for the purpose of fair comparison with the O-tree repre-sentation which is the fastest for non-slicing floorplans in the literature.
We performed two sets of experiments: one was based on the MCNCbenchmark circuits used in [1], and the other on some artificial rectilin-ear modules. Table 2 lists the names of the circuits, the numbers of mod-ules, the runtimes per iteration for the iterative, deterministic algorithm,memory requirements, and chip areas for the cluster refinement algo-rithm [16], the O-tree, the B*-tree based on the iterative algorithm. Wealso tested the total runtimes and areas resulted from using the B*-treebased simulated annealing algorithm. The results show that the B*-treeachieved average speedups (area reductions) of 458 and 4.5 (1.0% and
-
7/28/2019 10.1.1.11.9430
6/6
top related