Integrated Circuit Example Design Method Based on Virtuoso
An automated method in Virtuoso's Skill language addresses the inefficiencies and errors of manual instance replacement in integrated circuit design by traversing and replacing instance objects, enhancing design efficiency and consistency.
Patent Information
- Application Number
- CN202411248745.X
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2024-09-06
- Publication Date
- 2024-12-06
- Estimated Expiration
- 2044-09-06
AI Technical Summary
The manual replacement of instance references in integrated circuit design using Virtuoso software is time-consuming and prone to errors, especially as the design scale increases, affecting efficiency and consistency.
An automated method using a program script file in Virtuoso's Skill language to traverse and replace instance objects in the Layout view, adhering to preset criteria, ensuring standardization and reducing human error.
Automated replacement of instance references improves design efficiency and consistency by reducing manual effort and error, maintaining standardization and reliability in integrated circuit design.
Smart Images

Figure CN118761375B_ABST
Abstract
Description
Technical Field
[0001] The present application relates to the technical field of integrated circuit design, and in particular to a Virtuoso-based integrated circuit instance design method. Background Art
[0002] Virtuoso software is an integrated circuit design software launched by EDA software supplier Cadence. It can complete all aspects of the entire IC design process, including circuit diagram input, circuit simulation, layout design, layout verification, parasitic parameter extraction and post-simulation, so it is widely used in the development of integrated circuits. There are multiple cell views (cellview) in the integrated circuit design environment based on Virtuoso software. Each cell view represents a different expression of a specific cell. Among them, Layout cellview is the physical design view of the integrated circuit, which defines the physical position and shape of the components on the silicon wafer, including various hierarchical structures, metal interconnections, contact holes (Via), etc. Designers can implement circuit layout and routing by editing Layoutcellview.
[0003] The Layout view can contain a large number of instances, that is, copies of a referenced circuit unit. Each instance references the Cellview of a cell in the library, that is, the Master. The Master can be regarded as a template. Multiple instances can reference the same Master, thereby sharing the definition of the Master. When there is a design change or the Cellview in another library needs to be used as a new reference, the Master referenced by the existing Instance needs to be replaced to point to the Cellview in another Library. For instances such as Via, sometimes the cellview in the library pointed to by the Master referenced by the Via is user-defined rather than from the standard process library (PDK). In this case, in order to maintain the consistency and standardization of the design, these Vias need to be replaced with standard devices from the standard process library. In response to this situation, designers currently generally use manual operations to modify the Master referenced by the Instance. However, as the scale of the circuit expands and the number of components increases, if the Master is modified manually, designers will not only need to spend a lot of time, which will seriously affect the design efficiency, but may also greatly increase the probability of errors. Summary of the invention
[0004] Based on this, it is necessary to provide an integrated circuit example design method based on Virtuoso to address the above technical problems.
[0005] In a first aspect, the present application provides a method for designing an integrated circuit instance based on Virtuoso, the method comprising:
[0006] Using the Skill program interface of the Virtuoso software, a program script file is written according to predetermined execution steps, and the program script file is configured in the Virtuoso software environment. When the Virtuoso software is started, the program script file is automatically loaded, and in response to a call request of the program script file, the reference content of the instance of the target integrated circuit in the Layout view is extracted and replaced;
[0007] The predetermined execution steps implemented by writing the program script file include:
[0008] Traversing the instance objects in the Layout view of the target integrated circuit, and extracting the target instance objects that meet the preset replacement criteria;
[0009] The target instance object is replaced with an instance object whose reference content points to a unit view in the target library.
[0010] In one embodiment, traversing the instance objects in the Layout view of the target integrated circuit to extract the target instance objects that meet the preset replacement criteria includes:
[0011] For each preset keyword, the instance objects in the Layout view of the target integrated circuit are traversed to extract the target instance objects whose instance names contain the preset keyword.
[0012] In one embodiment, replacing the target instance object with an instance object whose reference content points to a unit view in a preset library includes:
[0013] Acquire attribute information of the target instance object, wherein the attribute information at least includes a reference unit name, a target library name, and a reference view name;
[0014] A target unit view is selected in the target library according to the attribute information, and the master attribute of the target instance object is replaced with the identification information of the target unit view.
[0015] In one embodiment, traversing the instance objects in the Layout view of the target integrated circuit to extract the target instance objects that meet the preset replacement criteria includes:
[0016] Obtain all via instances within a coordinate range of a Layout view of the target integrated circuit;
[0017] The obtained via instances are traversed to extract target via instances whose library parameters in the master attribute are not target libraries.
[0018] In one embodiment, replacing the target instance object with an instance object whose reference content points to a unit view in a preset library includes:
[0019] Acquire attribute information of the target via instance, wherein the attribute information includes at least a via instance name, a via instance position and direction, and a via instance coverage parameter;
[0020] Obtaining a via instance technical definition in a target library according to the via instance name;
[0021] The target via instance is deleted, and a new via instance is created according to the via instance position and direction, the via instance coverage parameters, and the via instance technology definition.
[0022] In one embodiment, traversing the instance objects in the Layout view of the target integrated circuit to extract the target instance objects that meet the preset replacement criteria includes:
[0023] Obtain all via array instances according to the number of metal layers included in the Layout view of the target integrated circuit;
[0024] The obtained via array instances are traversed to extract target via array instances whose library parameters in the master attribute are not target libraries.
[0025] In one embodiment, obtaining all via array instances according to the number of metal layers included in the Layout view of the target integrated circuit includes:
[0026] Obtaining the maximum number of metal layers of all process libraries applied to the Layout view of the target integrated circuit;
[0027] generating a specific naming string according to the number of metal layers;
[0028] All via array instances whose naming format conforms to the specific naming string are obtained in the Layout view of the target integrated circuit.
[0029] In one embodiment, replacing the target instance object with an instance object whose reference content points to a unit view in a preset library includes:
[0030] Acquire attribute information of the target via array instance, wherein the attribute information at least includes a via array instance name, a via array instance position and a direction;
[0031] Obtaining a via array instance technical definition and via array instance layout parameters in a target library according to the via array instance name;
[0032] The target via array instance is deleted, and a new via array instance is created according to the via array instance position and direction, via array instance layout parameters, and the via array instance technology definition.
[0033] In one embodiment, the method further comprises:
[0034] If the via array instance technical definition corresponding to the via array instance name does not exist in the target library, a new via array instance name is created based on a regular expression, and the via array instance technical definition and via array instance layout parameters are obtained in the target library according to the new via array instance name.
[0035] In one embodiment, traversing the instance objects in the Layout view of the target integrated circuit to extract the target instance objects that meet the preset replacement criteria includes:
[0036] Obtaining the maximum number of metal layers of all process libraries applied to the Layout view of the target integrated circuit;
[0037] generating a specific naming string according to the maximum number of metal layers;
[0038] Acquire, in a Layout view of the target integrated circuit, all via instances whose naming format conforms to the specific naming string;
[0039] The obtained via instances are traversed to extract target via instances whose library parameters in the master attribute are not target libraries.
[0040] The integrated circuit instance design method based on Virtuoso disclosed in the present application is adopted, and a skill program is used to write a program script file, and then the program script file is configured in the Virtuoso software environment, so that the program script file is automatically loaded when the Virtuoso software is started, so that the program script file can respond to the call request, automatically extract and replace the reference content of the instance in the Layout view of the target integrated circuit. In this way, compared with the traditional manual operation method, the automated script traverses the instance objects in the layout view, and screens out the instances that need to be replaced based on preset standards, and then automatically replaces the reference content of the instance objects. Designers do not need to manually perform complex reference replacement operations, thereby reducing the risk of errors in human operations, saving a lot of time and energy, and significantly improving the design efficiency of integrated circuits. BRIEF DESCRIPTION OF THE DRAWINGS
[0041] Figure 1 A schematic diagram of a flow chart of a method for designing an integrated circuit example based on Virtuoso in one embodiment;
[0042] Figure 2A flowchart of predetermined execution steps implemented by writing a program script file in one embodiment. DETAILED DESCRIPTION
[0043] In order to make the purpose, technical solution and advantages of the present application more clearly understood, the present application is further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application and are not used to limit the present application.
[0044] When designing integrated circuits using Virtuoso software, each instance in the Layout view references a master component, which defines the structure and behavior of the instance and points to a cellview in a library. In some cases, it may be necessary to change the cellview pointed to by the master referenced by the instance. At this time, the designer can select the cellview to be copied and the target library through File ->Save a Copy, so as to copy the cellview to the target library to form a new cellview. After that, the designer can edit the instance's Edit InstanceProperties and point the masterID in it to the new cellview in the target library. Via is a special instance used to establish electrical connections between different metal layers. In the Layout view, Via is represented by a geometric shape and placed at a specific location between metal layers. Typically, Via is a standard instance that references a specific cellview in a standard process library (PDK) and can be placed directly at a specific location in the layout. However, in some cases, designers may create custom Vias that are not from PDK. In order to maintain the consistency and standardization of the design, it may be necessary to replace the custom Vias with standard Vias from PDK. In this case, designers also need to manually find and replace Vias that do not reference PDK. It can be seen that the above replacement of instances (including Vias) involves multiple steps: copying cellview, updating instance references, replacing Vias, etc. If these steps are completed manually, it is not only time-consuming, but also prone to errors. Especially when the design scale is large, it becomes more difficult to manually handle each instance.
[0045] In view of the above problems, the present application provides an integrated circuit example design method based on Virtuoso, such as Figure 1 As shown, the following steps may be included:
[0046] Step 110, using the Skill program interface of the Virtuoso software, write a program script file according to the predetermined execution steps.
[0047] Among them, Virtuoso software is part of the Cadence design system, an environment for integrated circuit design, especially analog, RF, mixed signal design, etc. Skill language is Cadence's proprietary scripting language, used to write automated programs. Skill provides in-depth access to the Virtuoso database and design tools, allowing users to automate and customize the design process through programming.
[0048] In implementation, when writing a program script file, the library functions and tools provided by the Skill language can be used to access the design database, perform graphical user interface (GUI) programming, process text and data, etc. The predetermined execution steps in the program script file may include: accessing the database of integrated circuit designs, traversing the instance objects in the Layout view of the integrated circuit, extracting the instance objects that meet the preset replacement criteria, replacing the instance objects with the instance objects whose reference content points to the unit view in the target library, etc.
[0049] For details, please refer to Figure 2 As shown, the predetermined execution steps implemented by writing a program script file include the following:
[0050] Step 111, traverse the instance objects in the Layout view of the target integrated circuit, and extract the target instance objects that meet the preset replacement criteria.
[0051] Among them, the preset replacement standard can be used to define the conditions under which instance objects need to be replaced. The preset replacement standard can be defined by the designer based on various factors, such as performance optimization, power consumption reduction, process library update, design rule change, etc.
[0052] In implementation, the program script file can traverse the Layout view of the target integrated circuit, find all instance objects, and then determine whether the instance objects meet the preset replacement criteria. Once the target instance objects that need to be replaced are determined, that is, the target instance objects that meet the preset replacement criteria, the program script file will extract these target instance objects from the layout view and prepare for the next step of replacement operation.
[0053] Step 112: Replace the target instance object with an instance object whose reference content points to the unit view in the target library.
[0054] In implementation, the program script file can replace the extracted target instance object with an instance object whose reference content points to a unit view in a target library, wherein the target library can be a library that needs to be referenced after the replacement. For the replacement of the target instance object, the reference content of the target instance object can be directly modified, or the target instance object can be deleted and a new instance object can be inserted at the same position according to the specific situation.
[0055] In one embodiment, satisfying the preset replacement standard may be that the instance name contains a preset keyword. Accordingly, step 111 may include the following processing: for each preset keyword, traverse the instance objects in the Layout view of the target integrated circuit, and extract the target instance object whose instance name contains the preset keyword.
[0056] In practice, the above process can be broken down into the following steps:
[0057] 111-1a: The main function change_inst_library is selected as the main entry of the program script file, which is used to batch replace the library of the master cellview of the instance in the Virtuoso layout.
[0058] 111-2a: Get the specific string (i.e., preset keyword) input by the user and the name of the target library, and store the specific string in the namelist list, where the namelist list can be in the format of list("flag1" "flag2" "flag3"...), and each flag represents a keyword. Furthermore, relevant position restriction identifiers can be added to filter instance names more accurately. For example, the regular expression "^NN" can be used to represent a string starting with "NN", and "NN$" can be used to represent a string ending with "NN". In this way, instance objects whose instance names start with "NN" or end with "NN" can be matched and filtered out.
[0059] 111-3a: Use the geGetEditCellView function to get the address ID of the only opened Layout view and read this address into the cvId variable.
[0060] The function of geGetEditCellView is to obtain a reference to the layout cell currently being edited, ensuring that subsequent operations are performed on the correct Layout view; the cvId variable is a reference to the view currently being operated on (similar to a pointer or handle), through which the data in the view can be accessed and operated.
[0061] 111-4a: Use the foreach function to traverse each keyword in the namelist list. Every time a keyword is read, a new empty list corresponding to the keyword is created as inst_ids to store the address ID of the instance that needs to be modified based on the keyword.
[0062] The foreach function is an iterative function in the Skill language, which is used to loop through each element in the collection.
[0063] 111-5a: Use the setof function to filter out all instance objects in the cvId variable (representing the current cellview) whose instance names meet the judgment criteria of the rexMatchp function, and store the filtered instance objects in inst_ids corresponding to the keyword. Here, the rexMatchp function is used to check whether the instance name of the instance object contains the keyword defined by the user in the namelist.
[0064] It can be understood that the foreach loop and rexMatchp function can accurately match the instance object names that match the keywords provided by the user, and store the IDs of these instance objects in the list inst_ids. This matching mechanism allows designers to accurately filter according to specific naming rules (such as ^NN, NN$), so that only specific instance objects can be modified without accidentally modifying irrelevant objects. And by allowing users to customize keywords and target libraries, it provides great flexibility, allowing designers to batch replace different instance objects as needed.
[0065] Based on the processing of steps 111-1a to 111-5a, the processing of step 112 can be as follows: obtain the attribute information of the target instance object, the attribute information at least includes the reference unit name, the target library name and the reference view name; select the target unit view in the target library according to the attribute information, and replace the master attribute of the target instance object with the identification information of the target unit view.
[0066] In practice, the above process can be broken down into the following steps:
[0067] 112-6a: Traverse each target instance object in each inst_ids list, and read the attribute information of each instance object through the operator ~>. Specifically, cellName (i.e., the reference cell name) can be assigned to the variable copycell through the operator ~>, libName (i.e., the user-defined target library name) can be assigned to the variable copylib through the operator ~>, and viewName (i.e., the reference view name) can be assigned to the variable copyview through the operator ~>.
[0068] Here, 112 - 6a is a subsequent step of 111 - 5a.
[0069] 112-7a: Use the ddGetObj function to determine whether there is already a cell view named copycell and whose view is copyview in the copylib library (that is, the target cell view).
[0070] 112-8a: If it does not exist, use the dbSave function to create a cell named copycell in the target library copylib and set the view type to copyview; if it exists, execute step 111-9.
[0071] 112-9a: Read the data ID of the copycell cell view (i.e., the target cell view) in copylib through the dbOpenCellViewByType function and assign it to the newMaster variable.
[0072] 112-10a: The master attribute of the target instance object is read through the operator ~>, and the target unit view ID (ie, newMaster) is assigned to the master attribute through "=", thereby completing the replacement of the reference content of the target instance object.
[0073] It can be understood that the processing of the above steps 111-1a to 112-10a can identify and replace qualified instance objects through the user-defined keyword list (namelist) and the target library (the library where the master cell is located), thereby realizing the automatic replacement of the old library to the new library, reducing the risk of errors in manual operations, and improving work efficiency. At the same time, the replacement operation not only realizes the update of the target library, but also ensures the consistency of the design. All qualified instance objects are uniformly replaced with new implementation versions. This is very important for maintaining the standardization and maintainability of the design. In addition, by obtaining the current cellName, library, and viewName of each instance object to be replaced, it is determined whether it exists in the target library. If the corresponding cellview is missing in the target library, a new cellview is automatically created, thereby avoiding the replacement failure caused by the incomplete target library and improving the reliability of the program script file.
[0074] In one embodiment, for via instances, the processing of step 111 may be specifically as follows: obtaining all via instances within the coordinate range of the Layout view of the target integrated circuit; traversing the obtained via instances, and extracting target via instances whose library parameters in the master attributes are not the target library.
[0075] In implementation, the above process may include the following contents:
[0076] 111-1b: Select the main function change_Via_library() as the main entry of the program script file, which is used for the subsequent batch replacement of non-standard vias with vias that meet the PDK standard.
[0077] 111-2b: Use the geGetEditCellView function to get the address ID of the only opened Layout view and read this address into the cvId variable.
[0078] The function of geGetEditCellView is to obtain a reference to the layout cell currently being edited, ensuring that subsequent operations are performed on the correct Layout view; the cvId variable is a reference to the view currently being operated on (similar to a pointer or handle), through which the data in the view can be accessed and operated.
[0079] 111-3b: Get the bBox coordinate range of the current layout view, use the leSearchHierarchy function to search for Via (i.e., via instance) within the bBox coordinate range, and store all the found Via IDs in the Via_ids list for subsequent processing.
[0080] 111-4b: Use the foreach function to iterate over each Via ID in the Via_ids list, and use the operator ~> to read the master property value bound to the Via ID.
[0081] 111-5b: Determine whether the library (i.e., library parameter) pointed to by the master is the target library (e.g., tsmcN12, i.e., determine whether the Via is from the tsmcN12 process library). If not, the Via is a target via instance and needs to be further processed and replaced with the Via in the tsmcN12 process library.
[0082] Based on the processing of steps 111-1b to 111-5b, the processing of step 112 can be as follows: obtain the attribute information of the target via instance, the attribute information including at least the via instance name, the via instance position and direction, and the via instance coverage parameters; obtain the via instance technical definition in the target library according to the via instance name; delete the target via instance, and create a new via instance according to the via instance position and direction, the via instance coverage parameters, and the via instance technical definition.
[0083] In practice, the above process can be broken down into the following steps:
[0084] 112-6b: Use the operator ~> to read the origin environment variable (i.e., the via instance position) bound to the ID of the target via instance, indicating the starting position or center point of the via in the layout, and store it in the variable centerpoint; read the orient environment variable (i.e., the via instance direction), indicating the direction or rotation angle of the via, and store it in the variable orient.
[0085] Here, 112 - 6b is a subsequent step of 111 - 5b.
[0086] 112-7b: Return the technology database identifier bound to the current layout view (cvId) through the techGetTechFile function, store the technology database identifier in the variable tech to find the Via definition in the technology database.
[0087] 112-8b: Use the operator ~> to read the cell name of the master bound to the ID of the target via instance and assign it to the variable cellname; through the techFindViaDefByName function, find the corresponding Via definition (that is, the via instance technology definition) in the technology database pointed to by the variable tech according to cellName.
[0088] 112-9b: Use the operator ~> to read the overrideParams environment variable (i.e., via instance override parameters) bound to the ID of the target via instance, including parameters used to fine-tune or define the characteristics of the Via, such as the size and spacing of the Via.
[0089] 112-10b: Delete the old target via instance from the database through the dbDeleteObject function, here the current Via is deleted; based on the previously saved centerpoint, orient, ViaParams and Via definition in the technical database, use the dbCreateVia function to create a new via instance at the location of the deleted target via instance, ensuring that the new via instance meets the specified technical requirements and parameter settings.
[0090] In one embodiment, for via array instances, the processing of step 111 may be specifically as follows: obtaining all via array instances according to the number of metal layers contained in the Layout view of the target integrated circuit; traversing the obtained via array instances, and extracting the target via array instances whose library parameters in the master attributes are not the target library.
[0091] In practice, the above process can be broken down into the following steps:
[0092] 111-1c: Select the main function change_Via_library() as the main entry of the program script file for subsequent batch replacement of non-standard via arrays with via arrays that meet the PDK standard.
[0093] 111-2c: Use the geGetEditCellView function to get the address ID of the only opened Layout view and read this address into the cvId variable.
[0094] The function of geGetEditCellView is to obtain a reference to the layout cell currently being edited, ensuring that subsequent operations are performed on the correct Layout view; the cvId variable is a reference to the view currently being operated on (similar to a pointer or handle), through which the data in the view can be accessed and operated.
[0095] 111-3c: Create a new empty list array_ids to store all IDs about the Via array.
[0096] 111-4c: Get all via array instances according to the number n of metal layers contained in the Layout view of the target integrated circuit.
[0097] It can be understood that in integrated circuit design, the process library contains components, metal layers, etc. under a specific process node or manufacturing technology. Different process libraries represent different manufacturing process technologies or different design rules, such as 28nm, 14nm or 7nm process libraries. Different process libraries may allow the use of different numbers of metal layers, and the materials, thicknesses, and hierarchical structures of these metal layers may be different. Via arrays are key structures for creating electrical connections between different metal layers. Designers can determine which Via arrays are needed between these metal layers based on the metal layer options and process libraries used. Therefore, it can be assumed that Via arrays are set between all metal layers included in the Layout view, so that all via arrays can be obtained based on the number of metal layers included in the Layout view.
[0098] Based on this, 111-4c can be further refined into the following process: obtain the maximum number of metal layers of all process libraries applied to the Layout view of the target integrated circuit; generate a specific naming string based on the number of metal layers; obtain all via array instances whose naming format conforms to the specific naming string in the Layout view of the target integrated circuit.
[0099] In implementation, the above processing flow may be specifically as follows:
[0100] 111-4c-1: Get the maximum number n of metal layers of all process libraries applied to the Layout view of the target integrated circuit.
[0101] 111-4c-2: Use the for function to traverse all the numbers i from 2 to n, and use the strcat function to concatenate strings to generate a specific named string in the "Mi_M*" format and assign it to the variable name.
[0102] It can be understood that 2 to n correspond to via arrays between different metal layers, and via array instances in a specific naming format can be searched by generating a specific naming string.
[0103] 111-4c-3: Use the leSearchHierarchy function to search for via array instances that match the naming format name in the Layout view, and store the IDs of the via array instances in the array_ids list. Similarly, when searching for via array instances, you can first obtain the bBox coordinate range of the current layout view, and search for via array instances that match the naming format name within the bBox coordinate range.
[0104] 111-5c: Use the foreach function to iterate over the ID of each Via array (via array instance) in the array_ids list, and use the operator ~> to read the master property value bound to the ID of the Via array.
[0105] 111-6c: Determine whether the library (i.e., library parameter) pointed to by the master is the target library (e.g., tsmcN12, i.e., determine whether the Via array is from the tsmcN12 process library). If not, the Via array is an instance of the target via array and needs to be further processed and replaced with the Via array in the tsmcN12 process library.
[0106] Based on the processing of steps 111-1c to 111-6c, the processing of step 112 can be as follows: obtain the attribute information of the target via array instance, the attribute information at least including the via array instance name, the via array instance position and direction; obtain the via array instance technical definition and the via array instance layout parameters in the target library according to the via array instance name; delete the target via array instance, and create a new via array instance according to the via array instance position and direction, the via array instance layout parameters, and the via array instance technical definition.
[0107] In practice, the above process can be broken down into the following steps:
[0108] 112-7c: Use the operator ~> to read the bBox coordinate value bound to the ID of the target via array instance, then calculate the coordinate center point (that is, the position of the via array instance) through the centerBox function and store the calculation result in the variable point.
[0109] Among them, bBox is the bounding box, which represents the outer coordinates of the Via array in the Layout view, usually composed of the coordinates of the lower left corner and the upper right corner. The centerBox function is used to calculate the center point of the bounding box, that is, the center position of the Via array.
[0110] Here, 112 - 7c is a subsequent step of 111 - 6c.
[0111] 112-8c: Use the operator ~> to read the tileArray environment variable bound to the ID of the target via array instance (that is, the direction of the via array instance) and store it in the variable orient.
[0112] The tileArray environment variable indicates the arrangement or direction of the Via array, which is related to the direction of the Via array in the layout (such as horizontal or vertical arrangement).
[0113] 112-9c: The width and length of the bBox are calculated through the xCoord and yCoord functions, that is, the size of the current Via array is obtained, thereby providing a reference for subsequent replacement operations to ensure that the newly created Via array can correctly fill the space of the original Via array.
[0114] 112-10c: Return the technology database identifier bound to the current layout view (cvId) through the techGetTechFile function, store the technology database identifier in the variable tech to find the Via array definition in the technology database.
[0115] 112-11c: Use the operator ~> to read the cell name of the master bound to the ID of the target via array instance and assign it to the variable cellname; through the techFindViaDefByName function, according to cellName, find the corresponding Via array definition (that is, the via array instance technical definition) in the technology database pointed to by the variable tech, and return the identifier ViaDefId of the Via array definition.
[0116] 112-12c: Use the operator ~> to read the length and width of a single Via in the environment variable params bound to ViaDefId and assign it to the variable w_l, assign the length-to-length spacing of Via in the Via array to the variable space1, assign the width-to-width spacing of Via in the Via array to the variable space2, calculate the integer multiple value of width relative to w_l and assign it to the variable maxrownum, calculate the integer multiple value of length relative to w_l and assign it to the variable maxcolumnum.
[0117] 112-13c: Initialize the variable rows to 1, loop through all the numbers i from 1 to maxrownum through the for function, and calculate the width of the Via array mosaic_width = space2*2+space2*(i-1)+w_l*i. If mosaic_width is less than or equal to width, assign the value of i to the variable rows until the maximum number of Vias that can be placed on width is obtained.
[0118] Similarly, initialize the value of the variable columns to 1, and use the for function to loop through all the numbers i from 1 to maxcolumnum, and calculate the length of the Via array mosaic_length = space1*2+space1*(i-1)+w_l*i. If mosaic_length is less than or equal to length, assign the value of i to the variable columns until the maximum number of Vias that can be placed on length is obtained.
[0119] It can be understood that 112-13c calculates the maximum number of Via arrays to be placed, and obtains the number of rows and columns of the newly created Via array, thereby ensuring that the newly created Via array can effectively utilize space.
[0120] 112-14c: Generate a Via parameter list to store the parameters required to create a new Via array (i.e., via array instance layout parameters). The Via parameter list can include rows, columns, space1, space2, and w_l, etc.
[0121] Among them, rows and columns represent the number of rows and columns of the Via array. The values of rows and columns determine the number of vias arranged in the X and Y directions in the Via array. space1 and space2 represent the horizontal and vertical spacing between vias, which are used to affect the overall density and size of the via array. w_l is the width and length of each via, which determines the size of the via itself and the space occupied by the entire array.
[0122] 112-15c: Delete the old target via array instance from the database through the dbDeleteObject function, here the current Via array is deleted; according to the previously saved point, orient, ViaParams and Via array definition in the technical database, use the dbCreateVia function to create a new via array instance at the location of the deleted target via array instance, ensuring that the new via array instance meets the specified technical requirements and parameter settings.
[0123] Optionally, if the Via array definition corresponding to cellName cannot be found in the technology database pointed to by the variable tech in 112-11c, that is, the via array instance technology definition corresponding to the via array instance name does not exist in the target library, a new via array instance name can be created based on a regular expression, and the via array instance technology definition and via array instance layout parameters can be obtained in the target library according to the new via array instance name.
[0124] It should be noted that the situation where the Via array definition does not exist is usually because some non-standard naming or uncommon Via arrays are used in the design process. In order to find a suitable Via array definition, the metal layer information can be extracted from the cellName through a regular expression to reconstruct a possible Via array name according to the standard naming rules. At this time, the metal layer information can be extracted from the cellName using a regular expression (such as M2_M1 represents the Via array between metal layer 2 and metal layer 1), and the extracted metal layer information can be stored in two variables, such as maxnum (representing a higher metal layer) and minnum (representing a lower metal layer). Based on the extracted metal layer information, a new Via array name can be generated by string concatenation. For example, maxnum=3 and minnum=2 are extracted from M3_M2, and then the Via array name is generated as M3_M2. Next, the new Via array name can be searched again in the technical database. If the array name meets the naming specifications of the technical database, then it is very likely that the corresponding Via array definition can be found in the technical database.
[0125] Specifically, the regular expression string pattern can be compiled through rexCompile, the string cellname can be matched with the rexExecute function, and the substring matching the string pattern, i.e., the high-level number and low-level number of the metal layer, can be extracted with the rexSubstitute function, and assigned to the variables maxnum and minnum respectively, and then the string can be concatenated with the strcat function to generate the "Mmaxnum_Mminnum" format and assigned to the variable cell. In this way, the techFindViaDefByName function can be used to return the identifier ViaDefId of the Via array definition corresponding to the cellName in the specified technology database, and then 112-12c and its subsequent processing can be executed.
[0126] In another embodiment, the instance object in the Layout view can be directly searched through the metal layer information. Accordingly, the processing of step 111 can be as follows: obtain the maximum number of metal layers of all process libraries applied to the Layout view of the target integrated circuit; generate a specific naming string based on the maximum number of metal layers; obtain all via instances in the Layout view of the target integrated circuit whose naming format conforms to the specific naming string; traverse the obtained via instances, and extract the target via instances whose library parameters in the master attributes are not the target library.
[0127] In practice, the above process can be broken down into the following steps:
[0128] 111-1d: Create a new empty list instVia_ids to store the IDs of all instances that meet the conditions.
[0129] 111-2d: Get the maximum number n of metal layers of all process libraries applied to the Layout view of the target integrated circuit.
[0130] 111-3d: Use the for function to traverse all the numbers i from 2 to n, and use the strcat function to concatenate strings to generate a specific named string in the format of "Mi-1_Mi" and assign it to the variable name.
[0131] It can be understood that 2 to n represent vias between specific metal layers, for example, 2 represents M1_M2, i.e., vias between metal layers M1 and M2, 3 represents M2_M3, i.e., vias between metal layers M2 and M3, and so on. Different naming formats can be generated for vias between different metal layers through specific naming strings.
[0132] 111-4d: Use the setof function to filter out instances whose names meet the judgment criteria of the rexMatchp function from all instance lists of the current cellview, and store the IDs of the filtered instances into instVia_ids. The rexMatchp function is used to check whether the instance name contains the string pattern in the name variable (such as "M2_M1*"). If it does, it means that the instance is a via instance.
[0133] 111-5d: Use the foreach function to iterate over the id of each Via (via array instance) in the array_ids list, and use the operator ~> to read the master property value bound to the Via ID.
[0134] 111-6d: Determine whether the library (i.e., library parameter) pointed to by the master is the target library (e.g., tsmcN12, i.e., determine whether the Via array is from the tsmcN12 process library). If not, the Via is a target via instance and needs to be further processed and replaced with the Via in the tsmcN12 process library.
[0135] Based on the above processing of 111-1d to 111-6d, the IDs of all via instances in the current layout that conform to the specific metal layer via naming format can be automatically identified and collected. For the subsequent processing of the target via instance, refer to the processing of steps 112-6b to 112-10b. It is worth mentioning that the processing of steps 111-1d to 111-6d can also be used as a supplementary processing after steps 111-1b to 112-10b, and 111-1c to 112-15c, that is, after traversing and obtaining the ID of each Via in the array_ids list in 111-5d, it can be determined whether the ID exists in the array_ids and Via_ids lists. If not, the processing of 111-6d can be executed again.
[0136] Step 120, configuring the program script file into the Virtuoso software environment.
[0137] When configuring a program script file, you can place the written Skill script file in a directory accessible to the Virtuoso software, and write a command to load the program script file in the .cdsinit file, so that the Virtuoso software can automatically load the program script file when it starts up through the .cdsinit file. The .cdsinit file is the initialization file of the Virtuoso software, which is usually used to configure environment variables, load scripts, and set the default behavior when the software starts up.
[0138] Of course, you can also choose not to modify the startup configuration of the Virtuoso software, but manually load the script file through the command line of the Virtuoso software when needed. This method is more flexible, but it requires manual loading after each startup, which may not be suitable for frequently used automated scripts.
[0139] Step 130: When the Virtuoso software is started, the program script file is automatically loaded.
[0140] After configuring the script files, Virtuoso can automatically load these scripts each time it starts. Of course, you can also choose to delay the loading of scripts, that is, load and execute script files only under certain conditions, which can reduce the startup time and reduce resource usage.
[0141] Step 140 , in response to the calling request of the program script file, extract and replace the reference content of the instance of the target integrated circuit in the Layout view.
[0142] The Layout view is a representation of the physical design of the integrated circuit, which is used to display the geometry of each device and interconnection on the chip, including metal layers, contact holes (Via), silicon layers, gates, etc. Instance is the basic building block in the Layout view, representing a physical copy of a cell in the physical design. Different instances can reference the same or different master cellviews, and can be placed in different locations or use different parameters (such as size, direction, etc.).
[0143] When the user performs a predetermined operation in the Virtuoso software (such as clicking a menu item or entering a command) to trigger a call request for the program script file, the program script file will be called, so that it can access the design database, extract all instances in the Layout view of the target integrated circuit, and replace the reference content of the instances that require master adjustment. After that, the program script file can display the instance after the reference content is replaced in the Layout view.
[0144] Specifically, for the instance of the cellview that needs to be replaced by the master, the Layout view can be opened in the edit mode. The user types the main function change_inst_library("namelist" "libname") in the CIW window, and fills in the custom variables in the brackets, that is, the preset keywords and the name of the target library. After the program script file is run, the user can see the modified instance in the Layout view; for the Via of the cellview that needs to be replaced by the master, the Layout view can be opened in the edit mode. The user types the main function change_Via_library() in the CIW window. The custom variables do not need to be filled in the brackets. After the program script file is run, the user can see the modified Via in the Layout view.
[0145] In this embodiment, a skill program is used to write a program script file, and then the program script file is configured in the Virtuoso software environment, so that the program script file is automatically loaded when the Virtuoso software is started, so that the program script file can respond to the call request, automatically extract and replace the reference content of the instance in the Layout view of the target integrated circuit. In this way, compared with the traditional manual operation method, the automated script traverses the instance objects in the layout view, and screens out the instances that need to be replaced based on preset standards, and then automatically replaces the reference content of the instance objects. Designers do not need to manually perform complex reference replacement operations, thereby reducing the risk of errors in human operations, saving a lot of time and energy, and significantly improving the design efficiency of integrated circuits.
[0146] The technical features of the above embodiments may be combined arbitrarily. To make the description concise, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.
[0147] The above-described embodiments only express several implementation methods of the present application, and the descriptions thereof are relatively specific and detailed, but they cannot be understood as limiting the scope of the present application. It should be pointed out that, for a person of ordinary skill in the art, several variations and improvements can be made without departing from the concept of the present application, and these all belong to the protection scope of the present application. Therefore, the protection scope of the present application shall be subject to the attached claims.
Claims
1. A method for designing an integrated circuit example based on Virtuoso, characterized in that: The method comprises: Using the Skill program interface of the Virtuoso software, a program script file is written according to predetermined execution steps, and the program script file is configured in the Virtuoso software environment. When the Virtuoso software is started, the program script file is automatically loaded, and in response to a call request of the program script file, the reference content of the instance of the target integrated circuit in the Layout view is extracted and replaced; The predetermined execution steps implemented by writing the program script file include: Traversing the instance objects in the Layout view of the target integrated circuit, and extracting the target instance objects that meet the preset replacement criteria; The target instance object is replaced with an instance object whose reference content points to a unit view in the target library; The traversing of the instance objects in the Layout view of the target integrated circuit to extract the target instance objects that meet the preset replacement criteria includes: Obtaining the maximum number of metal layers of all process libraries applied to the Layout view of the target integrated circuit; generating a specific naming string according to the maximum number of metal layers; Acquire, in a Layout view of the target integrated circuit, all via instances whose naming format conforms to the specific naming string; The obtained via instances are traversed to extract target via instances whose library parameters in the master attribute are not target libraries.
2. The method according to claim 1, characterized in that The traversing the instance objects in the Layout view of the target integrated circuit to extract the target instance objects that meet the preset replacement criteria includes: For each preset keyword, the instance objects in the Layout view of the target integrated circuit are traversed to extract the target instance objects whose instance names contain the preset keyword.
3. The method according to claim 2, characterized in that The step of replacing the target instance object with an instance object whose reference content points to a unit view in a preset library includes: Acquire attribute information of the target instance object, wherein the attribute information at least includes a reference unit name, a target library name, and a reference view name; A target unit view is selected in the target library according to the attribute information, and the master attribute of the target instance object is replaced with the identification information of the target unit view.
4. The method according to claim 1, characterized in that The traversing the instance objects in the Layout view of the target integrated circuit to extract the target instance objects that meet the preset replacement criteria includes: Obtain all via instances within a coordinate range of a Layout view of the target integrated circuit; The obtained via instances are traversed to extract target via instances whose library parameters in the master attribute are not target libraries.
5. The method according to claim 4, characterized in that The step of replacing the target instance object with an instance object whose reference content points to a unit view in a preset library includes: Acquire attribute information of the target via instance, wherein the attribute information includes at least a via instance name, a via instance position and direction, and a via instance coverage parameter; Obtaining a via instance technical definition in a target library according to the via instance name; The target via instance is deleted, and a new via instance is created according to the via instance position and direction, the via instance coverage parameters, and the via instance technology definition.
6. The method according to claim 1, characterized in that The traversing the instance objects in the Layout view of the target integrated circuit to extract the target instance objects that meet the preset replacement criteria includes: Obtain all via array instances according to the number of metal layers included in the Layout view of the target integrated circuit; The obtained via array instances are traversed to extract target via array instances whose library parameters in the master attribute are not target libraries.
7. The method according to claim 6, characterized in that Get all via array instances according to the number of metal layers contained in the Layout view of the target integrated circuit, including: Obtaining the maximum number of metal layers of all process libraries applied to the Layout view of the target integrated circuit; generating a specific naming string according to the number of metal layers; All via array instances whose naming format conforms to the specific naming string are obtained in the Layout view of the target integrated circuit.
8. The method according to claim 6, characterized in that The step of replacing the target instance object with an instance object whose reference content points to a unit view in a preset library includes: Acquire attribute information of the target via array instance, wherein the attribute information at least includes a via array instance name, a via array instance position and a direction; Obtaining a via array instance technical definition and via array instance layout parameters in a target library according to the via array instance name; The target via array instance is deleted, and a new via array instance is created according to the via array instance position and direction, via array instance layout parameters, and the via array instance technology definition.
9. The method according to claim 8, characterized in that The method further comprises: If the via array instance technical definition corresponding to the via array instance name does not exist in the target library, a new via array instance name is created based on a regular expression, and the via array instance technical definition and via array instance layout parameters are obtained in the target library according to the new via array instance name.
