Publication number | US20030221176 A1 |

Publication type | Application |

Application number | US 10/153,570 |

Publication date | Nov 27, 2003 |

Filing date | May 22, 2002 |

Priority date | May 22, 2002 |

Also published as | US6665850 |

Publication number | 10153570, 153570, US 2003/0221176 A1, US 2003/221176 A1, US 20030221176 A1, US 20030221176A1, US 2003221176 A1, US 2003221176A1, US-A1-20030221176, US-A1-2003221176, US2003/0221176A1, US2003/221176A1, US20030221176 A1, US20030221176A1, US2003221176 A1, US2003221176A1 |

Inventors | Alexander Andreev, Vojislav Vukovic |

Original Assignee | Andreev Alexander E., Vojislav Vukovic |

Export Citation | BiBTeX, EndNote, RefMan |

Referenced by (4), Classifications (4), Legal Events (10) | |

External Links: USPTO, USPTO Assignment, Espacenet | |

US 20030221176 A1

Abstract

The present invention is directed to a spanning tree method for K dimensional space. To address timing driven buffer insertion and clock routing problems clusters of points must be constructed in 3-dimensional space. The first and second dimensions are coordinates on a plane, while the third dimension is time which is arrival pin time for buffers insertion and clock latency for clock routing. In a first aspect of the present invention, a method includes partitioning an input set of points into a binary tree of partitions so that each leaf partition has maximally a defined number of points. Graph edges are made for the points by connecting each point to its closest points in every of 2^{K }subspaces and the number of graph nodes is then reduced to a predefined value.

Claims(26)

partitioning an input set of points into a binary tree of partitions so that each leaf partition has maximally a defined number of points;

making graph edges for the points by connecting each point to its closest point in every of 2^{K }subspaces; and

reducing number of graph elements to predefined value.

sorting edges, wherein edges e_{l}(X_{s}, X_{e}) are sorted by length in ascending order, X_{s }and X_{e }are start and end points of the edge;

initializing a set of components so that every graph point is a single component C^{Xi};

processing edges until the number of components is equal to input parameter C, wherein processing includes if size(C_{Xs}) size(C_{Xe}), where size of the component is the number of belonging vertexes, a new component is made of the two components by moving all vertexes which have belonged to component C_{Xe }to C_{Xs }and erasing component C_{Xe}, if it is not the case, C_{Xx i}s removed and C_{Xe }expanded.

partitioning an input set of points into a binary tree of partitions so that each leaf partition of the binary tree has maximally a defined number of points;

making graph edges for the points by connecting each point to its closest point in every of 2^{K }subspaces; and

factorizing number of graph points by decreasing a number of components in the set of graph points until it becomes equal to a predefined specified program input parameter C.

sorting edges, wherein edges e_{l}(X_{s}, X_{e}) are sorted by length in ascending order, X_{s }and X_{e }are start and end points of the edge;

initializing a set of components so that every graph point is a single component C_{Xi};

processing edges until the number of components is equal to input parameter C, wherein processing includes if size(C_{Xs}) size(C_{Xe}), where size of the component is the number of belonging vertexes, a new component is made of the two components by moving all vertexes which have belonged to component C_{Xe }to C_{Xs }and erasing component C_{Xe}, if it is not the case, C_{Xs }is removed and C_{Xe }expanded.

a memory suitable for storing a program of instructions; and

a processor communicatively coupled to the memory, the processor suitable for performing a program of instructions, wherein the program of instructions configures the processor to

partition an input set of points into a binary tree of partitions so that each leaf partition of the binary tree has maximally a defined number of points;

making graph edges for the points by connecting each point to its closest point in every of 2^{K }subspaces; and

factorize number of graph points by decreasing a number of components in the set of graph points until it becomes equal to a predefined specified program input parameter C.

sorting edges, wherein edges e_{l}(X_{s}, X_{e}) are sorted by length in ascending order, X_{s }and X_{e }are start and end points of the edge;

initializing a set of components so that every graph point is a single component C_{Xi};

processing edges until the number of components is equal to input parameter C, wherein processing includes if size(C_{Xs}) size(C_{Xe}), where size of the component is the number of belonging vertexes, a new component is made of the two components by moving all vertexes which have belonged to component C_{Xe }to C_{Xs }and erasing component C_{Xe}, if it is not the case, C_{Xs }is removed and C_{Xe }expanded.

a means for partitioning an input set of points into a binary tree of partitions so that each leaf partition has maximally a defined number of points;

a means for making graph edges for the points, the graph edge means communicatively coupled to the partitioning means, wherein the graph edges means connects each point to maximum 2^{K }closest points to make edges of the graph; and

a means for reducing number of graph points communicatively coupled to the graph edge means, wherein the reducing means decreasing a number of components in the set of graph points until it becomes equal to a predefined specified program input parameter C.

Description

- [0001]The present invention generally relates to the field of integrated circuit design, and particularly to a method for implementing a spanning tree method for K-dimensional space.
- [0002]The complexity encountered in the design and production of integrated circuits has grown exponentially as the number of features, speed and size of the integrated circuits has grown. For instance, integrated circuits may be found in an ever increasing range of products. To provide the desired functionality for the products, circuits may be designed specifically for the contemplated usage and/or generalized circuits may be employed capably of providing usage desired by a wide range of manufacturers and end users.
- [0003]There are a wide variety of considerations that must be addressed in the design of the integrated circuit, such as timing considerations. For instance, sections of a chip may be able to perform operations in different amounts of time, such as based on the complexity of the calculation. Additionally, the transfer of data between components of an integrated circuit may be performed in different lengths of time, such time depending distance the information must travel to arrive at a desired component, and the like.
- [0004]To address these timing considerations, integrated circuit may be arranged in an optimal manner, buffers employed to store data so that it is ready when needed, and the like. However, previous methods utilized to compute the placement of buffers, routing and the like were inefficient and overly complex.
- [0005]Therefore, it would be desirable to provide a spanning tree system and method for K dimensional space.
- [0006]Accordingly, the present invention is directed to a spanning tree method for K dimensional space. To address timing driven buffer insertion and clock routing problems clusters of points must be constructed in 3-dimensional space. The first and second dimensions are coordinates on a plane, while the third dimension is time which is arrival pin time for buffers insertion and clock latency for clock routing. In a first aspect of the present invention, a method includes partitioning an input set of points into a binary tree of partitions so that each leaf partition has maximally a defined number of points. Graph edges are made for the points by connecting each point to its closest point in every of 2
^{K }subspaces and the number of graph nodes is then reduced to a predefined value. - [0007]In an additional aspect of the present invention, a method for partitioning an integrated circuit includes partitioning an input set of points into a binary tree of partitions so that each leaf partition of the binary tree has maximally a defined number of points. Graph edges for the points are made by connecting each point to 2
^{K }closest points. The starting number of graph points is then factorized by decreasing a number of components in the set of graph points until that number becomes equal to a predefined specified program input parameter C. - [0008]In a further aspect of the present invention, a system includes a memory suitable for storing a program of instructions and a processor communicatively coupled to the memory, the processor suitable for performing a program of instructions. The program of instructions configures the processor to partition an input set of points into a binary tree of partitions so that each leaf partition of the binary tree has maximally a defined number of points. Graph edges are made for the points by connecting each point to its closest point in every of 2
^{K }subspaces. The number of graph nodes is reduced by factorizing a number of constructed components in the set of graph points until it becomes equal to a predefined specified program input parameter C. - [0009]It is to be understood that both the forgoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the invention as claimed. The accompanying drawings, which are incorporated in and constitute a part of the specification, illustrate an embodiment of the invention and together with the general description, serve to explain the principles of the invention.
- [0010]The numerous advantages of the present invention may be better understood by those skilled in the art by reference to the accompanying figures in which:
- [0011][0011]FIG. 1 is a flow diagram of an exemplary method of the present invention wherein a partitioning method is shown suitable for operating in accordance with the present invention;
- [0012][0012]FIG. 2 is a top view depiction of an illustration of an integrated circuit having partitions and points;
- [0013][0013]FIG. 3 is a flow diagram of an exemplary method of the present invention wherein a method for finding a closest point is shown;
- [0014][0014]FIGS. 4A, 4B &
**4**C are top-view illustrations of points and partitions in a variety of configurations; - [0015][0015]FIG. 5 is a flow diagram of an exemplary method of the present invention wherein a method findInside is shown;
- [0016][0016]FIG. 6 is a flow diagram of an exemplary method of the present invention wherein a method of making components is shown; and
- [0017][0017]FIG. 7 is a top view illustration of an embodiment of the present invention showing a spanning tree example.
- [0018]Reference will now be made in detail to the presently preferred embodiments of the invention, examples of which are illustrated in the accompanying drawings.
- [0019]Referring generally now to FIGS. 1 through 7, exemplary embodiments of the present invention are shown. To address timing driven buffer insertion and clock routing problems clusters of points must be constructed in 3-dimensional space. The first and second dimensions are coordinates on a plane, while the third dimension is time which is arrival pin time for buffers insertion and clock latency for clock routing.
- [0020]In an embodiment of the present invention, partitioning is performed on the base of a minimal spanning tree. There are methods of ElogE complexity where E is the number of edges in the graph, such as the method described in Algorithms for VLSI Physical Design Automation, by Naveed Sherwani, Kluwer Academic Publishers (1995), which is herein incorporated by reference in its entirety. However, in the present invention, a general method is employed which has N(logN)
^{2 }complexity, because any two of N points may be potentially connected by some edge. The present invention may be employed in two, three or more dimensional Euclidean space with Manhattan distance between points. - [0021]Instead of considering all possible edges for N input points, the present invention constructs a special graph. Each vertex has at most 2
^{K }closest vertexes in this graph. The linear dependence between the number of edges and the number of points reduces the complexity of the problem. The overall complexity of the method is N(logN)^{2}. The present invention may be employed in a FFS search engine, as described in U.S. patent application Ser. No. 09/678,313, titled “Fast Flexible Search Engine for Perfect Match” Attorney Docket Number 00-175, filed Oct. 4, 2000; and U.S. patent application Ser. No. 09/678,313, titled “Fast Flexible Search Engine for Longest Prefix Match” Attorney Docket Number 00-210, filed Oct. 4, 2000, which are herein incorporated by reference in their entirety. - [0022]The Spanning Tree Method
- [0023]In an embodiment of the present invention, the method includes three main parts:
a partitioning method; a method for making graph edges; and a method for reducing the number of graph vertexes. - [0024]The flow starts by partitioning given input set of points X
_{i}(n_{1}, n_{2}, . . . , n_{K}), i=1, 2, . . . N into a binary tree of partitions using a rule that every leaf partition may maximally have previously a defined number of points M. Progressing through the partitions tree, the second part of the program is performed so that for every point the_{2}K closest points are found in the 2^{K }directions of matter (K=2: right up, left up, left down, right down) and those points are connected thereby making edges of the graph. Based on the estimated edges, the final method decreases the number of components in the set of vertexes (a component contains one or more vertexes) until it becomes equal to the specified program input parameter C. - [0025]The Partitioning Method
- [0026]Referring now to FIG. 1, an exemplary method
**100**of the present invention is shown wherein a partitioning method operable to embody the present invention is shown. At the first step of the method, the number of points k in the current partition**102**is checked to determine if it is greater than M**104**. If it is, the median is calculated for every K coordinate and a coordinate nd which has the greatest quadratic deviation is chosen as the coordinate by which the partition is divided into two smaller partitions. An index i is implemented which represents the index of current point in the partition**108**. Every point that has nd coordinate value less or equal to the value of its median medd**110**is put into the “left” child partition**112**and all other points into the “right” child partition**114**. The terms “left” are “right” are utilized to distinguish the partitions, and should be apparent to a person of ordinary skill in the art that “left” and “right” are not to be limited by direction. The quadratic deviation is estimated as median of: - (
*X*_{i}*[n*_{d}*]−med*_{d})^{2}, i=1, 2, . . . ,k - [0027]where X
_{i}[n_{d}] is nd coordinate of point X_{i}. The method**100**continues by processing the “left” and “right” child recursively until the number of points in all leaf partitions becomes less or equal to M. - [0028]Method for Making Graph Edges
- [0029]This recursive method is performed for all points in the set. In FIG. 2, an embodiment
**200**of the present invention is shown wherein a two-dimensional (K=2) example for searching the closest point to point A in the right up direction (dir=RIGHT_UP) is illustrated. For this example, d=2, what means that the parent partition P has been divided by coordinate n_{2}. PL is the leaf partition and the “left” child of P and PR is the “right” child of P. - [0030]For this situation, the steps of the method are first, find the closest point to A (n
_{1A}, n_{2A}) in P_{L }by comparing distances to every point. Let it be some point C with referencing distance ref. - [0031]Second, as shown in the exemplary method
**300**depicted in FIG. 3, a method for finding a closest point is utilized. This algorithm extends the closest point quest on other partitions in the tree. If the smallest distance l_{u }from the partition PR to point A is less than ref**302**, maybe the partition P_{R }contains point that is closer to A than point C. The function findInside(P_{R}, dir, A, ref) may then be implemented**304**, which will be described in relation to FIG. 5. If l_{u }is not less than ref**302**, then the closer point is not in P_{R }and a determination is made as to whether the distance l_{r }to a neighbouring partition P_{n}, which is one level up in the partitions tree, is less than ref**306**. In that case, as in the case when l_{u}<ref, the same method**300**is applied to the parent partititon of PL and PR in the partitions tree, partition P. As is shown in FIG. 3, the recursion will stop when L_{u}≧ref and l_{r}≧ref. - [0032]Third, the call findInside(PR, dir, A, ref) may encounter a variety of situations, such as the three following situations for chosen example. First, the partition P
_{R }may be divided horizontally as shown in the example**400**depicted in FIG. 4A. In this example, the left**402**and right**404**children are P_{RL }and P_{RR}. Point T(n_{1T}, n_{2T}) is the top outline point of P_{RL}, C_{0 }is the closest point to the bottom outline point of P_{RR}. As shown in FIG. 5, if n_{1A}≦n_{1T }then if 1<ref, the closest point to A in the right child partition is C_{0 }and the left partition P_{RL }is checked (depends on partitioning but could be one of the three cases we are describing). If n_{1A}=n_{1T }the left partition**402**does not belong to considered subspace and after determining whether l<ref, the process is done. If n_{1A}>n_{1T}, just the P_{RR }partition is recursively examined. - [0033]Second, FIG. 4B depicts an embodiment
**450**showing the situation in which P_{RL }**452**is first examined and then if 1 is less then ref, P_{RR }**454**is considered. - [0034]Third, in the case of the embodiment
**470**shown in FIG. 4C a check is made for the possible closest point in the partition**472**by comparing distances from every partition point to A**474**. - [0035]The method contains parts for all other situations other than those previously described, the previous discussion being an example thereof. After the closest point in every direction of matter is found for every graph point, graph edges are obtained connecting corresponding points.
- [0036]Method for Reducing Number of Graph Vertexes
- [0037]Next, a method for reducing the number of graph vertexes is employed. The steps of the method include the following. First, edges e
_{l}(X_{s}, X_{e}) are sorted by length in ascending order. X_{s }and X_{e }are start and end points of the edge. Second, the set of components is initialized so that every vertex (graph point) is single component C_{Xi}. In this way, the number of components matches the number of vertexes. Third, edges are processed one by one until the number of components becomes input parameter C. - [0038]If size (C
_{Xs})>size(C_{Xe}), where size of the component is the number of belonging vertexes, a new component is made of these two components by moving all vertexes which have belonged to component C_{Xe }to C_{Xs}. The component C_{Xe }is then erased. If size(C_{Xs})<size(C_{Xe}), C_{Xs }is removed and C_{Xe }expanded in the described way. Thus, the number of components is decreased by one. The next edge is then considered, as shown in FIG. 6. - [0039][0039]FIG. 7 shows an exemplary program result for the two-dimensional test example.
- [0040]In exemplary embodiments, the methods disclosed may be implemented as sets of instructions or software readable by a device. Further, it is understood that the specific order or hierarchy of steps in the methods disclosed are examples of exemplary approaches. Based upon design preferences, it is understood that the specific order or hierarchy of steps in the method may be rearranged while remaining within the scope of the present invention. The accompanying method claims present elements of the various steps in a sample order, and are not meant to be limited to the specific order or hierarchy presented.
- [0041]Although the invention has been described with a certain degree of particularity, it should be recognized that elements thereof may be altered by persons skilled in the art without departing from the spirit and scope of the invention. One of the embodiments of the invention can be implemented as sets of instructions resident in the memory of one or more information handling systems, which may include memory for storing a program of instructions and a processor for performing the program of instruction, wherein the program of instructions configures the processor and information handling system. Until required by the information handling system, the set of instructions may be stored in another readable memory device, for example in a hard disk drive or in a removable medium such as an optical disc for utilization in a CD-ROM drive and/or digital video disc (DVD) drive, a compact disc such as a compact disc-rewriteable (CD-RW), compact disc-recordable and erasable; a floppy disk for utilization in a floppy disk drive; a floppy/optical disc for utilization in a floppy/optical drive; a memory card such as a memory stick, personal computer memory card for utilization in a personal computer card slot, and the like. Further, the set of instructions can be stored in the memory of an information handling system and transmitted over a local area network or a wide area network, such as the Internet, when desired by the user.
- [0042]Additionally, the instructions may be transmitted over a network in the form of an applet that is interpreted or compiled after transmission to the computer system rather than prior to transmission. One skilled in the art would appreciate that the physical storage of the sets of instructions or applets physically changes the medium upon which it is stored electrically, magnetically, chemically, physically, optically or holographically so that the medium carries computer readable information.
- [0043]It is believed that the system and method of the present invention and many of its attendant advantages will be understood by the forgoing description. It is also believed that it will be apparent that various changes may be made in the form, construction and arrangement of the components thereof without departing from the scope and spirit of the invention or without sacrificing all of its material advantages. The form herein before described being merely an explanatory embodiment thereof. It is the intention of the following claims to encompass and include such changes.

Referenced by

Citing Patent | Filing date | Publication date | Applicant | Title |
---|---|---|---|---|

US6826740 * | May 7, 2002 | Nov 30, 2004 | International Business Machines Corporation | Automated buffer insertion incorporating congestion relief for use in connection with physical design of integrated circuit |

US8381159 * | Dec 23, 2010 | Feb 19, 2013 | Renesas Electronics Corporation | Method of semiconductor integrated circuit, and computer readable medium |

US20030212976 * | May 7, 2002 | Nov 13, 2003 | International Business Machines Corporation | Automated buffer insertion incorporating congestion relief for use in connection with physical design of integrated circuit |

US20110161904 * | Dec 23, 2010 | Jun 30, 2011 | Renesas Electronics Corporation | Method of semiconductor integrated circuit, and computer readable medium |

Classifications

U.S. Classification | 716/125 |

International Classification | G06F17/50 |

Cooperative Classification | G06F17/5072 |

European Classification | G06F17/50L1 |

Legal Events

Date | Code | Event | Description |
---|---|---|---|

May 22, 2002 | AS | Assignment | Owner name: LSI LOGIC CORPORATION, CALIFORNIA Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:ANDREEV, ALEXANDER E.;VUKOVIC, VOJISLAV;REEL/FRAME:012934/0780 Effective date: 20020521 |

May 14, 2007 | FPAY | Fee payment | Year of fee payment: 4 |

Jun 9, 2011 | FPAY | Fee payment | Year of fee payment: 8 |

May 8, 2014 | AS | Assignment | Owner name: DEUTSCHE BANK AG NEW YORK BRANCH, AS COLLATERAL AG Free format text: PATENT SECURITY AGREEMENT;ASSIGNORS:LSI CORPORATION;AGERE SYSTEMS LLC;REEL/FRAME:032856/0031 Effective date: 20140506 |

Jun 6, 2014 | AS | Assignment | Owner name: LSI CORPORATION, CALIFORNIA Free format text: CHANGE OF NAME;ASSIGNOR:LSI LOGIC CORPORATION;REEL/FRAME:033102/0270 Effective date: 20070406 |

Apr 3, 2015 | AS | Assignment | Owner name: AVAGO TECHNOLOGIES GENERAL IP (SINGAPORE) PTE. LTD Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:LSI CORPORATION;REEL/FRAME:035390/0388 Effective date: 20140814 |

Jul 24, 2015 | REMI | Maintenance fee reminder mailed | |

Dec 16, 2015 | LAPS | Lapse for failure to pay maintenance fees | |

Feb 2, 2016 | AS | Assignment | Owner name: AGERE SYSTEMS LLC, PENNSYLVANIA Free format text: TERMINATION AND RELEASE OF SECURITY INTEREST IN PATENT RIGHTS (RELEASES RF 032856-0031);ASSIGNOR:DEUTSCHE BANK AG NEW YORK BRANCH, AS COLLATERAL AGENT;REEL/FRAME:037684/0039 Effective date: 20160201 Owner name: LSI CORPORATION, CALIFORNIA Free format text: TERMINATION AND RELEASE OF SECURITY INTEREST IN PATENT RIGHTS (RELEASES RF 032856-0031);ASSIGNOR:DEUTSCHE BANK AG NEW YORK BRANCH, AS COLLATERAL AGENT;REEL/FRAME:037684/0039 Effective date: 20160201 |

Feb 2, 2016 | FP | Expired due to failure to pay maintenance fee | Effective date: 20151216 |

Rotate