Source: http://www.google.com/patents/US7966598?dq=inassignee:doubleclick
Timestamp: 2015-07-08 00:28:30
Document Index: 628817885

Matched Legal Cases: ['art 200', 'art 300', 'art 300', 'art 300', 'art 300', 'art 900', 'art 900', 'art 900']

Patent US7966598 - Top level hierarchy wiring via 1�N compiler - Google PatentsSearch Images Maps Play YouTube News Gmail Drive More »Sign inAdvanced Patent SearchPatentsEmbodiments that route 1�N building blocks using higher-level wiring information for a 1�N compiler are disclosed. Some embodiments comprise determining higher-level coordinates for a blockage of a 1�N building block, determining intra-1�N coordinates for a shape of the blockage via the higher-level...http://www.google.com/patents/US7966598?utm_source=gb-gplus-sharePatent US7966598 - Top level hierarchy wiring via 1�N compilerAdvanced Patent SearchPublication numberUS7966598 B2Publication typeGrantApplication numberUS 12/201,643Publication dateJun 21, 2011Filing dateAug 29, 2008Priority dateAug 29, 2008Fee statusPaidAlso published asUS20100058275Publication number12201643, 201643, US 7966598 B2, US 7966598B2, US-B2-7966598, US7966598 B2, US7966598B2InventorsAnthony L. Polomik, Benjamin J. Bowers, Anthony Correale, Jr., Matthew W. Baker, Irfan Rashid, Paul M. SteinmetzOriginal AssigneeInternational Business Machines CorporationExport CitationBiBTeX, EndNote, RefManPatent Citations (65), Non-Patent Citations (10), Referenced by (5), Classifications (8), Legal Events (3) External Links: USPTO, USPTO Assignment, EspacenetTop level hierarchy wiring via 1�N compiler
US 7966598 B2Abstract
Embodiments that route 1�N building blocks using higher-level wiring information for a 1�N compiler are disclosed. Some embodiments comprise determining higher-level coordinates for a blockage of a 1�N building block, determining intra-1�N coordinates for a shape of the blockage via the higher-level coordinates, and creating routes of intra-1�N wires of the 1�N building block that avoid the intra-1�N coordinates. Further embodiments comprise an apparatus having a higher-level wiring examiner to examine higher-level wiring of an area near a 1�N building block of a physical design representation. The apparatus may also have a blockage determiner to determine a blockage that affects intra-1�N wiring for the 1�N building block and a coordinate calculator to calculate coordinates of a shape of the blockage, wherein the calculated coordinates may enable a routing tool to avoid the shape when creating intra-1�N wiring for the 1�N building block.
using a computer to perform the following operations:
determining higher-level coordinates for a blockage of a 1�N building block, wherein the blockage is from higher-level wiring for an area above the 1�N building block;
determining intra-1�N coordinates for the blockage via the higher-level coordinates; and
creating routes of intra-1�N wires of the 1�N building block that avoid the intra-1�N coordinates.
2. The method of claim 1, further comprising using the computer to perform the operation of storing the intra-1�N coordinates in an image file for a routing tool of an integrated circuit (IC) design application.
3. The method of claim 2, further comprising using the computer to perform the operation of recompiling, via the image file, the 1�N building block to create one of a behavioral representation, a logical representation, and a physical design representation.
4. The method of claim 2, further comprising using the computer to perform the operation of creating additional routes of intra-1�N wires based on the recompiling of the 1�N building block.
5. The method of claim 2, wherein the using the computer to perform the operation of creating the routes comprises using the computer to perform the operation of reading the image file for a routing tool of an IC design application.
6. The method of claim 1, further comprising using the computer to perform the operation of adding the 1�N building block to a list that comprises 1�N building blocks with blockages, wherein the list is to be used for using the computer to perform the operation of creating routes of intra-1�N wires for the 1�N building blocks.
7. The method of claim 1, wherein the using the computer to perform the operation of determining the higher-level coordinates for the blockage comprises using the computer to perform the operation of interpreting physical information for at least one of global wiring metal and a via.
a higher-level wiring examiner to examine higher-level wiring of an area near a 1�N building block of a physical design representation;
a blockage determiner to determine a blockage via the examination, wherein the blockage affects intra-1�N wiring for the 1�N building block; and
a coordinate calculator to calculate coordinates of the blockage, wherein the calculated coordinates enable a routing tool to avoid the blockage when creating intra-1�N wiring for the 1�N building block.
9. The apparatus of claim 8, further comprising a placement generator to generate a physical placement for the 1�N building block in the physical design representation.
10. The apparatus of claim 9, wherein the higher-level wiring examiner, the blockage determiner, and the coordinate calculator comprise elements of a 1�N compiler, wherein the 1�N compiler is arranged to generate updated behavioral representations, updated logical representations, and updated physical design representations via the physical placement.
11. The apparatus of claim 8, further comprising an intra-1�N router to generate intra-1�N wire routing and vias for the 1�N building block.
12. The apparatus of claim 8, wherein the apparatus is arranged to save a shape of the calculated coordinates in an image file to be used by the routing tool.
13. The apparatus of claim 8, further comprising the routing tool.
14. The apparatus of claim 8, wherein the higher-level wiring examiner is arranged to examine areas near a plurality of 1�N building blocks of a list, wherein the list comprises a subset of 1�N building blocks of the physical design representation.
program instructions, stored on at least one of the one or more storage devices, to determine higher-level coordinates for a blockage of a 1�N building block, wherein the blockage is from higher-level wiring for an area above the 1�N building block;
program instructions, stored on at least one of the one or more storage devices, to determine intra-1�N coordinates for the blockage via the higher-level coordinates; and
program instructions, stored on at least one of the one or more storage devices, to create routes of intra-1�N wires of the 1�N building block that avoid the intra-1�N coordinates.
16. The computer program product of claim 15, further comprising program instructions, stored on at least one of the one or more storage devices, to store the intra-1�N coordinates in an image file for use with a routing tool.
17. The computer program product of claim 16, further comprising program instructions, stored on at least one of the one or more storage devices, to recompile the 1�N building block, via the image file, and create updated behavioral representations, updated logical representations, and updated physical design representations.
18. The computer program product of claim 17, further comprising program instructions, stored on at least one of the one or more storage devices, to create additional routes of intra-1�N wires based on the recompilation.
19. The computer program product of claim 16, further comprising program instructions, stored on at least one of the one or more storage devices, to read the image file for the routing tool.
20. The computer program product of claim 15, wherein the program instructions that determine the intra-1�N coordinates determine the intra-1�N coordinates based on higher-level wiring that causes one of a short and a design rule check violation. Description
The present invention generally relates to the field of integrated circuits. More particularly, the present invention relates to routing 1�N building blocks using higher-level wiring information for a 1�N compiler. The integrated circuits of today commonly have hundreds of millions of transistors on a single chip, with many critical circuit features having measurements in the deep sub-micron range. As manufacturers implement more and more circuit elements in smaller and smaller silicon substrate surface areas, engineers and designers develop hardware and software tools to automate much of the integrated circuit design and manufacturing process.
Some embodiments comprise determining higher-level coordinates for a blockage of a 1�N building block. For example, the blockage may be due to higher-level wiring for an area above the 1�N building block. The embodiments may further include determining intra-1�N wiring coordinates for a shape of the blockage via the higher-level coordinates and creating routes of intra-1�N wiring of the 1�N building block that avoid the intra-1�N coordinates.
Further embodiments comprise an apparatus having a higher-level wiring examiner to examine higher-level wiring of an area near a 1�N building block of a physical design representation. The apparatus may also have a blockage determiner to determine a blockage that affects intra-1�N wiring for the 1�N building block and a coordinate calculator to calculate coordinates of the blockage, wherein the calculated coordinates may enable a routing tool to avoid the blockage when creating intra-1�N wiring for the 1�N building block.
Even further embodiments comprise a computer program product comprising a computer readable medium having a computer readable program, wherein the computer readable program causes the computer to determine higher-level coordinates for a blockage of a 1�N building block, such as blockage from higher-level wiring for an area above the 1�N building block. The computer readable program further causes the computer to determine intra-1�N coordinates for the blockage via the higher-level coordinates and create routes of intra-1�N wiring of the 1�N building block that avoid the intra-1�N coordinates of the blockage.
FIG. 1 depicts a computing system that may design integrated circuits using a closed-loop 1�N compiler;
FIG. 2 is a flowchart illustrating different phases of a 1�N design process, including a 1�N compilation stage;
FIG. 3 illustrates design flow for a 1�N compilation for one or more embodiments;
FIG. 4A illustrates one embodiment of a closed-loop cycle between the elements of 1�N compilation and a logic phase;
FIG. 4B illustrates one embodiment of a closed-loop cycle between the elements of 1�N compilation and a synthesis phase;
FIG. 4C illustrates a process of automatically maintaining changes made to the 1�N building blocks during a physical design phase via mechanisms of back-annotation and reassembly;
FIG. 4D illustrates one embodiment of a closed-loop cycle between the elements of 1�N compilation and a timing analysis phase;
FIG. 5 shows a graphical user interface window that a designer may use when creating or modifying 1�N building blocks;
FIGS. 6A-6B show different configurations of a 1�N building block;
FIG. 7A depicts a 1�N compiler that may use higher-level wiring information for routing 1�N building blocks;
FIG. 7B illustrates one embodiment of a 1�N compiler routing flow diagram that uses higher-level wiring information for routing 1�N building blocks;
FIG. 8 is a flow diagram of a process used in semiconductor design, manufacture, and/or test using a 1�N design compiler; and
FIG. 9 depicts a flowchart illustrating a method of routing 1�N building blocks using higher-level wiring information for a 1�N compiler.
Many of the embodiments contained herein describe using 1�N building blocks to design an integrated circuit. A circuit layout or circuit design may comprise a hierarchical collection of circuit elements or cells. A building block, or macro, may generally refer to the concept that a circuit may comprise a plurality of different circuit elements or cells, wherein the cells may be divided into categories. These categories may be basic cells, level cells, and building blocks. Basic cells, which may alternatively be referred to as leaf cells, may comprise an aggregation of circuit elements, such as a collection of logic gates, and may be thought of as residing at the bottom of the design hierarchy. Basic cells may be nested together, along with other circuit elements, to form level cells at different mid-levels within the design hierarchy. The level cells, which are frequently referred to as composition cells, may be further nested together to form building blocks, alternatively referred to as macros, which may also be referred to as root cells or prime cells. Building blocks may be thought of as residing at the top of the design hierarchy. Building blocks may also be referred to as blocks or modules.
1�N building blocks may contain a homogeneous collection of cells, also commonly referred to as bits, or contain an inhomogeneous collection of cells. For example, one 1�N building block may contain four AND gates while another 1�N building block may contain two AND gates, three NAND gates, and two OR gates, as well as auxiliary bits or cells. Additionally, while some bits of 1�N building blocks may be relatively simple, such as comprising a latch, some bits may also comprise a more complex collection of elements, such as comprising multiplexers. As one skilled in the art will appreciate, 1�N building blocks differ from a simple grouping or collection of cells. The bits of 1�N building blocks may be grouped together in a single row or column, along with the auxiliary cells, and processed as a functional unit by a 1�N compiler, hence the term “1�N” or “one-by-N”.
Turning now to the drawings, FIG. 1 illustrates a computing system 100 that may route 1�N building blocks 155 using higher-level wiring information for a 1�N compiler 160. For example, computing system 100 may comprise a design workstation or a desktop computer executing a very-large-scale integration (VLSI) design application 145 in memory 140. A circuit designer may receive a specification for an integrated circuit (IC). Based on the specification, the circuit designer may define architecture for the IC and develop a circuit design for the IC at a very high level of abstraction.
Higher-level placement data, such as the locations of individual 1�N building blocks and how the blocks are situated in relation to the other circuit elements, may also affect the physical realizations and/or internal wiring of the 1�N building blocks. Interconnectivity of common signals, such as clock and decode signals, may be tuned or altered to reflect expected blockages due to the higher hierarchy level.
1�N compiler 160 and VLSI design application 145 may provide a closed-loop environment that employs high-level 1�N constructs for tuning performance and power consumption. VLSI design application 145 may capture logic using both high-level RTL and references to 1�N building blocks. 1�N compiler 160 and VLSI design application 145 may represent the 1�N building blocks via a high-level language and transform the 1�N building blocks into custom realizations using, e.g., building blocks available in a standard or custom cell library.
Using input device 120 a circuit designer may interact with VLSI design application 145. In one or more embodiments, input device 120 may comprise a keyboard and/or a mouse, allowing the circuit designer to perform such actions as viewing different circuit sections or performing numerous circuit design activities such as performing a timing analysis, increasing the drive strength of a gate, or defining which circuit elements should not be modified during various design cycle iterations. In some embodiments input device 120 may comprise a tablet and stylus, such as a pressure-sensitive surface or a capacitance pad that recognizes hand-written characters and stylus movement. In even further embodiments input device 120 may comprise an audible input device, such as a microphone used for speech recognition. For example, in one embodiment input device 115 may allow a circuit designer to automate one or more tasks during the design flow, such as by recognizing when the circuit designer speaks the phrase “calculate Vt-hybridization values for selected 1�N building blocks”.
Display 110 and input device 120 may also allow the circuit designer to interact with VLSI design application 145 when creating, viewing, and manually modifying various 1�N building blocks 155. For example, 1�N block builder 150 may allow a circuit designer to retrieve a 1�N building block from a cell library 130, stored on a storage device 125. Storage device 125 may comprise a local solid state drive or a network hard drive, as examples, which stores standard cells and various instantiations created by a circuit designer. Upon retrieving a 1�N logic block, 1�N block builder 150 may allow a circuit designer to edit the 1�N building block by displaying configuration information for the 1�N building block in window 115. After editing the 1�N building block, VLSI design application 145 may save the edited version back to cell library 130.
In the embodiment depicted in FIG. 1, VLSI design application 145 may design an IC using a closed-loop 1�N methodology, the specific details of which will be discussed later. However, to gain a general understanding of some of the steps that may be involved in the closed-loop 1�N methodology, as well as how this closed-loop methodology may differ from an open-loop design methodology, one may examine FIG. 2. FIG. 2 shows a flowchart 200 illustrating how a design for an IC may begin with a design concept 210.
The logical representation may comprise gate-level logic, such as AND, OR, NOT, NAND, and NOR gates, to name just a few. The gate-level logic may be arranged to implement the desired functionality described in the high-level HDL code. The tools that perform the conversion from the high-level description to the gate-level logic are generally called synthesis tools. For example, a set of synthesis programs from Synopsys� may perform the conversion from the high-level code to the logic-level code. As is known to those skilled in the art, the logical representation, or logic-level code, may be referred to as gate-level netlists. The logical representation may comprise a netlist of high-level macrocell components, such as adders, pipelined multipliers, arithmetic logic units, multiplexers, and register-files. Each macrocell, or building block, may have a corresponding netlist of primitive cells as well as a corresponding custom layout. This gate-level netlist of primitive cells and the layout may be generated using a silicon compiler tool, like 1�N compiler 160.
During an open-loop design sequence, the circuit designer may need to exert caution to prevent having the accumulated design improvements altered or negated, due to disjointed activities of capturing logic in logic phase 220 and developing the physical design in physical design phase 240. Until the design reaches the logic-freeze stage, which halts subsequent synthesis in synthesis phase 230, physical optimizations such as tweaks made for drive strengths and power optimization may be lost during subsequent synthesis iterations. Using a closed-loop methodology offered by 1�N compilation 260, an application like VLSI design application 145 may maintain these physical optimizations without depending on disjointed tools and databases.
1�N compilation 260 may allow a VLSI design system to employ a closed-loop design process whereby physical implementation details, such as alterations due to drive strength and power optimization, may be fed back into each step of the design process. The VLSI design system may feed the design alterations back to the different design phases by using 1�N building blocks and inserting data generated by compiling the 1�N building blocks back into the design flow.
A VLSI design system may use a 1�N compiler during 1�N compilation 260 to create, modify, and maintain 1�N macros through the design process. As will be illustrated in the subsequent discussion of the various embodiments, the 1�N compiler may directly update the configuration file or files of a circuit design in a closed-loop manner. Additionally, the 1�N compiler may support direct wiring, have built-in design-for-manufacturability features, and have hierarchical wiring avoidance.
As FIG. 2 illustrates, the 1�N design methodology may involve a primary design loop and secondary design loops. The solid lines between design concept 210, logic phase 220, synthesis phase 230, physical design phase 240, timing phase 250, 1�N compilation 260, and back to logic phase 220 may represent the closed-loop nature of the primary design loop. The primary design loop shows the design flow through various stages of the design. Circuit designers may spend large quantities of time engaged in the various activities of the primary design loop, which may be characterized as the pre-logic-freeze design flow. In other words, the optimization decisions made in each phase of the methodology, such as synthesis phase 230, physical design phase 240, and timing phase 250, may be fed back into logic phase 220 via 1�N compilation 260 to iterate through the primary design loop again. Iterations through the primary design loop may involve changing 1�N building blocks and/or logical RTL structure. Each iteration or progression through the primary design loop may provide an improved starting seed for automated synthesis and optimization algorithms.
FIG. 2 also illustrates a number of smaller secondary design loops represented by the dashed lines. For example, one of the secondary design loops may comprise the loop defined by progressing from logic phase 220 to 1�N compilation 260, back to logic phase 220. Another secondary design loop may comprise the loop defined by progressing from 1�N compilation 260, to synthesis phase 230, to physical design phase 240, and back to 1�N compilation 260. The dashed lines may represent iterative changes through individual design phases and/or through iterative loops of multiple phases of the design, without necessarily progressing through the complete primary design loop. A 1�N design system may employ a closed-loop process to feed optimizations developed in a single design phase into another design phase without necessarily losing physical information.
With a general understanding of some of the steps that may be involved in the closed-loop 1�N methodology, we return now to FIG. 1. In various embodiments, a computing system like computing system 100 may execute a variety of different applications in addition to VLSI design application 145. For example, computing system 100 may execute a synthesis application and/or performance tuning tools 190. In one or more embodiments, tools 190 may represent a number of different applications comprising a tool suite. A circuit designer may use tools 190 to transform Verilog or VHDL code into a netlist describing the hardware for the physical design. A circuit designer may also use tools 190 to simulate the circuit design, perform timing analyses of the design, and generate a routing design for the circuit elements. In other words, tools 190 may comprise one or more applications that may work in conjunction with VLSI design application 145 and alter the circuit design as the circuit designer progresses through the various design stages, as illustrated in FIG. 2.
Depending on the embodiment, computing system 100 may run a variety of different operating systems. For example, in one embodiment computing system 100 may use AIX�. In another embodiment, computing system may use Microsoft� Windows�, Linux�, or Mac OS�, as examples. Other alternative embodiments may have no operating system at all. For example, computing system 100 may comprise a state machine or microcontroller executing firmware instructions, such that no operating system is necessary.
While not shown in FIG. 1, alternative embodiments of a computing device in a system may connect to other computers of the system using a variety of different hardware. For example, computing system 100 may comprise a CAD workstation computer connected to another computer via a wireless communications card, or an Ethernet cable coupled to a local or wide area network (LAN or WAN). The desktop computer may, e.g., download and import cell files and/or 1�N building blocks from the Internet.
In one or more alternative embodiments, computing system 100 may also work with one or more other networked computing devices to perform one or more of the different design activities. For example, in one embodiment computing system 100 may edit and compile 1�N building blocks and generate a schematic view for the IC design. However, during the synthesis, physical design, or timing analysis stages, VLSI design application 145 may transfer netlist 185 for the design to the networked computer(s). Such an arrangement may be desired, for example, where the design task requires extensive computational power that may otherwise overload computing system 100. As the above example illustrates, various embodiments of a system may comprise an almost limitless number of wired and wireless communication devices, allowing computing devices of a system to communicate with each other to share and/or process VLSI design files, wherein the computers may be located close to or remote from each other.
As described earlier, 1�N compiler 160 and VLSI design application 145 may work with 1�N building blocks 155. 1�N building blocks 155 may comprise the means by which physical implementation details of circuit elements in 1�N building blocks 155 are stored. A building block of 1�N building blocks 155 may provide a layer of abstraction between the logical behavior of the block and the physical realization of the corresponding logic elements. In numerous embodiments, 1�N building blocks 155 may comprise one or more user-configurable text files. In alternative embodiments, the building blocks may be represented in an alternative file format. For example, the building blocks may be stored in a proprietary binary file that is encoded and decoded as a circuit designer views/edits the 1�N building blocks.
1�N compiler 160 may perform a variety of tasks in VLSI design application 145. 1�N compiler 160 may comprise a software module or other type of module that, at a high level of abstraction, converts data from the building blocks of 1�N building blocks 155 into behavioral, physical, and logical representations, or definitions. 1�N compiler 160 may convert 1�N building blocks 155 into specifically formatted implementations as required by the different design phases. For example, conversions of 1�N building blocks 155 may be represented by 1�N compilation 260 in FIG. 2. During 1�N compilation 260, 1�N compiler 160 may take 1�N building blocks 155 generated by physical design 240 and reformat 1�N building blocks 155 into a form compatible with logic stage 220, without losing physical information that may have been generated in previous design iterations. Similarly, during 1�N compilation 260, 1�N compiler 160 may take 1�N building blocks 155 generated by logic phase 220, synthesis phase 230, or timing phase 250 and reformat 1�N building blocks 155 into a form or forms compatible with each of the phases, without losing physical, behavioral, or logical information that may have been generated in previous design iterations.
FIG. 3 depicts a flowchart 300 that illustrates a design flow of a 1�N compilation for one or more embodiments. FIG. 3 illustrates how a circuit designer may use a 1�N block builder 310 to retrieve and edit one or more building blocks from a circuit library 305. For example, 1�N building block 315 may comprise a specific instantiation of 1�N building blocks 155 retrieved from cell library 130 and loaded into 1�N block builder 150.
1�N block builder 310 may comprise a graphical user interface (GUI) routine that allows the circuit designer to create one or more building blocks and implement a desired logical function. For example, 1�N block builder 150 may allow the circuit designer to create a bank of NAND logic gates in a relatively easy and efficient manner without having to be familiar with the actual scripting language required by 1�N compiler 160.
In various embodiments, 1�N block builder 310 may comprise the initial entry point to the 1�N compilation stage, which may correspond to 1�N compilation 260 shown in FIG. 2. 1�N block builder 310 may provide a layer of abstraction between the complexity of the physical elements comprising 1�N building block 315 and the associated logical representation. 1�N block builder 310 may check design requirements for each logical function and generate or create 1�N building block 315 that provides the proper gate constructs. 1�N block builder 310 may check the design requirements and create 1�N building block 315 without requiring the circuit designer to intervene or potentially even understand the design requirements.
While 1�N block builder 310 may generate a default set of implementation details, the designer may be able to choose between specific implementation types and make specific customizations for 1�N building block 315, such as specific drive strengths, Vt-hybridizations, and/or voltage island references. Once the designer has chosen a desired 1�N building block 315 to build, 1�N block builder 310 may generate a logical RTL instantiation for 1�N building block 315, as well as the physically crafted realization of 1�N building block 315. One embodiment of a window for block builder 310 is depicted in FIG. 5. For example, 1�N block builder 150 may generate window 500 on display 110 when a circuit designer edits a specific building block, such as illustrative 1�N building block 600 depicted in FIG. 6A.
As FIG. 6A illustrates, 1�N building blocks may include a physical tiling methodology to create a row 610 of duplicate or similar cells, one or more overhead or support cells, as well as associated interconnectivity that matches the logic specification for the cells. For example, one 1�N building block may comprise a number of NAND gates, various parameters for one or more of the individual gates, two support cells, and some interconnection data. Another 1�N building block may comprise a row of multiplexers and support cells. As one skilled in the art will realize, the type of common cell for a 1�N building block, as well as the number of support cells and parameters, may vary greatly from building block to building block. The examples cited above and elsewhere in the specification are only a few examples cited for the sake of illustration. One should not interpret that 1�N building blocks are limited to the cited configurations. On the contrary, the different configurations or arrangements of cells and parameters for different 1�N building blocks are innumerable.
Compiling 1�N building blocks like 1�N building block 600 with a 1�N compiler may enable a VLSI design application to perform numerous transformations, or modifications, to elements and/or cells in the building blocks during the design process. The VLSI design application or a designer may invoke timing optimizations and/or power optimizations, either directly through synthesis refinement or manually via engineering change (EC) mode. The designer or VLSI design application may change predefined 1�N building blocks. For example, the designer may transform such parameters as polarity, drive strength, and hybrid-Vt for 1�N building blocks, thereby creating custom 1�N building blocks.
Using a 1�N compiler within a 1�N building block methodology to design a VLSI circuit may create a framework that allows 1�N building blocks to be utilized in different ways. For example, in some embodiments, 1�N building blocks may be configured for use with industry-standard formats. In other embodiments, the 1�N compiler may allow the 1�N building blocks to use alternative, special, or proprietary features. As will be illustrated, the 1�N compiler may have the ability to “reform” or reassemble hierarchy from a previously flattened hierarchical design, allowing optimization tools that work on flat data to nonetheless enable use of 1�N building blocks.
FIG. 6A depicts what may comprise a fully-realizable 1�N building block 600 in an embodiment. 1�N building block 600 may comprise a single-port, non-inverting latch bank with clock enable based on designer input from 1�N block builder 310. Alternatively, 1�N building block 600 may comprise a default implementation of a 1�N building block. FIG. 6A shows a single latch type (A) arranged in rows 4-16 (element 628) with two clock splitters (element 615) arranged in rows 0-1 and 2, and an overhead latch (element 620) in row 3. FIG. 6A also depicts the associated logical RTL 605 generated by the 1�N block builder for 1�N building block 600. Worth noting, FIG. 6A shows the elements of 1�N building block 600 arranged in a row, horizontally. As one skilled in the art will appreciate, the arrangement of the elements of 1�N building block 600, or other 1�N building blocks, does not have to be in a row, or horizontally situated. For example, the elements may instead be located in a different manner, such as in a column, running vertically from top-to-bottom or bottom-to-top.
FIG. 6B shows another customized 1�N building block 660 corresponding to 1�N building block 600 illustrated in FIG. 6A. FIG. 6B further illustrates the flexibility of a 1�N Building Block. 1�N building block 660 has four different Vt-hybridization choices 665, represented by “instdef A” through “instdef D”, for the latch bits and the physical placement data for each cell in 1�N building block 660. As FIG. 6B illustrates, the latch bits are staggered in rows 0-4, 7-9, 11, and 13-16 with each Vt-hybridization choice represented by a different letter. The two clock splitters are staggered in rows 5-6 and 10 with the overhead latch arranged in row 12.
1�N building blocks 600 and 660 are exemplary building blocks, none of which may be required in any specific embodiment. 1�N building blocks 600 and 660 may be the results of individual optimizations through each design phase in order to meet power, area, and timing goals for one particular latch bank and the associated timing paths for the latch bank. Various integrated circuit parameters may vary with factors such as temperature, voltage and frequency. One circuit parameter that a circuit designer may adjust is the drive strength of one or more circuit devices, such as an output driver stage. For example, the circuit designer may match the output drive strength of a signal to the circuit being driven. Another parameter that a circuit designer may adjust is Vt-hybridization. Vt-hybridization refers to an optimization technique for static power reduction while optimizing performance within a given drive strength. Worth emphasizing, in many embodiments the polarity of individual bits of a 1�N building block may also be modified by optimization routines. Additionally, the polarity of individual bits may be manually modified.
Returning back to FIG. 3, uniquifier 320 may comprise a software module or other type of module that permits individual building blocks 315, which may correspond to individual building blocks of 1�N building blocks 155 of FIG. 1, to be reused within a design. When a designer decides to reuse a 1�N building block, at a particular step in the design phase, the designer may designate a parent definition and a number of child definitions for that 1�N building block. In other words, uniquifier 320 may create a type of software inheritance, wherein each child definition may inherit the properties of the related parent definition, unless the inheritance is overridden. For example, uniquifier 165 may work in conjunction with 1�N compiler 160 during the 1�N compilation stage, read a netlist 185, read the current set of building blocks of 1�N building blocks 155, and determine whether any building blocks are reused. If any building blocks are reused, uniquifier 165 may create parent-child definitions where such definitions do not already exist and produce a new netlist 185 with unique names for each child that directly corresponds to the child definitions created with the building block definitions.
In some embodiments, uniquifier 320 may also be configured to selectively ignore or uniquify specific sets of 1�N building blocks 315. Selective uniquification of building blocks may be advantageous in situations where parent-child relationships do not need to be defined during the logic entry stage, which may correspond to logic phase 220. The parent-child relationships may be defined on-the-fly as the relationships are required for a design stage. Depending on the embodiment, uniquifier 320 may be configured to read netlist 330 in a mixture of different formats. For an example referring to FIG. 1 and FIG. 2, uniquifier 165 may read netlist 185 formatted in one format generated in physical design phase 240, yet also read a modified version of netlist 185 formatted in a second format generated after tuning from timing phase 250.
During the various iterations of a design, 1�N compiler 340 may generate compilation data for a number of different views 350. The different views of views 350, which may correspond to output view data 180 depicted in FIG. 1, may comprise behavioral representations, gate-level or logical representations, physical design representations, and an output view for various types of scripts.
1�N compiler 340 may generate compilation data for behavioral RTL as well as gate-level RTL. Additionally, 1�N compiler 160 may generate compilation data for physical views, helper scripts, and potentially numerous other views depending on the embodiment. For example, VLSI design application 145 may use 1�N compiler 160 to generate Verilog HDL behavioral RTL and corresponding Cadence™ physical views. Additionally, in numerous embodiments, 1�N compiler 160 may be configured based on the tool suite of the user, such as tools 190. In other words, an embodiment may control which languages and view types are generated. An alternative embodiment may generate VHDL behavioral RTL and corresponding Synopsys� physical views.
To illustrate in more detail the iterative logic, synthesis, physical design, and timing cycles for 1�N building blocks, we turn now to FIGS. 4A-4D. For the sake of illustrative context, logic phase 410 and 1�N compilation 402 of FIG. 4A may correspond to logic phase 220 and 1�N compilation 260 shown in FIG. 2, respectively. The closed loop may comprise the design flow from logic stage 220 to 1�N compilation 260, via the secondary/dashed flow line, and back from 1�N compilation 260 to logic stage 220, via the solid/primary flow line. Additionally, 1�N building block 404 and 1�N compiler 406 may correspond to 1�N building block 315 and 1�N compiler 340, respectively, of FIG. 3.
FIG. 4A illustrates one embodiment of a closed-loop cycle between the elements of 1�N compilation 402 and logic phase 410. For example, during a design of an integrated circuit, a circuit designer may have created the behavioral RTL, synthesized the RTL and converted the design from a behavioral script form to a physical design form, and tuned or optimized the flattened form of the physical design to meet certain performance requirements. The circuit designer may then take the flattened physical design altered during a timing analysis and view/modify the behavioral definition of the design at logic phase 410. In other words, the designer may generate a behavioral view 408 from the flattened physical design via 1�N compilation 402. Behavioral view 408 may comprise, e.g., a VHDL listing for the design. Worth pointing out, the entry point into 1�N compilation 402 to generate behavioral view 408 may be from one of the other stages, not just logic stage 410 as depicted in FIG. 4A. As described in the example, the entry point into 1�N compilation 402 was from the timing stage, such as from timing phase 250 as illustrated in FIG. 2.
The iterative logic cycle depicted in FIG. 4A may enable more liberal logic reuse by increasing the level of abstraction for the gate-level design by using 1�N building blocks, such as 1�N building block 404. The use of 1�N building blocks may enable the increase of logic reuse as a result of decoupling the gate-level implementation of a 1�N building block from its logical function via the use of the 1�N compiler. To illustrate the increase of abstraction and the decoupling of the gate-level implementation from the logical function, we may briefly examine FIG. 5. As shown in FIG. 5, an RTL instantiation of a 1�N building block may include parameterized calls 580 that describe features of 1�N building blocks. For example, the 1�N building block features may include a logical function type and a number of bits for the 1�N building block. Logical function types and numbers of bits are just example features; other features may be available in various alternative embodiments.
1�N compiler 406 may insert checks, or verification text, in the 1�N behavioral RTL model for the parameterized features. When the design is simulated via an RTL simulation tool, the verification text may ensure that the intent of the designer, which is described in the RTL, matches the gate-level implementation defined by the 1�N behavioral model. One should note that the behavioral model for a 1�N building block may not need to be gate-specific. As a behavioral model, the model may describe the logical function using higher-level constructs. The higher-level constructs may be defined by the RTL language used. For example, the higher-level constructs for System Verilog may be different than the higher-level constructs for VHDL.
1�N compiler 406 may verify that the behavioral model, which may be represented by behavioral view 408, and the gate-level implementation are equivalent. For example, in one embodiment 1�N compiler 406 may verify that the behavioral model and the gate-level implementation are equivalent by using one or more verification tools. The verification tools may be, e.g., industry standard verification tools available in IC design systems available from Cadence™, Synopsys�, Mentor Graphics�, Magma�, or other design systems. Verifying the equivalency of the behavioral model and the gate-level implementation may help protect the designer from inadvertent changes during the logic design, as well as protect the designer from gate-level changes that might alter a function of a 1�N building block.
The behavioral model construct generated by 1�N compiler 406 may allow the circuit designer to reuse 1�N building block 404 and related logical function(s) in the design without having to worry about the gate-level tweaks that may be necessary for proper placement or timing of the specific 1�N building block. Consequently, using the generated behavioral model may also help protect the intellectual property described in the gate-level netlist because the gate-level details are not directly disclosed by the RTL listing. In other words, a hardened or physically-realized design that uses this 1�N building block methodology may be converted to a softened, or RTL-level, design and transferred to another party with less risk of exposing physical details, which may be sensitive or proprietary in nature. Generating an RTL-level design from a physically-realized design may not necessarily be limited to 1�N building blocks. 1�N compiler 406 may generate an RTL-level design from other types of hierarchical RTL elements. In other words, the 1�N methodology described herein may provide an automated closed-loop approach that may used to create RTL-level or behavioral-level design for numerous other RTL elements.
To illustrate in more detail the iterative synthesis cycle, we move to FIG. 4B. Synthesis phase 440 and 1�N compilation 420 of FIG. 4B may correspond to synthesis phase 230 and 1�N compilation 260, respectively, shown in FIG. 2. The closed loop may comprise the design flow from synthesis phase 230 to 1�N compilation 260, via the secondary/dashed flow line exiting synthesis phase 230, and back from 1�N compilation 260 to synthesis phase 230, via the secondary/dashed flow line between the two. Additionally, internal elements of 1�N compilation 420 may correspond to the respective elements depicted in flowchart 300 for FIG. 3.
FIG. 4B illustrates one embodiment of a closed-loop cycle between the elements of 1�N compilation 420 and synthesis phase 440. Synthesis phase 440 may comprise a stage in the design process where a design application like VLSI design application 145 may use 1�N compiler 160 to perform a substantial number of automated optimizations. In the classical design methodology, many of the updates created by the automated optimization tools are discarded prior to logic-freeze, because the physical information for these updates is not translated back to the RTL. To help prevent the loss of one or more of the optimization updates, the 1�N building blocks and the 1�N compiler may provide an “RTL no-touch” feature.
Various embodiments may provide an RTL no-touch feature by allowing specific sets of RTL constructs to be designated as having been previously implemented and optimized as gate-level netlists. For example, a circuit design may have twenty-five different 1�N building blocks. A circuit designer may have synthesized the circuit and tuned a portion of the circuit having ten 1�N building blocks. The circuit designer may want to add some additional circuit functions, or otherwise modify the circuit design at the behavioral level, using Verilog HDL. The circuit designer may designate the ten 1�N building blocks that have been tuned as no-touch blocks. As a consequence, any subsequent automated optimizations performed on the circuit design may tune or alter the other fifteen 1�N building blocks and the newly added circuit functions but make no more tuning or optimization changes to the ten previously tuned building blocks.
Various embodiments may implement the RTL no-touch feature by maintaining the gate-level netlists for the no-touch building blocks (element 444) separate from the behavioral level design. The embodiments may maintain separate gate-level netlists and behavioral lists to the building blocks as long as both the gate-level netlists and behavioral lists are proven and maintained to be logically equivalent, such as by using industry-available tools. The RTL no-touch feature may not be limited to 1�N building blocks. Many embodiments may implement the RTL no-touch feature for both 1�N building blocks and other types of hierarchical cells and circuit elements in a circuit design. Using the RTL no-touch feature for other types of circuit elements may allow a designer to tune one or more parts of a circuit design, which may contain both 1�N building blocks and non-1�N elements, and prevent such tuning parameters from being erased or overwritten during subsequent tuning or optimization for other portions of the circuit design. Referring to FIG. 2, the designer may designate numerous elements as no-touch elements in synthesis phase 230, wherein the no-touch elements may remain unaltered in subsequent iterations of logic phase 220, synthesis phase 230, physical design phase 240, timing phase 250, and 1�N compilation 260.
In at least one embodiment, the RTL no-touch feature may eliminate the need for disrupting the RTL-only design environment with gate-level implementation details. The 1�N compiler may be configured to avoid generating RTL-level code for the no-touch building blocks. Preventing the generation of the RTL-level code may enable the embodiment to help protect proprietary design techniques, as well as maintain a technology-independent netlist.
By employing a 1�N design methodology, an IC design application like VLSI design application 145 may maintain the results of optimizations performed on 1�N building blocks through a process of back-annotation. With back-annotation, a circuit designer may also perform automated optimizations of the design. In many embodiments, the circuit designer may perform the automated optimizations normally, such as the designer would in a traditional design flow. Performing the automated optimizations in a traditional manner may allow a system employing 1�N building blocks to decouple the 1�N building blocks from the tool-suite of the system. Referring back to FIG. 1, computing system 100 may perform automated optimizations on an IC design, such as a design represented by netlist 185, via tools 190 yet VLSI design application 145 may decouple 1�N building blocks 155 from tools 190.
A premise of back-annotation may be the detection and description of optimizations via 1�N building blocks. An embodiment may perform an optimization on a design and make changes to the netlist based on the optimization results. The back-annotation feature may allow the embodiment to detect the netlist changes and then describe or create updates to the 1�N building blocks corresponding to the netlist changes. FIG. 4B illustrates back-annotation via back-annotator 424. Back-annotator 424 may comprise, e.g., a software module in the stage of 1�N compilation 420, back-annotator 325 depicted in flowchart 300, or back-annotator 170 of VLSI design application 145 shown in FIG. 1.
Back-annotator 424 may read two netlists. In FIG. 4B, back-annotator 424 may read a hierarchical netlist from netlist 426 created before one or more optimization operations. Back-annotator 424 may also read a netlist that has been modified, tuned, or updated via an optimization tool or a synthesis tool. For example, back-annotator 424 may read a netlist from synthesis tool 448. Back-annotator 424 may find the 1�N building blocks in the different netlists and then detect changes of the 1�N building blocks. If back-annotator 424 finds any changes, such as by a comparison process, back-annotator 424 may update the appropriate 1�N building block 422 to reflect those optimizations. For example, back-annotator 424 may detect a change in the different netlists and update the affected parents and/or children 1�N building blocks. Back annotator 424 may detect changes such as drive strength alterations, Vt-hybridization changes, placement modifications, voltage island changes, cell-type changes, as well as other types of changes.
Since the optimizations made to the elements in the netlists are decoupled from the 1�N building blocks, back annotation for 1�N building blocks may allow an embodiment to support numerous optimization techniques, such as optimization techniques for timing, power, or area. Additionally, an embodiment may have the capability to disable one or more optimization tools or optimization features via synthesis tool 448 or back annotator 424. The quality of the starting netlist or “seed” may determine the output quality and amount of time required for automated optimization routines. Consequently, the use of iterative cycles of synthesis and back annotation may improve runtimes and result in better-optimized designs.
Back-annotator 424 may be extendable and programmed to selectively accept or ignore a specified set of changes to a specific list of 1�N building blocks. An embodiment may program back-annotator 424 to selectively accept or ignore the specified set of changes through a list of directives, which may be similar to the use of directives by existing synthesis tools. For example, if an embodiment needs a specific 1�N bit-ordering to meet a routing requirement, the embodiment may disable placement updates by fixing cell locations in the netlist or by providing back-annotator 424 with a list of 1�N building blocks for which the placement updates should be ignored. Further, depending on the embodiment, the user may be able to select the method used for optimization-exclusion. If the tool suite in an embodiment supports optimization-exclusion, the embodiment may allow a user to configure the optimization-exclusion via synthesis tool 448. However, in another embodiment that does not support optimization-exclusion, or if the optimization-exclusion is difficult or cumbersome to use, the embodiment may allow the user to configure the optimization-exclusions via back-annotator 424.
In many embodiments, synthesis tool 448 may be hierarchy-aware. In other words, synthesis tool 448 may be configured to recognize and work with hierarchical cell elements. For embodiments that have a hierarchy-aware synthesis tool 448, 1�N building block 422 may be represented as hierarchical elements, e.g., traditional hierarchical elements. Synthesis tool 448 may manipulate the hierarchical elements to produce an optimized design. For embodiments that have hierarchy-aware synthesis tool 448, the embodiments may need to perform the timing improvements or timing optimizations using the individual gates within the hierarchical elements so that timing rules such as New Delay Rules (NDRs) are not required for each individual 1�N building block 422. Otherwise, an embodiment may need to update 1�N compiler 428 to generate NDRs for each 1�N building block 422.
In many embodiments, optimizations made to 1�N building blocks may be captured via back-annotation by back-annotator 424. Placement changes allowed on a hierarchical 1�N building block 422 may be used in the physical design phase for floorplanning updates. Because the results of synthesis and automated optimization routines may largely depend on the initial quality of the netlist, or starting seed, maintaining optimizations for 1�N building blocks through back-annotation may result in a better quality synthesis result through successive iterations.
As illustrated above for embodiments that do not have hierarchy-aware tools, the embodiments may flatten the 1�N building blocks before performing the optimizations. Embodiments that flatten the 1�N building blocks before performing the optimizations may detect and capture changes to the 1�N building blocks via back-annotation. However, flattening the design may eliminate the hierarchy established to maintain 1�N building blocks as individually tunable elements in the separate design phases. To address the eliminated hierarchy, various embodiments may recreate the hierarchy through a reassembly process.
Reassembler 432 may comprise a software module or other type of module for 1�N compilation 420 that uses netlist attributes created by 1�N compiler 428 to recreate the hierarchical design. Reassembler 432 may also comprise, e.g., reassembler 335 depicted in flowchart 300, or reassembler 175 of VLSI design application 145 shown in FIG. 1.
Reassembler 432 may detect changes to 1�N building blocks, such as 1�N building block 422, via back-annotation. However, because the netlist may have been flattened, the changes may not be directly applied back to the hierarchical RTL and physical design netlists. Reassembler 432 may discern the hierarchical boundaries of the flattened netlist. Plus, reassembler 432 may be configured to apply the updates for the 1�N building block 422 back to the respective hierarchical physical design netlist or RTL netlist without manual intervention.
For example, reassembler 432 may use attributes created by 1�N compiler 428, which are present in the flattened netlist, to recreate the hierarchical design. The flow process for recreating the hierarchical design via attributes of the netlist is illustrated in FIG. 4B, with the determination of the type of netlist type 426 causing reassembler 432 to reassemble flattened netlist elements. If the netlist from synthesis tool 448 is a hierarchical or non-flattened netlist, back-annotator 424 may read the netlist directly, without any modifications. However, if the netlist has been flattened, such as due to the requirements of synthesis tool 448, back-annotator 424 may read a reassembled netlist from reassembler 432.
The physical design phase may comprise the part of the design process that captures or generates the physical attributes of the circuit design. For example, a VLSI design application may capture the physical attributes related to floor planning, cell and 1�N building block placement, routing between the cells/blocks, noise reduction, power bussing, and design rule checking, as just a few examples. Embodiments that employ only classical design methodologies generally lose many of the changes made during the physical design phase due to the iterations through the logic and/or synthesis design phases.
An embodiment employing a 1�N design methodology may automatically maintain changes made to the 1�N building blocks during the physical design phase via the mechanisms of back-annotation and reassembly. FIG. 4C illustrates the process of automatically maintaining changes made to the 1�N building blocks during the physical design phase via the mechanisms of back-annotator 454 and reassembler 462. For example, if a physical designer, or integrator, changes the relative spacing or bit-ordering of leaf cells in a 1�N building block 456 to ease routing congestion, an embodiment may capture the relative spacing or bit-ordering information in 1�N building block 456 and maintain the information through each successive design phase.
One flow of an iterative physical design stage may comprise reading different 1�N building blocks from a netlist of physical design 468. Depending on the type of netlist (element 452), an embodiment may reassemble the netlist via reassembler 462 and/or perform back-annotation via back-annotator 454 for the individual 1�N building blocks, such as 1�N building block 456. Embodiments may employ 1�N compiler 458 to compile the reassembled and back-annotated 1�N building blocks to generate physical design view 460.
An embodiment employing a 1�N design methodology may leverage the hierarchical nature of a physical design to make many physical design tasks more efficient through the use of scripting. For example, if an integrator wants to change the relative spacing of the leaf cells in 1�N building block 456, the embodiment employing the 1�N design methodology may not require the integrator to move each individual cell manually. Instead, the embodiment may allow the integrator to update 1�N building block 456 to reflect the desired spacing. The embodiment may then allow the integrator to recompile the design via 1�N compiler 458 and re-read the relative spacing changes into the design. The hierarchical 1�N building block 456 may be rewired on-the-fly, such as when the integrator is working on the design in physical design phase 240, so that the spacing changes are ready to use once the design is re-read. Subsequently, the integrator may resolve any potential overlaps between the 1�N building block and other random-logic cells and re-route the hierarchical connections.
An embodiment may make physical design tasks more efficient through the use of scripting for numerous types of transformations. For example, various embodiments may use scripting for relative placement of cells within 1�N building blocks, relative spacing of leaf cells, bit ordering, changes of cell types used in 1�N building blocks, and DFM/redundancy-for-test improved manufacturability implementations.
Embodiments employing dynamic updates to 1�N building blocks, such as 1�N building block 456, may not need to rely on pre-compiled sub-blocks that can be tiled together. Instead, 1�N compiler 458 may interpret the underlying physical structure of each cell and rewire 1�N building block 456 according to the cell placements described in 1�N building block 456. Interpreting the underlying physical structure and rewiring 1�N building block 456 may reduce turn-around-time for design optimizations and provide the designer or integrator with more physical detail information through each design phase.
Due to the nature of classical timing analysis tools, designers typically perform the timing design phase using flattened designs. Based on the results of the timing analyses, a designer may manually update the design to meet timing goals. Alternatively, the timing tool may also apply updates to the design. In other words, the timing tools may use various methods to communicate the recommended changes or updates and have the updates physically implemented in the design. Embodiments employing a 1�N design methodology may update 1�N building blocks in at least two ways. A first method may comprise updating 1�N building blocks through reassembly and back-annotation, whereby the embodiment recognizes design changes and feeds the changes or alterations back to other stages in the methodology. A second method may comprise incorporating the changes via on-the-fly editing and recompilation of 1�N building blocks. This secondary method may allow for more accurate timing information in a rapid fashion via scripting from a 1�N compiler.
In a classical design flow, the timing team may make changes to the abstract or higher-level design, communicate the changes to the physical design team, and wait until the physical design team has incorporated the changes into the physical design. This interaction between the timing team and physical design team may be relatively slow in that the updates may need to be placed and routed before the updates can be analyzed in a timing analysis. Implementing the updates via placement and routing may require days. Once the physical design is ready to be analyzed for timing performance, the timing tool may take hours or days to produce the timing data for the designer depending on the complexity of the design. FIG. 4D illustrates how one or more embodiments employing a 1�N design methodology may improve this process.
FIG. 4D illustrates how an embodiment employing a 1�N design methodology may allow a designer to incorporate updates to a design that has 1�N building blocks. Depending on the type of netlist (element 472), an embodiment may reassemble the netlist via reassembler 482 and/or perform back-annotation via back-annotator 474 for an individual 1�N building block 476. The designer may be able to update 1�N building block 476, recompile the building block via 1�N compiler 478, produce a script 480 that can be read into a timing tool during a timing analysis phase 488, whereby the timing tool may update 1�N building block 476 by changing the physical implementation details of 1�N building block 476.
Changing 1�N building block 476 may not provide completely accurate timing results in some instances, because changes to 1�N building block 476 may affect other circuit elements, such as random logic gates. However, incorporating changes from a timing analysis using a 1�N design methodology may provide a greater degree of accuracy than a designer not using capabilities provided by a 1�N design methodology. Consequently, the designer may use the 1�N design methodology to reduce the time needed to update the physical design and meet timing goals, resulting in a quicker turnaround time for the design.
Script 480 generated from recompilation may not be limited to use in the timing design phase, nor to a specific set of transformations. Rather, 1�N compiler 478 may be configured to work with various tool sets for other phases of the design methodology and other desired transformations. For example, 1�N compiler 478 may be configured to work with placement and routing tools, DFM tools, design-rule checking tools, simulation tools, timing analysis tools, and other tools used in the logic, synthesis, physical design, and timing phases. Embodiments employing a 1�N building block methodology may provide the necessary design information for the various transformations through reassembly, back-annotation, and uniquification. Some embodiments may employ scripts for adding new 1�N building blocks to a design. Some embodiments may employ scripts for changing internal cell placement, internal rewiring, rewiring pins of a 1�N building block, and/or changing the functions for 1�N building blocks. Even further embodiments may employ scripts to delete specific 1�N building blocks from a design or remove internal cells of designated 1�N building blocks. As one skilled in the art will appreciate, scripts for 1�N building blocks may be used in a variety of different ways for a variety of different purposes. The example uses just cited are only a few of the possible uses.
FIG. 7A depicts a 1�N compiler 700 that may use higher-level wiring information for routing 1�N building blocks of a VLSI circuit design 720. For example, the integrated circuit designer may use 1�N compiler 700 when creating netlist 185 and numerous portions of design file(s) 135 shown in FIG. 1. In one or more embodiments, 1�N compiler 700 may be part of a VLSI design application, such as VLSI design application 145. In an alternative embodiment, 1�N compiler 700 may comprise a device used to create a VLSI circuit design, or at least a portion of the VLSI design, such as a state machine arranged to work with one or more representations of circuit design 720.
As illustrated in FIG. 7A, 1�N compiler 700 may operate on a behavioral representation 722, a logical representation 724, and a physical design representation 726. The different representation forms generated by 1�N compiler 700 may be used in the respective design phases, such as the design phases illustrated in FIG. 2. In numerous embodiments, the representations, or views, may be recompiled at any time to enable iterative cycling through the design phases. For example, the logic phase 220 may use a behavioral RTL generated by 1�N compiler 700. As the circuit designer redefines the logical implementation, he or she can fine tune, or even completely change, 1�N building blocks and regenerate the behavioral RTL views, shown as behavioral representation 722, on-the-fly through recompilation.
1�N compiler 700 may be able to craft physical aspects, such as internal wiring routes, of 1�N building blocks in conjunction with limitations imposed by higher-level hierarchical routing. For example, 1�N compiler 700 may generate the routes of internal wiring of 1�N building block 727 based on one or more blockages resulting from top-level or higher-level wiring for IC elements located near 1�N building block 727. The term “intra-1�N wiring” may generally refer to wiring elements of cells of a 1�N building block, as well as to wiring between cells of the 1�N building block. Contrastingly, global wiring, top-level wiring, and/or higher-level wiring may refer to wiring that is not related to wiring elements of 1�N building block cells or to wiring between cells, but rather for wiring of elements external to the 1�N building block. However, global or higher-level wiring may include input/output signal wiring for the 1�N building block, used to provide input signals to and carry output signals away from the 1�N building block.
Each 1�N building block may have intra-1�N wiring, such as common clocking or controls. With intra-1�N wiring, 1�N compiler 700 may generate such interconnectivity in a manner that does not cause conflicts when 1�N compiler 700 integrates 1�N building block 727 into the next level or levels of hierarchy. Thus 1�N compiler 700 may be arranged to push the shapes, or coordinates of the shapes, of wiring metal and via of top-level or higher level hierarchy into 1�N building block 727 as blockage. By pushing the shapes into 1�N building block 727 as blockage, 1�N compiler 700 may prevent 1�N building block 727 from having any intra-1�N wiring that could cause a short or a DRC (Design Rule Check) violation due to the higher-level interconnectivity. To illustrate how 1�N compiler 700 may push the shapes into 1�N building block 727 as blockage, we may examine FIG. 7B.
FIG. 7B illustrates the process by which a 1�N compiler 752, which may correspond to 1�N compiler 700, may perform intra-1�N routing. 1�N compiler 752 may generate a physical placement (element 754) for each of the various elements of 1�N building block 750. 1�N compiler 752 may also generate a set of basic, or preliminary, routing and interconnection vias for the intra-1�N routes of wires (element 756). Depending on the embodiment, 1�N compiler 752 may generate a number of support files for use with one or more external tools. For example, the embodiment of 1�N compiler 752 depicted in FIG. 7B may generate a Cadence™ import script, import.il file 764. 1�N compiler 752 may also generate a set of placement and pre-routing files, such as VIM file 768 and router files 772. 1�N compiler 752 may also generate a routing blockage file, topblk.i file 776, if non-existent.
A detailed router 774 may utilize router files 772 and topblk.i file 776 to create a routed VIM file 770. As persons having ordinary skill in the art will appreciate, routed VIM file 770 and import.il file 764 may comprise inputs for a Cadence™ Physical Design System 766. Cadence™ Physical Design System 766 may then use custom software to update topblk.i file 776. Also, in different embodiments, both the names of the files and the number of files may vary. For example, one embodiment may create two files for VIM file 768. Another embodiment may name topblck.i file 776 by another name.
Topblk.i file 776 may comprise an extra image file defined for every 1�N building block. Depending on the embodiment, topblk.i file 776 may be empty by default. A routing tool may read topblk.i file 776 when routing 1�N building block 750. For example, in a VLSI system that employs Cadence™, the system may read topblk.i file 776 into the ICCraftsman/VCR router, when the system routes 1�N building block 750, as an overlay image. Any shapes defined in topblk.i file 776 may exist as blockage in the router representation, and internal routes may avoid the locations determined by the shapes.
In some embodiments, hierarchical wiring avoidance may be accomplished without having to recompile 1�N building block 750. For example, given 1�N building block 750, detailed router 774 may start the routing via updates to topblk.i file 776, producing the updated routed VIM file 770 which may be fed into Cadence™ Physical Design System 766. This secondary loop, without recompiling 1�N building block 750, may enable the circuit designer to dynamically update the wiring of 1�N building block 750 without having to go through the entire compilation process and may reduce turn-around time.
Returning back to FIG. 7A, 1�N compiler 700 may comprise a placement generator 702 and an intra-1�N router 704. Placement generator 702 and intra-1�N router 704 may, e.g., generate the physical placement (element 754) and generate the basic routing and vias (element 756) as illustrated in FIG. 7B. For example, placement generator 702 may determine physical locations of 1�N building blocks, such as 1�N building block 725, of logical representation 724 when creating physical design representation 726. In other words, placement generator 702 may create a physical design representation corresponding to 1�N building block 725 when compiling logical representation 724, wherein 1�N building block 727 may correspond to the created physical design.
After placing one or more 1�N building blocks in various locations of the floorplan, an embodiment may enable the circuit designer to select specific 1�N building blocks, such as 1�N building block 727, to be added to a list which may be processed by 1�N compiler 700 to have higher-level blockages “pushed” into them. In other words, the circuit designer may select a subset of the total number of 1�N building blocks of circuit design 720 and only push the higher-level blockages for the 1�N building blocks of the list.
Higher-level wiring examiner 708 may, e.g., comprise a software module that looks for any higher-level or top-level wiring that crosses the areas of the 1�N building blocks. For example, higher-level wiring examiner 708 may examine the top-level design for routing wires that cross intra-1�N clock wires of 1�N building block 727. Based on the determination of higher-level wiring examiner 708, blockage determiner 710 may determine that one or more of the higher-level wires actually create a number of blockages or impermissible intersections of wires and/or vias. In other words, the blockages may affect intra-1�N wiring for 1�N building block 727. By using the blockage information from blockage determiner 710, coordinate calculator 712 may determine intra-1�N coordinates for 1�N building block 727 for the blockage stemming from the higher-level wiring. Stated differently, higher-level wiring examiner 708, blockage determiner 710, and coordinate calculator 712 may transform the shapes from the higher-level wiring down to relative shape coordinates inside 1�N building block 727. 1�N compiler 700 may write the areas representing the relative shape coordinates to router support information/files 714. For example, router support information/files 714 may comprise import.il file 764, VIM file 768, router files 772, and topblk.i file 776.
Using the information provided via router support information/files 714, a routing tool of routing tools 736 may generate the intra-1�N wiring for 1�N building block 727 which avoids the shapes of the blockages. For example, using the topblk.i file 776, 1�N compiler 700 and the routing tool may create the intra-1�N wire routing without violating top-level (parent) metal for 1�N building block 727. Depending on the embodiment, the circuit designer may need to verify that the router was able to fully route all signals within 1�N building block 727. If routing completion was not completed successfully, then the circuit designer may need to force routing tools 736 to move the top-level parent metal or shift 1�N building block 727 to allow enough routing porosity over or within close proximity of 1�N building block 727 to allow for complete routing. For either case, 1�N compiler 700 may regenerate toplblock.i file 776 and repeat one or more of the actions described for creating topblk.i file 776.
The different representation forms of circuit design 720 may vary from embodiment to embodiment, as well as within an embodiment. Behavioral representation 722 may comprise a high-level description of circuit design 720. For example, behavioral representation 722 may comprise one or more types of HDL code, behavioral RTL descriptions, user-configurable text files, C-language code, RTL netlists, or other high-level elements that describe various circuit devices, cells, and/or hierarchical cells/macros.
Logical representation 724 may comprise a gate-level description of circuit design 720. For example, logical representation 724 may describe an alternative form of circuit design 720, having such components and/or elements as AND gates, OR gates, NAND gates, and NOR gates, one or more 1�N building blocks 725, and a mixture of other high-level macrocell components, such as adders, arithmetic logic units, multiplexers, and register-files.
Physical design representation 726 may comprise a low-level description of circuit design 720. For example, physical design representation 726 may describe an alternative form of circuit design 720, having such components and/or elements as nodes, wires, resistors, capacitors, inductors, contacts, poly, diffusion, many of which may have associated placement and dimensional data. Depending on the embodiment, physical design representation 726 may also comprise hierarchical information, such as hierarchical information of cells and 1�N building block 727. In other words, physical design representation 726 may comprise a PD netlist and/or a flattened netlist. Worth emphasizing, 1�N building block 727 may comprise collections of circuit elements associated with 1�N building block 725, wherein the circuit elements of physical design representation 726 may be represented in a flattened netlist.
During the design process, the circuit designer may use one or more tools of tool suite 730. For example, tool suite 730 may comprise a variety of synthesis and performance optimization tools, such as tools 190 in FIG. 1, that generates graphical representations of circuit design 720 via display 110 and window 115, allowing the designer to create, view, simulate, and edit circuit design 720.
The integrated circuit designer may have to repeatedly and iteratively use one or more of the tools of tool suite 730 before developing a final physical design representation 726 that may be fabricated. For example, the designer may use one or more logic design tools 732 that work in conjunction with 1�N compiler 700 to create 1�N building blocks in behavioral representation 722. Logic design tools 732 may comprise, e.g., cell editors, 1�N building block editors, RTL editors, and other high-level circuit design applications.
The designer may use one or more synthesis tools 738 to create logical representation 724 from behavioral representation 722. One or more of synthesis tools 738 may work in conjunction with 1�N compiler 700 when creating logical representation 724. The designer may then analyze and/or optimize the design via one or more logic design tools 732. For example, the designer may simulate the operation of groups of elements, cells, and 1�N building blocks of logical representation 724, such as applying various sequences of bit patterns to verify that logical representation 724 behaves in a similar or equivalent fashion as behavioral representation 722 behaves. Additionally the designer may use one or more timing analysis tools 740 with logical design tools 732. For example, the designer may verify that signals propagate through sections of the circuit in required time intervals and that drive strengths are sufficient for implemented fan-outs.
The circuit designer may use physical design tools 734, which may work in conjunction with 1�N compiler 700, to generate physical representation 726 from logical representation 724. Similar to the other iterative closed loops encountered when generating behavioral representation 722 and logical representation 724, the designer may need to make numerous changes to elements of physical design representation 726 due to results of physical design tools 734 and timing analysis tools 740. For example, the designer may discover that a routing tool cannot create a functional wiring arrangement for the design, due to rule restrictions, area constraints, and other problems encountered by physical design tools 734.
Alternatively, one or more optimization tools may generate changes to circuit design 720, such as by relocating elements, selecting different pins of different cells and/or 1�N building blocks, increasing gate drive strengths, rearranging cells of 1�N building blocks, and making other types of alterations to other elements of physical design representation 726. Consequently, the designer may use 1�N compiler 700 to generate updated representations of the altered 1�N building blocks for behavioral representation 722, the altered 1�N building blocks for logical representation 724, and the altered 1�N building blocks of physical design representation 726. 1�N compiler 700 may also generate updated information for router support information/files 714 via higher-level blockage determiner 706 and update intra-1�N wiring for altered 1�N building blocks of physical design representation 726 via routing tools 736.
One or more elements of 1�N compiler 700 may be in the form of hardware, software, or a combination of both hardware and software. For example, in one embodiment, one or more of the modules of higher-level blockage determiner 706 may comprise software instructions of an application stored in a tangible medium, executed in memory by a processor of a computer. In other words, one embodiment of 1�N compiler 700 may comprise portions of stored code for an application, which may design integrated circuits using a closed-loop 1�N methodology, such as VLSI design application 145 shown in FIG. 1.
In alternative embodiments, one or more of the modules of 1�N compiler 700 may comprise hardware-only modules. For example, in one embodiment higher-level blockage determiner 706 may comprise a state machine that pushes shapes for wiring metal and via of higher-level hierarchy into 1�N building block 727 as blockage. A state machine higher-level blockage determiner 706 may be desirable when, e.g., the designer needs to create the wiring for a large design, containing numerous 1�N building blocks, in a rapid fashion, since a state machine compiler may be able to generate the representations considerably faster than a software-based compiler.
In some embodiments, placement generator 702, intra-1�N router 704, higher-level wiring examiner 708, blockage determiner 710, and coordinate calculator 712 may all reside in a single device, such as in storage device 125 of computing system 100 shown in FIG. 1. Alternatively, depending on the embodiment, various elements of 1�N compiler 700 may reside in two or more devices. For example, in one alternative embodiment, intra-1�N router 704 and all the elements of higher-level blockage determiner 706 may reside on a remote server workstation, while placement generator 702 reside in a local workstation.
The arrangement of 1�N compiler 700 may vary in different embodiments. Some embodiments may have different elements than those modules depicted in FIG. 7A. For example, some embodiments may have additional modules, such as a uniquifier, a back-annotator, and a reassembler. 1�N compiler 700 may be expandable, such that additional intra-1�N routers may be added to generate wiring for different types of 1�N building blocks. In other words, 1�N compiler 700 may be expandable and/or configurable. Some embodiments may not have all of the modules shown in FIG. 7A. For example, one embodiment may not comprise intra-1�N router 704. In such an embodiment, 1�N compiler 700 may perform no wiring for 1�N building blocks but rely on external routing tools, such as routing tools 736, to generate both internal and external wiring for 1�N building blocks.
In other embodiments, 1�N compiler 700 may include varying numbers of modules. For example, one embodiment may have two higher-level wiring examiners 708, one to examine wiring for one metallization layer and one to examine wiring for a different metallization layer.
FIG. 8 shows a block diagram of an exemplary design flow 800 used for example, in semiconductor design, manufacturing, and/or test using a 1�N design methodology. Design flow 800 may vary depending on the type of IC being designed. For example, a design flow 800 for building an application specific IC (ASIC) may differ from a design flow 800 for designing a standard component. Design structure 820 is preferably an input to a design process 810 and may come from an IP provider, a core developer, or other design company or may be generated by the operator of the design flow, or from other sources. Design structure 820 comprises a product of an embodiment of the invention, such as netlist 185, design file(s) 135, 1�N building blocks 155, and cell library 130 as shown in FIG. 1, in the form of schematics or HDL, a hardware-description language (e.g., Verilog, VHDL, C, etc.). Design structure 820 may be contained on one or more machine readable mediums. For example, design structure 820 may be a text file or a graphical representation of an embodiment of the invention, such as storage device 125 as shown in FIG. 1. Design process 810 preferably synthesizes (or translates) a product of an embodiment of the invention as shown in FIG. 1 into a netlist 880, where netlist 880 is, for example, a list of wires, transistors, logic gates, control circuits, I/O, models, etc. that describes the connections to other elements and circuits in an integrated circuit design and recorded on at least one of machine readable medium. This may be an iterative process in which netlist 880 is resynthesized one or more times depending on design specifications and parameters for the circuit.
FIG. 9 depicts a flowchart 900 of a process illustrating a method of routing 1�N building blocks using higher-level wiring information for a 1�N compiler. For example, one or more embodiments may be implemented as a computer program product comprising a computer readable storage medium including instructions that, when executed by a processor, use higher-level wiring information for a 1�N compiler to generate internal routes of wires for 1�N building blocks, as part of an iterative closed-loop design methodology.
As illustrated in FIG. 9, the process may involve generating a physical placement for a 1�N building block of a physical design representation (element 910). For example, a circuit designer may have created logical representation 724, which comprises numerous 1�N building blocks. 1�N compiler 700 may work in conjunction with a placement tool of physical design tools 734 to create a physical floorplan, containing shapes of physical manifestations for the 1�N building blocks. Physical design representation 726 may comprise the physical floorplan.
After generating the physical placement for the 1�N building block, the circuit designer may use the 1�N compiler to generate internal wire routing and vias for the 1�N building block (element 920). For example, 1�N compiler 700 may work in conjunction with a routing tool of routing tools 736 to generate preliminary routes of intra-1�N wiring and vias. The routing tool may also generate external wiring for the 1�N building block, such as interconnecting wires which deliver signals to and/or from the 1�N building block.
Based on the intra-1�N wiring and external block wiring, 1�N compiler 700 may determine higher-level coordinates for a blockage which affects the intra-1�N wiring and/or vias (element 930). For example, the routing tool may have been programmed to first try and generate a set of internal and external wires for the 1�N building block which violate no design rules, such as shorts or DRC errors. If the routing tool cannot generate an error-free set of internal and external wires, the routing tool may be programmed to ignore the internal wiring and generate only error-free external wiring. Using the information of the internal and external wiring generated by the routing tool, higher-level determiner 708 may determine higher-level coordinates of the external, higher-level routing which interferes and creates one or more blockages for the intra-1�N wiring.
Using the higher-level coordinates, blockage determiner 710 and coordinate calculator 712 may work in conjunction with each other to correlate the higher-level coordinates to intra-1�N coordinates (element 940) and store the intra-1�N coordinates in an image file (element 950). Referring again to FIG. 7A for illustration, 1�N compiler 700 may store the coordinates, in the form of shapes, into an image file of router support information/files 714, such as topblk.i file 776 depicted in FIG. 7B.
Using the intra-1�N coordinate information of router support information/files 714, 1�N compiler 700 may work in conjunction with routing tools 736 to generate intra-1�N routes of wires via the image file (element 960) and potentially updated routes of wires external to the 1�N building block (element 970). For example, 1�N compiler 700 may work in conjunction with routing tools 736 to generate updated intra-1�N routes of wires and generate updated external wire routing as well, because the updated intra-1�N routes of wires may have affected the external wire routes. Because the iterative generation of intra-1�N wiring and external wiring may alter one or more physical components of the corresponding physical design representation, 1�N compiler 700 may generate update versions of, e.g. behavioral representation 722 and logical representation 724 (element 980).
Flowchart 900 of FIG. 9 illustrates only one process. Alternative embodiments may implement innumerable variations of flowchart 900. For example, instead of generating internal wire routing and vias for the 1�N building block (element 920) before generating the external routes of wires, and then determine the higher-level coordinates of potential blockages (930), some embodiments may generate routes of wires external to the 1�N building block (960), insert the shapes for higher-level images that cross over the 1�N building block into the image file, and then use the image file to determine intra-1�N blockages (element 930) while creating the internal wire routing (element 920).
Those skilled in the art, having the benefit of this disclosure, will realize that the present disclosure contemplates routing 1�N building blocks using higher-level wiring information for a 1�N compiler. The form of the embodiments shown and described in the detailed description and the drawings should be taken merely as examples. The following claims are intended to be interpreted broadly to embrace all variations of the example embodiments disclosed.
Patent CitationsCited PatentFiling datePublication dateApplicantTitleUS4377489Mar 16, 1981Mar 22, 1983Ceil Clean Corporation, Inc.Inorganic persulfate cleaning solution for acoustic materialsUS5301318May 21, 1992Apr 5, 1994Silicon Systems, Inc.Hierarchical netlist extraction toolUS5455775Jan 25, 1993Oct 3, 1995International Business Machines CorporationComputer design system for mapping a logical hierarchy into a physical hierarchyUS5629860 *May 16, 1994May 13, 1997Motorola, Inc.Method for determining timing delays associated with placement and routing of an integrated circuitUS5685006 *Dec 28, 1994Nov 4, 1997Kabushiki Kaisha ToshibaApplication specific integrated circuit having hierarchical structure and method of organizing such circuit using inheritance informationUS5946477 *Aug 28, 1996Aug 31, 1999Nec CorporationPositioning/wiring method for flip-chip semiconductor deviceUS6009251Sep 30, 1997Dec 28, 1999Synopsys, Inc.Method and system for layout verification of an integrated circuit design with reusable subdesignsUS6113647Nov 6, 1996Sep 5, 2000Vlsi Technology, Inc.Computer aided design system and method using hierarchical and flat netlist circuit representationsUS6230304Apr 2, 1998May 8, 2001Magma Design Automation, Inc.Method of designing a constraint-driven integrated circuit layoutUS6317860Oct 27, 1997Nov 13, 2001Altera CorporationElectronic design automation tool for display of design profileUS6324671Jun 29, 1999Nov 27, 2001Advanced Micro Devices, Inc.Using a reduced cell library for preliminary synthesis to evaluate designUS6397375 *Feb 18, 2000May 28, 2002Hewlett-Packard CompanyMethod for managing metal resources for over-the-block routing in integrated circuitsUS6477690 *Feb 18, 2000Nov 5, 2002Hewlett-Packard CompanyIn-place repeater insertion methodology for over-the-block routed integrated circuitsUS6487706 *Aug 30, 2000Nov 26, 2002International Business Machines CorporationContract methodology for concurrent hierarchical designUS6496968 *Aug 18, 1999Dec 17, 2002Hitachi, Ltd.Hierarchical wiring method for a semiconductor integrated circuitUS6532580 *Feb 18, 2000Mar 11, 2003Hewlett-Packard CompanyIn-place method for inserting repeater buffers in an integrated circuitUS6584121 *Nov 13, 1998Jun 24, 2003Lucent TechnologiesSwitch architecture for digital multiplexed signalsUS6591408 *Sep 26, 2000Jul 8, 2003Nec Electronics CorporationApparatus and method for designing semiconductor circuit, and recording mediumUS6634017May 29, 2001Oct 14, 2003Kabushiki Kaisha ToshibaSystem LSI development apparatus and the method thereof for developing a system optimal to an applicationUS6701489May 7, 1999Mar 2, 2004Advanced Micro Devices, Inc.Method and apparatus for changing register implementation without code changeUS6735754Jun 6, 2002May 11, 2004Sun Microsystems, Inc.Method and apparatus to facilitate global routing for an integrated circuit layoutUS6738958Sep 10, 2001May 18, 2004Numerical Technologies, Inc.Modifying a hierarchical representation of a circuit to process composite gatesUS6754879Jan 27, 1997Jun 22, 2004Unisys CorporationMethod and apparatus for providing modularity to a behavioral description of a circuit designUS6766502Dec 30, 1999Jul 20, 2004Intel CorporationMethod and apparatus for routing using deferred mergingUS6782520Aug 12, 2002Aug 24, 2004Cadence Design Systems, Inc.IC layout system having separate trial and detailed routing phasesUS6795960Oct 17, 2002Sep 21, 2004Xilinx, Inc.Signal routing in programmable logic devicesUS6883156May 31, 2002Apr 19, 2005Mips Technologies, Inc.Apparatus and method for relative position annotation of standard cell components to facilitate datapath designUS6886140Jan 17, 2002Apr 26, 2005Micron Technology, Inc.Fast algorithm to extract flat information from hierarchical netlistsUS6886150 *Feb 8, 2002Apr 26, 2005Matsushita Electric Industrial Co., Ltd.Method for designing integrated circuit deviceUS6938237Jun 28, 2002Aug 30, 2005Ellipsis Digital Systems, Inc.Method, apparatus, and system for hardware design and synthesisUS6966044Dec 9, 2002Nov 15, 2005Lsi Logic CorporationMethod for composing memory on programmable platform devices to meet varied memory requirements with a fixed set of resourcesUS7065729Oct 19, 1999Jun 20, 2006Chapman David CApproach for routing an integrated circuitUS7111110 *Dec 10, 2002Sep 19, 2006Altera CorporationVersatile RAM for programmable logic deviceUS7124380Mar 18, 2004Oct 17, 2006Hewlett-Packard Development Company, L.P.System and method for controlling analysis of multiple instantiations of circuits in hierarchical VLSI circuit designsUS7168059Apr 19, 2002Jan 23, 2007Bryan Darrell BowyerGraphical loop profile analysisUS7178116Oct 20, 2004Feb 13, 2007Fujitsu LimitedMethod and device for designing semiconductor integrated circuit and logic design programUS7310787Mar 7, 2003Dec 18, 2007Shiv PrakashArray transformation in a behavioral synthesis toolUS7328143Feb 15, 2005Feb 5, 2008Cadence Design Systems, Inc.Systems and methods for efficiently simulating analog behavior of designs having hierarchical structureUS7340712Jun 1, 2005Mar 4, 2008International Business Machines CorporationSystem and method for creating a standard cell library for reduced leakage and improved performanceUS7461234 *May 16, 2005Dec 2, 2008Panasonic CorporationLoosely-biased heterogeneous reconfigurable arraysUS7587697 *Dec 12, 2006Sep 8, 2009Tabula, Inc.System and method of mapping memory blocks in a configurable integrated circuitUS7827513 *Oct 11, 2007Nov 2, 2010International Business Machines CorporationBuffer placement with respect to data flow direction and placement area geometry in hierarchical VLS designsUS20020073381 *Feb 8, 2002Jun 13, 2002Masushita Electric Industrial Co., Ltd.Method for designing integrated circuit deviceUS20020131442 *Nov 13, 1998Sep 19, 2002Brij Bhushan GargSpace/time switch architectureUS20020144225 *Mar 30, 2001Oct 3, 2002Rony KayPerformance verification/analysis tool for full-chip designsUS20030225565Mar 12, 2003Dec 4, 2003Broadcom CorporationMethod and system for deterministic control of an emulationUS20040060019 *Aug 8, 2002Mar 25, 2004Stacey SecatchMethod and apparatus for hierarchical clock tree analysisUS20040117746Nov 18, 2003Jun 17, 2004Prakash NarainIntent-driven functional verification of digital designsUS20050102643 *Nov 12, 2003May 12, 2005Taiwan Semiconductor Manufacturing Co.Methodology to optimize hierarchical clock skew by clock delay compensationUS20050210428Mar 18, 2004Sep 22, 2005Keller S BSystem and method for flattening hierarchical designs in VLSI circuit analysis toolsUS20050251771May 6, 2005Nov 10, 2005Mentor Graphics CorporationIntegrated circuit layout design methodology with process variation bandsUS20050257024 *May 16, 2005Nov 17, 2005Elixent, LimitedLoosely-biased heterogeneous reconfigurable arraysUS20060101355Nov 17, 2003May 11, 2006Pdf Solutions, Inc.Yield improvementUS20060143589Dec 23, 2004Jun 29, 2006Invarium, Inc.Method and system for reticle-wide hierarchy management for representational and computational reuse in integrated circuit layout designUS20060190905Feb 24, 2005Aug 24, 2006Nick MartinSystem for designing re-programmable digital hardware platformsUS20060265674May 19, 2006Nov 23, 2006Cadence Design Systems, Inc.System and method for statistical design rule checkingUS20070011637Jun 6, 2006Jan 11, 2007Alexander SeidlMethod and system for performing local geometrical operation on a hierarchical layout of a semiconductor deviceUS20070079274Oct 5, 2005Apr 5, 2007Lsi Logic CorporationMethod and computer program for detailed routing of an integrated circuit design with multiple routing rules and net constraintsUS20070083839Oct 11, 2005Apr 12, 2007Lsi Logic CorporationOn-the-fly RTL instructor for advanced DFT and design closureUS20070235766 *Jun 14, 2007Oct 11, 2007Naohito KojimaSemiconductor integrated circuit having an oblique global signal wiring and semiconductor integrated circuit wiring methodUS20070266346Mar 6, 2007Nov 15, 2007Taiwan Semiconductor Manufacturing Company, Ltd.Method of Design For ManufacturingUS20070288871Aug 21, 2007Dec 13, 2007Mcelvain Kenneth SMethods and apparatuses for designing integrated circuitsUS20070294655May 24, 2007Dec 20, 2007Jorge CamposAutomatically generating an input sequence for a circuit design using mutant-based verificationUS20090100397 *Oct 11, 2007Apr 16, 2009International Business Machines CorporationBuffer Placement with Respect to Data Flow Direction and Placement Area Geometry in Hierarchical VLS DesignsUS20090219051 *Apr 19, 2007Sep 3, 2009Wei ZhangHybrid nanotube/cmos dynamically reconfigurable architecture and an integrated design optimization method and system therefor* Cited by examinerNon-Patent CitationsReference1Correale Jr., et al., "Macro/Cell Compiler Custom Realization for Disjoint or Integrated Logical and Physical Design Databases," IBM Technical Disclosure Bulletin, Sep. 1991, pp. 196-201.2Hao Li et al., "Feedback Driven High Level Synthesis for Performance Optimization," ASIC, 2005, ASICON 2005, 6th International Conference, vol. 2, Oct. 24-27, 2005, pp. 961-964.3Sebastien Bilavarn et al., "Design Space Pruning Through Early Estimations of Area/Delay Tradeoffs for FPGA Implementations," IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 25, Issue 10, Oct. 2006, pp. 1950-1968.4Srinivasan, A., et al., "Accurate Area and Delay Estimation from RTL Descriptions," IEEE Transactions on Very Large Scale Integration (VLSI) Systems, vol. 6, Issue 1, Mar. 1998, pp. 168-172.5U.S. Appl. No. 12/200,016, Paul M. Steinmetz et al.6U.S. Appl. No. 12/200,076, Anthony Correale Jr. et al.7U.S. Appl. No. 12/200,121, Benjamin J. Bowers et al.8U.S. Appl. No. 12/201,591, Anthony Correale Jr. et al.9U.S. Appl. No. 12/201,685, Matthew W. Baker et al.10U.S. Appl. No. 12/256,594, Benjamin J. Bowers et al.Referenced byCiting PatentFiling datePublication dateApplicantTitleUS8219944 *Jun 23, 2009Jul 10, 2012Cadence Design Systems, Inc.Method and system performing block-level RC extractionUS8316336 *Dec 21, 2009Nov 20, 2012Cadence Design Systems, Inc.Method and mechanism for modeling interconnect structures for integrated circuitsUS8484589 *Oct 28, 2011Jul 9, 2013Apple Inc.Logical repartitioning in design compilerUS8701062 *Aug 17, 2011Apr 15, 2014Fujitsu LimitedApparatus and method for generating a netlist using non-uniquified module during logic synthesis stageUS20120054700 *Aug 17, 2011Mar 1, 2012Fujitsu LimitedNetlist generating apparatus and method* Cited by examinerClassifications U.S. Classification716/130, 716/105, 716/122, 716/123, 716/129International ClassificationG06F17/50Cooperative ClassificationG06F17/5077European ClassificationG06F17/50L2Legal EventsDateCodeEventDescriptionSep 2, 2008ASAssignmentFree format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:POLOMIK, ANTHONY L.;BOWERS, BENJAMIN J.;CORREALE, ANTHONY, JR.;AND OTHERS;SIGNING DATES FROM 20080828 TO 20080829;REEL/FRAME:021468/0570Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW YOwner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW YFree format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:POLOMIK, ANTHONY L.;BOWERS, BENJAMIN J.;CORREALE, ANTHONY, JR.;AND OTHERS;SIGNING DATES FROM 20080828 TO 20080829;REEL/FRAME:021468/0570Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION,NEW YOFree format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:POLOMIK, ANTHONY L.;BOWERS, BENJAMIN J.;CORREALE, ANTHONY, JR.;AND OTHERS;SIGNING DATES FROM 20080828 TO 20080829;REEL/FRAME:021468/0570Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION,NEW YOFree format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:POLOMIK, ANTHONY L.;BOWERS, BENJAMIN J.;CORREALE, ANTHONY, JR. AND OTHERS;SIGNED BETWEEN 20080828 AND 20080829;US-ASSIGNMENT DATABASE UPDATED:20100304;REEL/FRAME:21468/570Feb 1, 2013ASAssignmentOwner name: MENTOR GRAPHICS CORPORATION, OREGONFree format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:INTERNATIONAL BUSINESS MACHINES CORPORATION;REEL/FRAME:029733/0156Effective date: 20121231Dec 5, 2014FPAYFee paymentYear of fee payment: 4RotateOriginal ImageGoogle Home - Sitemap - USPTO Bulk Downloads - Privacy Policy - Terms of Service - About Google Patents - Send FeedbackData provided by IFI CLAIMS Patent Services