US20080301598A1 - method for checking constraints equivalence of an integrated circuit design - Google Patents
method for checking constraints equivalence of an integrated circuit design Download PDFInfo
- Publication number
- US20080301598A1 US20080301598A1 US11/755,764 US75576407A US2008301598A1 US 20080301598 A1 US20080301598 A1 US 20080301598A1 US 75576407 A US75576407 A US 75576407A US 2008301598 A1 US2008301598 A1 US 2008301598A1
- Authority
- US
- United States
- Prior art keywords
- constraints
- constraint
- constraint file
- file
- pair
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F30/00—Computer-aided design [CAD]
- G06F30/30—Circuit design
- G06F30/32—Circuit design at the digital level
- G06F30/33—Design verification, e.g. functional simulation or model checking
- G06F30/3323—Design verification, e.g. functional simulation or model checking using formal methods, e.g. equivalence checking or property checking
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2119/00—Details relating to the type or aim of the analysis or the optimisation
- G06F2119/12—Timing analysis or timing optimisation
Definitions
- the present invention relates generally to the design of integrated circuits (ICs), and more particularly to the checking of constraint equivalence in IC design.
- ICs integrated circuits
- the following background materials will be helpful to an understanding of this material, and all are incorporated herein by reference for their useful background concerning the design of ICs: U.S. Pat. No. 6,842,884 to Lai, et al.; U.S. Pat. No. 7,039,883 to Krishnamurthy; and U.S. Pat. No. 7,134,106 to Huang, et al.
- EDA electronic design automation
- the start point of a typical top-down design flow is a register transfer level (RTL) description of a circuit.
- the RTL description provides a functional view of an IC design expressed in a hardware description language (HDL).
- HDL hardware description language
- the RTL description is then converted, by logic synthesis tools, into detailed gate level netlists.
- the gate-level netlist is then used to create a floor-plan of the circuit.
- blocks are placed and routed by place-and-route tools to create the physical layout.
- the physical layout is optimized through a timing optimization process.
- the circuit designer defines various design constraints, such as the overall operating frequency of the IC, timing requirements, circuit area, power consumption, and the like. The constraints are used at various stages of the design process.
- design constraints are defined by the circuit designer by means of an ASCII text file, such a Synopsys Design Constraints (SDC) file or Tcl.
- SDC Synopsys Design Constraints
- a constraints file includes timing assignment information which achieves the following: 1) describing the different attributes of clock signals, such as clock frequency, duty cycle, clock skew, and clock latency; 2) specifying input and output delay requirements of ports relative to a clock transition; and 3) setting timing exceptions.
- a constraint can be defined using the following self-explanatory format:
- timing constraints can be further generated by design tools used during the various stages of the design.
- a synthesis tool determines the timing constraints based on statistical wire-load estimation models and pre-characterized cell libraries for the process technology to be used when physically implementing the IC.
- constraint files are used and modified at various stages of the design. At each stage, the SDC files are cleaned up so as to make them more efficient and concise.
- a new constraint file that includes constraints that are more appropriate for the new design stage, is generated.
- the new file is created either manually by the designer or automatically by using a design tool. For example, a synthesis tool determines the timing constraints based on statistically based wire-load estimation models and cell libraries pre-characterized for the process technology to be used when physically implementing the IC.
- FIG. 1 is a diagram illustrating the equivalence checks of two constraints files used at the same stage of the design
- FIG. 2 is a diagram illustrating the equivalence checks of two constraints files modified by an implementation tool
- FIG. 3 is a diagram illustrating the equivalence checks of two constraints files used at different stages of the design
- FIGS. 4A and 4B are diagrams for illustrating the equivalence checks between a block-level constraints file and a top-level constraint file
- FIG. 5 is a flowchart describing the equivalence check process
- the cleanup process 130 includes removing duplicate or overwritten exceptions, removing constraints that are not applicable or are redundant, removing disable_timing instances and replacing them with false_path, clustering constraints that are similar, e.g., expanded constraints may be replaced by wildcards, expanding wildcards to apply different constraints to each path, and so on.
- the design files 110 and 150 are used at the same stage of the design.
- the equivalence check process 500 assures that constraint files 120 and 140 are equivalent, i.e., that the new constraints file 140 retains the design criteria set in file 120 .
- the equivalence check process 500 is described in greater detail below.
- FIG. 2 shows a non-limiting and exemplary diagram 200 illustrating the equivalence check of two constraint files modified by an implementation tool in accordance with an embodiment of the present invention.
- This type of check is performed when a physical implantation tool 250 (e.g., a router) reconstructs a netlist and a constraints file.
- the netlist 210 is reconstructed by an implementation tool 250 which generates a new netlist 220 .
- the netlists 210 and 220 ought to be equivalent.
- the verification that netlists 210 and 220 are equivalent can be performed using a formal verification engine.
- the reconstruction of the netlist 220 also modifies the constraints file 230 and produces a new constraints file 240 .
- the equivalence check process 500 assures constraints set on input, outputs, registers and intermediate points are equivalent. With this aim, the process 500 is provided, by the formal verification engine, with mapping information for equivalent points between the netlists 210 and 220 .
- FIG. 3 shows a non-limiting and exemplary diagram 300 illustrating the equivalence checks of multiple constraint files at different stages of the design, in accordance with an embodiment of the present invention.
- a check is performed in order to compare between constraint files used for logic design (pre-layout) and physical design (post-layout).
- a RTL file 310 is synthesized to a gate-level netlist 320 by a synthesis tool 370 .
- netlist 320 is passed to a physical implementation tool 380 to create a layout of the design, which is represented as netlist 330 .
- Three different constraint files 340 , 350 and 360 are used, each of which is created during a different stage of the design flow.
- constraints file 340 is used for the RTL implementation and is typically defined by the user; file 350 is generated by synthesis tool 370 during logic synthesis; and, file 360 is generated using, for example, a static timing analyzer (STA) during the timing optimization.
- STA static timing analyzer
- netlists 320 and 330 are equivalent, there is a need to compare between constraint files 340 and 350 as well as between constraint files 350 and 360 . This is performed by using the equivalence check process 500 .
- FIGS. 4A and 4B show a non-limiting and exemplary diagram illustrating the equivalence checks between a block-level constraints file and a top-level constraints file in accordance with an embodiment of the present invention.
- constraint file 410 constrains the entire design and constraint files 430 - 2 through 430 - 2 relate to design blocks 440 - 2 and 440 - 2 .
- the files 430 are generated by a timing budgeting process 420 .
- the equivalence check process 500 checks that block-level constraint files 430 are equivalent to top-level file 410 .
- FIG. 4A constraint file 410 constrains the entire design and constraint files 430 - 2 through 430 - 2 relate to design blocks 440 - 2 and 440 - 2 .
- the files 430 are generated by a timing budgeting process 420 .
- the equivalence check process 500 checks that block-level constraint files 430 are equivalent to top-level file 410 .
- FIG. 4A
- the check process 500 can compare between a top-level constraint file 450 and block-level constraint files 460 - 1 and 460 - 2 . With this aim, files 460 are merged prior to comparing to file 550 . It should be noted that the check process 500 can a compare a plurality of block-level files to a top-level constraint file.
- the number of block-level constraint files 430 and 460 are as the number blocks of in a design 480 shown in FIGS. 4A and 4B .
- FIG. 5 shows a non-limiting and exemplary flowchart 500 describing the equivalence check process 500 in accordance with an embodiment of the present invention.
- the process 500 is the same regardless of the type of check that is being performed.
- Two constraint files are determined to be equivalent when all constraints and commands contained in the files are the same or result in the same effect.
- the process 500 begins with S 510 where two constraint files are received as an input. These files may be related to the same design or equivalent designs.
- the designer (user) may specify the type of check to be performed, e.g., one of the checks defined above.
- the user may further specify which section in the constraint files (i.e., type of constraints) have to be checked. This allows performing incremental equivalence checking of the files. For example, the designer might not be interested in detecting equivalence for the whole constraints file in one pass.
- mapping information of the different designs is received at S 530 .
- the mapping information is generated by a formal verification tool and includes name mapping of objects (pins, points, nets, and so on) in both designs.
- a check is performed to determine if the constraint files are clean.
- a clean constraints file is free of syntax errors and does not include any overwritten or duplicate constraints. If S 540 results with a negative answer (i.e., a determination of not clean), execution continues with S 545 , where a cleaning process is executed; otherwise, execution continues with S 550 .
- the cleaning process can be performed manually by the user or automatically by using a set of constraint rules.
- the constraints are sequentially scanned and a pair of constraints from both files is selected. Specifically, first constraints in the files are ordered according to the their type and then they are paired for case analysis, clocks, input/output delays, exceptions, clock latency, clock uncertainty, input transition, output load, and so on. If no equivalent pair can be found, then constraints that could have the same effect are paired together, e.g. set_input_delay specified with respect to a virtual clock and set_max_delay set on the same path are selected as pairs. For each pair of constraints (commands or definitions) in both constraint files, a series of checks is performed to determine equivalency.
- Execution reaches S 566 to determine if the pair of constraints results in the same effect. For example, if a pure combinatorial path is constrained by using set_input_delay and set_output_delay with respect to a virtual clock in one constraints file and constrained using set_max_delay and set_min_delay in the second file, then if both of these commands results in same timing constraint, then they are determined to be equivalent. As another example, if a path is constrained using the constraint set_disable_timing in a first file and the constraint set_false_path in the second file, then both constraints are equivalent. Yet as another example, if the same constraint is set on an object (e.g.
- constraints file “A” includes the constraints:
- create_clock -name CLK 1 -period 10 [get_ports clka] create_clock -name CLK 2 -period 12 [get_ports clkb] create_clock -name CLK 3 -period 14 [get_ports clkc] and a constraints file “B” includes the constraints: create_clock -name C 1 -period 10 [get_ports clka] create_clock -name C 2 -period 8 [get_ports clkb] create_clock -name C 3 -period 12 [get_ports clkb] create_clock -name C 4 -period 14 [get_ports clkc]
- a definition of clock C 2 (in file B) is not the same as the definition of clock CLK 2 (in file B).
- clock C 2 is overwritten by clock C 3 (in file B) and clock C 3 and clock CLK 2 are equivalent, thus files A and B are considered equivalent.
- execution continues with S 570 where the differing constraints are reported; otherwise, execution continues with S 580 .
- S 580 it is checked if all commands and definitions in both constraint files were tested, and if so, execution proceeds with S 590 where a report is generated; otherwise, execution returns to S 550 .
- the report preferably includes an indication of all pairs of different constraints and of constraints that are included only in one of the constraint files.
- top-level constraints file when comparing between a top-level constraints file and block-level constraints files, the latter are merged into a single file which is provided as an input to process 500 . That is, the compression is performed between a top-level file and the merged file.
- the invention disclosed in detail herein can be implemented in hardware, software, or combination thereof.
- the invention can be also implemented in a computer aided design (CAD) system or a CAD program and realized by operation of the system or program on a computer processor controlling a memory in which steps of the program are stored.
- CAD computer aided design
- the invention in the above-identified aspects may likewise be realized in a computer program product containing a plurality of instructions or commands, stored on a tangible computer readable medium, that when executed on a proper hardware such as a computer processor would result in the implementation of the methods disclosed herein.
Abstract
Description
- The present invention relates generally to the design of integrated circuits (ICs), and more particularly to the checking of constraint equivalence in IC design. The following background materials will be helpful to an understanding of this material, and all are incorporated herein by reference for their useful background concerning the design of ICs: U.S. Pat. No. 6,842,884 to Lai, et al.; U.S. Pat. No. 7,039,883 to Krishnamurthy; and U.S. Pat. No. 7,134,106 to Huang, et al.
- State of the art electronic design automation (EDA) systems for designing complex integrated circuits (ICs) involves the use of several software tools for the creation and verification of designs of such circuits. Presently, EDA systems implement a design process commonly known as the top-down design methodology. This methodology is an iterative process that includes the processing steps of logic synthesis, floor-planning, place and route, and timing optimization.
- The start point of a typical top-down design flow is a register transfer level (RTL) description of a circuit. The RTL description provides a functional view of an IC design expressed in a hardware description language (HDL). The RTL description is then converted, by logic synthesis tools, into detailed gate level netlists. The gate-level netlist is then used to create a floor-plan of the circuit. Thereafter, blocks are placed and routed by place-and-route tools to create the physical layout. The physical layout is optimized through a timing optimization process. To meet design goals the circuit designer defines various design constraints, such as the overall operating frequency of the IC, timing requirements, circuit area, power consumption, and the like. The constraints are used at various stages of the design process.
- Generally, design constraints are defined by the circuit designer by means of an ASCII text file, such a Synopsys Design Constraints (SDC) file or Tcl. Typically, a constraints file includes timing assignment information which achieves the following: 1) describing the different attributes of clock signals, such as clock frequency, duty cycle, clock skew, and clock latency; 2) specifying input and output delay requirements of ports relative to a clock transition; and 3) setting timing exceptions. For example, a constraint can be defined using the following self-explanatory format:
- set_max_delay 15.0-from [port A]-to [ports B]
- The timing constraints can be further generated by design tools used during the various stages of the design. For example, a synthesis tool determines the timing constraints based on statistical wire-load estimation models and pre-characterized cell libraries for the process technology to be used when physically implementing the IC.
- In a typical IC design, constraint files are used and modified at various stages of the design. At each stage, the SDC files are cleaned up so as to make them more efficient and concise. In addition, when a designer completes a design stage and moves to the next stage, a new constraint file, that includes constraints that are more appropriate for the new design stage, is generated. Typically, the new file is created either manually by the designer or automatically by using a design tool. For example, a synthesis tool determines the timing constraints based on statistically based wire-load estimation models and cell libraries pre-characterized for the process technology to be used when physically implementing the IC.
- To ensure a correct design, it is imperative to check whether a modified or new constraints file meets the design criteria. Currently, an automatic tool that checks for constraints equivalence does not exist in the EDA industry, and such checks are often performed manually by designers, a process which is both time consuming and error prone.
- Therefore it would be advantageous to provide a solution for automatically checking for equivalence between two or more constraints files.
-
FIG. 1 is a diagram illustrating the equivalence checks of two constraints files used at the same stage of the design -
FIG. 2 is a diagram illustrating the equivalence checks of two constraints files modified by an implementation tool -
FIG. 3 is a diagram illustrating the equivalence checks of two constraints files used at different stages of the design -
FIGS. 4A and 4B are diagrams for illustrating the equivalence checks between a block-level constraints file and a top-level constraint file -
FIG. 5 is a flowchart describing the equivalence check process - An embodiment of the present invention provides a system and method for checking the equivalence of two or more constraints files of an integrated circuit (IC) design. The comparison is performed between files at the same stage of a design flow, or between files that correspond to different stages of a design flow, or between top-level and block-level constraint files. The constraint file may be in a format of SYNOPSIS design constraints (SDC) file, a MAGMA design constraints file, or the like.
-
FIG. 1 shows a non-limiting and exemplary diagram 100 illustrating the equivalence check of two constraint files, used at the same stage of the design, in accordance with an embodiment of the present invention. This type of check is performed once a designer modifies the constraints file. Such modifications can be performed at any stage of the design to make the design more efficient and concise. As shown inFIG. 1 , adesign file 110 uses aconstraints file 120, which is modified through acleanup process 130 to create anew constraints file 140. Thedesign file 150 uses thenew constraints file 140. Thecleanup process 130 includes removing duplicate or overwritten exceptions, removing constraints that are not applicable or are redundant, removing disable_timing instances and replacing them with false_path, clustering constraints that are similar, e.g., expanded constraints may be replaced by wildcards, expanding wildcards to apply different constraints to each path, and so on. Thedesign files equivalence check process 500 assures thatconstraint files new constraints file 140 retains the design criteria set infile 120. Theequivalence check process 500 is described in greater detail below. -
FIG. 2 shows a non-limiting and exemplary diagram 200 illustrating the equivalence check of two constraint files modified by an implementation tool in accordance with an embodiment of the present invention. This type of check is performed when a physical implantation tool 250 (e.g., a router) reconstructs a netlist and a constraints file. Thenetlist 210 is reconstructed by animplementation tool 250 which generates a new netlist 220. Thenetlists 210 and 220 ought to be equivalent. The verification thatnetlists 210 and 220 are equivalent can be performed using a formal verification engine. The reconstruction of the netlist 220 also modifies theconstraints file 230 and produces anew constraints file 240. In this case, theequivalence check process 500 assures constraints set on input, outputs, registers and intermediate points are equivalent. With this aim, theprocess 500 is provided, by the formal verification engine, with mapping information for equivalent points between thenetlists 210 and 220. -
FIG. 3 shows a non-limiting and exemplary diagram 300 illustrating the equivalence checks of multiple constraint files at different stages of the design, in accordance with an embodiment of the present invention. Typically, such a check is performed in order to compare between constraint files used for logic design (pre-layout) and physical design (post-layout). In the diagram shown inFIG. 3 , a RTLfile 310 is synthesized to a gate-level netlist 320 by asynthesis tool 370. Then, netlist 320 is passed to aphysical implementation tool 380 to create a layout of the design, which is represented asnetlist 330. Threedifferent constraint files synthesis tool 370 during logic synthesis; and, file 360 is generated using, for example, a static timing analyzer (STA) during the timing optimization. Asnetlists equivalence check process 500. -
FIGS. 4A and 4B show a non-limiting and exemplary diagram illustrating the equivalence checks between a block-level constraints file and a top-level constraints file in accordance with an embodiment of the present invention. As depicted inFIG. 4A constraint file 410 constrains the entire design and constraint files 430-2 through 430-2 relate to design blocks 440-2 and 440-2. The files 430 are generated by atiming budgeting process 420. Theequivalence check process 500 checks that block-level constraint files 430 are equivalent to top-level file 410. Additionally, as depicted inFIG. 4B thecheck process 500 can compare between a top-level constraint file 450 and block-level constraint files 460-1 and 460-2. With this aim, files 460 are merged prior to comparing to file 550. It should be noted that thecheck process 500 can a compare a plurality of block-level files to a top-level constraint file. The number of block-level constraint files 430 and 460 are as the number blocks of in adesign 480 shown inFIGS. 4A and 4B . -
FIG. 5 shows a non-limiting andexemplary flowchart 500 describing theequivalence check process 500 in accordance with an embodiment of the present invention. As demonstrated by the exemplary embodiments discussed above, theprocess 500 is the same regardless of the type of check that is being performed. Two constraint files are determined to be equivalent when all constraints and commands contained in the files are the same or result in the same effect. - The
process 500 begins with S510 where two constraint files are received as an input. These files may be related to the same design or equivalent designs. At S520, the designer (user) may specify the type of check to be performed, e.g., one of the checks defined above. The user may further specify which section in the constraint files (i.e., type of constraints) have to be checked. This allows performing incremental equivalence checking of the files. For example, the designer might not be interested in detecting equivalence for the whole constraints file in one pass. Optionally, when the designer wishes to check constraint equivalence of different designs, mapping information of the different designs is received at S530. The mapping information is generated by a formal verification tool and includes name mapping of objects (pins, points, nets, and so on) in both designs. - At S540, a check is performed to determine if the constraint files are clean. A clean constraints file is free of syntax errors and does not include any overwritten or duplicate constraints. If S540 results with a negative answer (i.e., a determination of not clean), execution continues with S545, where a cleaning process is executed; otherwise, execution continues with S550. The cleaning process can be performed manually by the user or automatically by using a set of constraint rules.
- At S550, the constraints are sequentially scanned and a pair of constraints from both files is selected. Specifically, first constraints in the files are ordered according to the their type and then they are paired for case analysis, clocks, input/output delays, exceptions, clock latency, clock uncertainty, input transition, output load, and so on. If no equivalent pair can be found, then constraints that could have the same effect are paired together, e.g. set_input_delay specified with respect to a virtual clock and set_max_delay set on the same path are selected as pairs. For each pair of constraints (commands or definitions) in both constraint files, a series of checks is performed to determine equivalency.
- Specifically, at S562, it is checked if the selected pair of constraints has the same definition, and if so execution proceeds to S564; otherwise, execution continues with S566. At S564, it is determined whether the (connection) points in the pair of constraints are equivalent. Generally, each constraint being considered for equivalence, is applied on a path that has a start point, an end point, and one or more intermediate points. These points can be inputs, outputs, registers or intermediate points in the design. If the input points and/or the output points are not equivalent, execution continues with S570 where the selected pair is reported as having differing constraints; otherwise, execution continues with S580.
- Execution reaches S566 to determine if the pair of constraints results in the same effect. For example, if a pure combinatorial path is constrained by using set_input_delay and set_output_delay with respect to a virtual clock in one constraints file and constrained using set_max_delay and set_min_delay in the second file, then if both of these commands results in same timing constraint, then they are determined to be equivalent. As another example, if a path is constrained using the constraint set_disable_timing in a first file and the constraint set_false_path in the second file, then both constraints are equivalent. Yet as another example, if the same constraint is set on an object (e.g. a pin) in the first file and set on an equivalent object (e.g. net connected to the pin) in the second file, then they are equivalent. If S566 results with a negative answer, execution continues with S568; otherwise, execution continues with S580.
- At S568, an equivalence check for overwritten or duplicate constraints is performed. For example, a constraints file “A” includes the constraints:
- create_clock -name CLK1 -period 10 [get_ports clka]
create_clock -name CLK2 -period 12 [get_ports clkb]
create_clock -name CLK3 -period 14 [get_ports clkc]
and a constraints file “B” includes the constraints:
create_clock -name C1 -period 10 [get_ports clka]
create_clock -name C2 -period 8 [get_ports clkb]
create_clock -name C3 -period 12 [get_ports clkb]
create_clock -name C4 -period 14 [get_ports clkc] - In this example, a definition of clock C2 (in file B) is not the same as the definition of clock CLK2 (in file B). However, clock C2 is overwritten by clock C3 (in file B) and clock C3 and clock CLK2 are equivalent, thus files A and B are considered equivalent. If it is determined that overwritten or duplicate constraints are not equivalent, execution continues with S570 where the differing constraints are reported; otherwise, execution continues with S580. At S580, it is checked if all commands and definitions in both constraint files were tested, and if so, execution proceeds with S590 where a report is generated; otherwise, execution returns to S550. The report preferably includes an indication of all pairs of different constraints and of constraints that are included only in one of the constraint files.
- It should be noted that when comparing between a top-level constraints file and block-level constraints files, the latter are merged into a single file which is provided as an input to process 500. That is, the compression is performed between a top-level file and the merged file.
- The invention disclosed in detail herein can be implemented in hardware, software, or combination thereof. The invention can be also implemented in a computer aided design (CAD) system or a CAD program and realized by operation of the system or program on a computer processor controlling a memory in which steps of the program are stored. The invention in the above-identified aspects may likewise be realized in a computer program product containing a plurality of instructions or commands, stored on a tangible computer readable medium, that when executed on a proper hardware such as a computer processor would result in the implementation of the methods disclosed herein.
- It will be appreciated that the foregoing description has been made with respect to simplified examples, and that the inventive approach can be applied to more complex situations. Likewise, the report mentioned above may be generated in any number of different forms, with varying content, and at steps other than the precise step mentioned above.
- It will be further appreciated that, as one example of a useful result that arises from the use of the inventive concepts described above, the checking of constraint equivalence in IC design can be realized in an automated system.
- The invention is not limited to the foregoing embodiments, and those familiar with this field will be now equipped from the foregoing discussion to implement the invention in various other embodiments, without departing from the scope or spirit of the invention. To that end, the scope of the invention should be determined not from the concrete examples discussed, but from the claims appended below.
Claims (28)
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US11/755,764 US7882483B2 (en) | 2007-05-31 | 2007-05-31 | Method for checking constraints equivalence of an integrated circuit design |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US11/755,764 US7882483B2 (en) | 2007-05-31 | 2007-05-31 | Method for checking constraints equivalence of an integrated circuit design |
Publications (2)
Publication Number | Publication Date |
---|---|
US20080301598A1 true US20080301598A1 (en) | 2008-12-04 |
US7882483B2 US7882483B2 (en) | 2011-02-01 |
Family
ID=40089705
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US11/755,764 Active 2027-08-01 US7882483B2 (en) | 2007-05-31 | 2007-05-31 | Method for checking constraints equivalence of an integrated circuit design |
Country Status (1)
Country | Link |
---|---|
US (1) | US7882483B2 (en) |
Cited By (7)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7694266B1 (en) * | 2008-01-22 | 2010-04-06 | Cadence Design Systems, Inc. | Method and apparatus for dynamic frequency voltage switching circuit synthesis |
US8261221B2 (en) | 2010-04-13 | 2012-09-04 | Synopsys, Inc. | Comparing timing constraints of circuits |
US20130014068A1 (en) * | 2011-07-08 | 2013-01-10 | Atrenta, Inc. | Computer-aided design system and methods thereof for merging design constraint files across operational modes |
US8607186B2 (en) | 2010-04-13 | 2013-12-10 | Synopsys, Inc. | Automatic verification of merged mode constraints for electronic circuits |
US8627262B2 (en) | 2010-04-13 | 2014-01-07 | Synopsys, Inc. | Automatic generation of merged mode constraints for electronic circuits |
US8701074B2 (en) | 2010-04-13 | 2014-04-15 | Synopsys, Inc. | Automatic reduction of modes of electronic circuits for timing analysis |
US9489478B2 (en) | 2014-10-17 | 2016-11-08 | Synopsys, Inc. | Simplifying modes of an electronic circuit by reducing constraints |
Families Citing this family (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
JP5157534B2 (en) * | 2008-03-06 | 2013-03-06 | 日本電気株式会社 | Behavioral synthesis apparatus and program |
JP4950942B2 (en) * | 2008-05-23 | 2012-06-13 | 株式会社東芝 | Semiconductor integrated circuit verification device |
Citations (8)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20040103380A1 (en) * | 2002-11-19 | 2004-05-27 | Bohl Richard L. | System and method for automated electronic device design |
US20050125757A1 (en) * | 2003-12-05 | 2005-06-09 | Narayanan Krishnamurthy | Derivation of circuit block constraints |
US20060230373A1 (en) * | 2005-03-29 | 2006-10-12 | Lsi Logic Corporation | Intelligent timing analysis and constraint generation GUI |
US20070067746A1 (en) * | 2005-09-22 | 2007-03-22 | Baumgartner Jason R | Method and system for performing heuristic constraint simplification |
US20070220462A1 (en) * | 2006-03-15 | 2007-09-20 | Lsi Logic Corporation | Verification of an extracted timing model file |
US20080126773A1 (en) * | 2006-06-30 | 2008-05-29 | International Business Machines Corporation | Method, system and program product for verifying configuration of a computer system |
US20080244491A1 (en) * | 2007-03-26 | 2008-10-02 | Lsi Logic Corporation | Generic methodology to support chip level integration of IP core instance constraints in integrated circuits |
US20080282212A1 (en) * | 2007-05-08 | 2008-11-13 | Ian Campbell Dennison | System and method enabling circuit topology recognition with auto-interactive constraint application and smart checking |
Family Cites Families (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6842884B2 (en) | 2002-08-28 | 2005-01-11 | Verplex Systems, Inc. | Combinational equivalence checking methods and systems with internal don't cares |
US7134106B2 (en) | 2004-04-09 | 2006-11-07 | Incentia Design Systems Corp. | Method and system for providing fast design for testability prototyping in integrated circuit designs |
-
2007
- 2007-05-31 US US11/755,764 patent/US7882483B2/en active Active
Patent Citations (9)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20040103380A1 (en) * | 2002-11-19 | 2004-05-27 | Bohl Richard L. | System and method for automated electronic device design |
US20060271892A1 (en) * | 2002-11-19 | 2006-11-30 | Bohl Richard L | System and method for automated electronic device design |
US20050125757A1 (en) * | 2003-12-05 | 2005-06-09 | Narayanan Krishnamurthy | Derivation of circuit block constraints |
US20060230373A1 (en) * | 2005-03-29 | 2006-10-12 | Lsi Logic Corporation | Intelligent timing analysis and constraint generation GUI |
US20070067746A1 (en) * | 2005-09-22 | 2007-03-22 | Baumgartner Jason R | Method and system for performing heuristic constraint simplification |
US20070220462A1 (en) * | 2006-03-15 | 2007-09-20 | Lsi Logic Corporation | Verification of an extracted timing model file |
US20080126773A1 (en) * | 2006-06-30 | 2008-05-29 | International Business Machines Corporation | Method, system and program product for verifying configuration of a computer system |
US20080244491A1 (en) * | 2007-03-26 | 2008-10-02 | Lsi Logic Corporation | Generic methodology to support chip level integration of IP core instance constraints in integrated circuits |
US20080282212A1 (en) * | 2007-05-08 | 2008-11-13 | Ian Campbell Dennison | System and method enabling circuit topology recognition with auto-interactive constraint application and smart checking |
Cited By (8)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7694266B1 (en) * | 2008-01-22 | 2010-04-06 | Cadence Design Systems, Inc. | Method and apparatus for dynamic frequency voltage switching circuit synthesis |
US8261221B2 (en) | 2010-04-13 | 2012-09-04 | Synopsys, Inc. | Comparing timing constraints of circuits |
US8607186B2 (en) | 2010-04-13 | 2013-12-10 | Synopsys, Inc. | Automatic verification of merged mode constraints for electronic circuits |
US8627262B2 (en) | 2010-04-13 | 2014-01-07 | Synopsys, Inc. | Automatic generation of merged mode constraints for electronic circuits |
US8701074B2 (en) | 2010-04-13 | 2014-04-15 | Synopsys, Inc. | Automatic reduction of modes of electronic circuits for timing analysis |
US20130014068A1 (en) * | 2011-07-08 | 2013-01-10 | Atrenta, Inc. | Computer-aided design system and methods thereof for merging design constraint files across operational modes |
US8775989B2 (en) * | 2011-07-08 | 2014-07-08 | Atrenta, Inc. | Computer-aided design system and methods thereof for merging design constraint files across operational modes |
US9489478B2 (en) | 2014-10-17 | 2016-11-08 | Synopsys, Inc. | Simplifying modes of an electronic circuit by reducing constraints |
Also Published As
Publication number | Publication date |
---|---|
US7882483B2 (en) | 2011-02-01 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US7882483B2 (en) | Method for checking constraints equivalence of an integrated circuit design | |
Mishchenko et al. | Improvements to combinational equivalence checking | |
US6728939B2 (en) | Method of circuit verification in digital design | |
US7506292B2 (en) | Method for clock synchronization validation in integrated circuit design | |
US7958470B1 (en) | Method and system for false path analysis | |
US10031986B1 (en) | System and method for creating a spice deck for path-based analysis of an electronic circuit design using a stage-based technique | |
US10776547B1 (en) | Infinite-depth path-based analysis of operational timing for circuit design | |
US20030208730A1 (en) | Method for verifying properties of a circuit model | |
US20050268258A1 (en) | Rule-based design consultant and method for integrated circuit design | |
US20130179142A1 (en) | Distributed parallel simulation method and recording medium for storing the method | |
US7650581B2 (en) | Method for modeling and verifying timing exceptions | |
US8869091B2 (en) | Incremental clock tree synthesis | |
Mattarei et al. | Cosa: Integrated verification for agile hardware design | |
US8719752B1 (en) | Hierarchical crosstalk noise analysis model generation | |
US20080201671A1 (en) | Method for generating timing exceptions | |
JP2003526149A (en) | Method and apparatus for verifying critical path and false path | |
US8522182B2 (en) | Generation of an end point report for a timing simulation of an integrated circuit | |
US10248746B1 (en) | Method and apparatus for estimating ideal power of an integrated circuit design | |
US7210109B2 (en) | Equivalence checking of scan path flush operations | |
US6687882B1 (en) | Methods and apparatuses for non-equivalence checking of circuits with subspace | |
Casaubieilh et al. | Functional verification methodology of Chameleon processor | |
US20040210861A1 (en) | System and method for optimizing exceptions | |
US20080059923A1 (en) | Lsi power consumption calculation method and calculation program | |
US7979262B1 (en) | Method for verifying connectivity of electrical circuit components | |
US10430535B2 (en) | Verification support program medium, verification support method, and information processing device for verification of a circuit |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: ATRENTA, INC., CALIFORNIA Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:GANGADHARAN, SRIDHAR;GOEL, MANISH;PRASOON, PRATYUSH K.;AND OTHERS;REEL/FRAME:019585/0076 Effective date: 20070702 |
|
AS | Assignment |
Owner name: HERCULES TECHNOLOGY GROWTH CAPITAL, INC., CALIFORN Free format text: SECURITY AGREEMENT;ASSIGNOR:ATRENTA, INC.;REEL/FRAME:021222/0668 Effective date: 20051229 Owner name: HERCULES TECHNOLOGY GROWTH CAPITAL, INC.,CALIFORNI Free format text: SECURITY AGREEMENT;ASSIGNOR:ATRENTA, INC.;REEL/FRAME:021222/0668 Effective date: 20051229 |
|
AS | Assignment |
Owner name: SILICON VALLEY BANK, CALIFORNIA Free format text: SECURITY AGREEMENT;ASSIGNOR:ATRENTA INC.;REEL/FRAME:022542/0570 Effective date: 20090414 Owner name: SILICON VALLEY BANK,CALIFORNIA Free format text: SECURITY AGREEMENT;ASSIGNOR:ATRENTA INC.;REEL/FRAME:022542/0570 Effective date: 20090414 |
|
AS | Assignment |
Owner name: ATRENTA INC., CALIFORNIA Free format text: RELEASE BY SECURED PARTY;ASSIGNOR:HERCULES TECHNOLOGY GROWTH CAPITAL, INC.;REEL/FRAME:022552/0639 Effective date: 20090414 |
|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
FPAY | Fee payment |
Year of fee payment: 4 |
|
AS | Assignment |
Owner name: ATRENTA INC., CALIFORNIA Free format text: RELEASE BY SECURED PARTY;ASSIGNOR:SILICON VALLEY BANK;REEL/FRAME:036584/0644 Effective date: 20150825 |
|
AS | Assignment |
Owner name: SYNOPSYS, INC., CALIFORNIA Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:ATRENTA INC.;REEL/FRAME:036687/0290 Effective date: 20150922 |
|
FEPP | Fee payment procedure |
Free format text: PAT HOLDER NO LONGER CLAIMS SMALL ENTITY STATUS, ENTITY STATUS SET TO UNDISCOUNTED (ORIGINAL EVENT CODE: STOL); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
MAFP | Maintenance fee payment |
Free format text: PAYMENT OF MAINTENANCE FEE, 8TH YEAR, LARGE ENTITY (ORIGINAL EVENT CODE: M1552) Year of fee payment: 8 |
|
MAFP | Maintenance fee payment |
Free format text: PAYMENT OF MAINTENANCE FEE, 12TH YEAR, LARGE ENTITY (ORIGINAL EVENT CODE: M1553); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY Year of fee payment: 12 |