Pixel-based rule checking for layouts
The pixel-based method for rule checking on layouts with curved edges addresses the inefficiencies of traditional contour-based methods by using parallel processing threads and SIMD computations, enhancing the efficiency and accuracy of mask rule checks for curved shapes.
Patent Information
- Application Number
- JP2026524635
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2024-10-21
- Filing Date
- 2024-10-22
- Publication Date
- 2026-11-19
AI Technical Summary
Performing mask rule checks on layouts with curved shapes is a complex and time-consuming task, especially as semiconductor manufacturing shifts towards curved masks, as traditional contour-based methods become inefficient and require extensive conversion to the pixel domain.
A pixel-based method for rule checking that utilizes multiple processing threads to perform checks on individual pixels along the boundary contours of shapes, especially those with curved edges, using rasterization to generate pixel definitions and SIMD computations for efficient parallel processing, eliminating the need for pre-defining and storing edges.
This approach significantly reduces execution time and maintains accuracy by performing rule checks directly in the pixel domain, optimizing the mask drawing process and ensuring compliance with design and manufacturing rules for curved shapes.
Smart Images

Figure 2026539048000001_ABST
Abstract
Description
Background Art
[0001] Photolithography is commonly used for manufacturing integrated circuits on semiconductors. Photolithography is a printing process that uses a lithography mask or photomask fabricated from a reticle to form a pattern on a substrate (e.g., a semiconductor or a silicon wafer) to create an integrated circuit (IC). Extreme ultraviolet (EUV) or X-ray lithography is considered a type of photolithography.
[0002] One reticle or a plurality of reticles may include circuit patterns corresponding to individual layers of an integrated circuit, and these patterns may be imaged onto specific regions on a substrate coated with a layer of radiation-sensitive material known as photoresist or resist. Once the patterned layer is created, the layer may undergo various other processes such as etching, ion implantation (doping), metallization, oxidation, and polishing. These processes are used to finish individual layers in the substrate. If several layers are required, this process is repeated layer by layer. Through such processes, a plurality of integrated circuits may be defined on the wafer substrate. The wafer may then be diced to obtain individual IC dies. Each IC die may then be mounted in an individual chip package.
[0003] In the production or manufacture of semiconductor devices such as integrated circuits, maskless direct writing processes may also be used to fabricate semiconductor devices. Maskless direct writing is a printing process that uses charged particle beam lithography to form patterns on a substrate, such as a semiconductor or silicon wafer, to create integrated circuits. The desired pattern of a layer is directly drawn onto the surface (in this case, the surface is also the substrate). Once the patterned layer is created, the layer can undergo various other processes such as etching, ion implantation (doping), metallization, oxidation, and polishing. These other processes are used to finish individual layers on the substrate. If several layers are required, the entire process is repeated for each new layer. Through such a process, multiple integrated circuits can be defined on the wafer substrate. The wafer substrate can then be cut to obtain individual IC dies that are mounted in individual chip packages. Some manufacturing processes use photolithography for some IC layers while using maskless direct writing for others.
[0004] In optical lithography, the lithography mask contains numerous geometric patterns (shapes) corresponding to circuit components defined on a semiconductor substrate. The mask pattern is based on design component and wiring shapes generated by EDA (electronic design automation) software. When designing these shapes, the EDA program typically follows a predetermined set of design rules.
[0005] These rules are set by processing, design, and end-use constraints. One example of an end-use constraint is defining transistor geometry to ensure reliable operation at the required supply voltage. Design rules may also define acceptable spacing between circuit devices or interconnect lines to prevent them from interacting with each other in undesirable ways (such as being too close to each other to cause a short circuit). Design rule constraints also reflect, among other things, the minimum dimensions that can be reliably manufactured. When referring to these small dimensions, the concept of limit dimensions is usually introduced. Limit dimensions are defined, for example, as a critical width or area of a feature, a critical distance or critical distance area between two features, and these dimensions require careful control.
[0006] As described above, photolithography manufactures circuit designs on a substrate by exposing a reticle (also called a mask or photomask) with charged particle beam lithography. As the critical dimensions of the circuit pattern become smaller and approach the resolution value of the exposure tool, it becomes difficult to accurately transfer the physical design generated by the EDA tool to the actual circuit pattern developed on the resist layer.
[0007] To facilitate the use of optical lithography to form patterns with features smaller than the wavelength of light used in the optical lithography process, a process known as optical proximity correction (OPC) has been developed. OPC modifies the physical design to compensate for distortions caused by effects such as optical diffraction and optical interactions between features with adjacent features. Resolution enhancement technologies (RET) performed using reticles include OPC and inverse lithography technology (ILT). OPC can reduce the difference between the original physical design pattern, i.e., the design, and the circuit pattern ultimately created on the substrate by adding sub-resolution lithographic features to the mask pattern.
[0008] Sub-resolution lithography features interact with and compensate for proximity effects in the original pattern in the physical design, improving the final circuit pattern. A feature added to improve pattern formation is called a "serif." A serif is a small feature that increases accuracy or resilience to manufacturing variations in the printing of a particular feature. An example of a serif is a small feature placed at the corners of a pattern to make the corners stand out in the final image. The pattern intended to be printed on the substrate is called the main feature.
[0009] Traditionally, OPC-decorated patterns drawn on a reticle are discussed in terms of main features (i.e., features that reflect the design before OPC decoration) and OPC features (OPC features may include serifs, jogs, sub-resolution assist features (SRAFs), and negative features). SRAFs are isolated shapes not attached to the main features and are too small to be printed on the substrate, while serifs, jogs, and negative features modify the main features. OPC features follow various design rules, such as rules based on the size of the smallest features that can be created on the wafer using photolithography. Other design rules may originate from the mask manufacturing process or, if patterns are formed on the reticle using a partially burst-exposure charged particle beam lithography system, from the stencil manufacturing process.
[0010] Photomasks at state-of-the-art nodes are becoming increasingly curvilinear. Traditionally, target mask shapes have been described as "Manhattan" geometry with orthogonal edges or, in some cases, 45-degree edges. The advent of multibeam masking has made curved mask target shapes possible. OPC and ILT can better optimize resilience to wafer manufacturing variability for curved shapes than for Manhattan shapes. Manufacturable target shapes on masks are more resilient to mask manufacturing variability. In both mask manufacturing and subsequent wafer manufacturing using those masks, the masks are less affected by mask manufacturing variability, and the resulting wafer patterns are also less affected by wafer manufacturing variability. For this reason, semiconductor manufacturing at state-of-the-art nodes is shifting towards curved masks.
[0011] Mask rule check (MRC) is a crucial step in the mask drawing process. After OPC and mask process correction (MPC), the data is ready to be supplied to the mask drawing machine. However, the data needs to be checked for compliance with several specific "mask rules." These rules essentially define the contract between the OPC shop and the mask shop, namely, that "if the OPC shop provides mask geometry in accordance with the agreed-upon mask rules, the mask shop will accurately transfer this geometry onto the semiconductor mask." MRC rules, for example, specify the minimum area, width, and spacing of the shape. Performing such checks on mask designs with curved shapes is no trivial matter. [Overview of the Initiative] [Means for solving the problem]
[0012] Several embodiments provide a method for performing pixel-based rule checking on layouts used in the process of designing or manufacturing integrated circuits (ICs). This pixel-based method provides an optimal technique for performing rule checking on layouts having shapes (e.g., patterns, interconnects, vias, etc.) with curved contours (i.e., curved edges). In some embodiments, the method performs optimal pixel-level rule checking on curved edges where one or more pixels reside. In some embodiments, the layout is a mask layout used to manufacture the IC, while in other embodiments, the layout is a design layout used to design the IC (e.g., a layout used during the physical design process). Further embodiments of the method are used to perform pixel-based rule checking on design layouts or mask layouts created to design and manufacture other patterns on other types of substrates, such as flat panel displays (e.g., monitors, televisions, glasses, etc.), curved displays (e.g., displays for virtual or augmented reality headsets), silicon interposers, and micro-electromechanical systems (MEMS).
[0013] In some embodiments, this method performs a rasterization operation to generate pixel-based definitions of shapes in a layout from contour-based definitions used to define shapes in the layout. In other embodiments, rasterization is not required because the layout shapes are already defined in the pixel domain (e.g., by an ILT-based OPC tool). In some embodiments, this method assigns some pixels (e.g., some pixels at any location in the layout or some pixels that exist along one or more edges of one or more shapes in the layout) to different processing threads of one or more processing units.
[0014] This method performs rule checks on specific pixels using a specific processing thread assigned to each specific pixel. For example, in some embodiments, this method determines whether a particular pixel lies on an edge that is within a threshold distance of another edge. Then, for each specific edge identified as being within the threshold distance of each pixel's edge, this method determines whether the identified specific edge violates a rule check.
[0015] In some embodiments, the threshold distance is a threshold distance that defines a search area (e.g., a search window) for searching for nearby edges. Rule checks, in some of these embodiments, include spacing checks and / or width checks. Spacing checks ensure that no two edges of two nearby shapes are closer than a threshold spacing distance. In such a check, the edges identified by the processing thread are edges of a different shape from the shape of the pixel to which the processing thread was assigned. Width checks, on the other hand, ensure that no two edges of a single shape are closer than a threshold width distance. Thus, in a width check, the edges identified by the processing thread are edges of the same shape as the pixel to which the thread was assigned.
[0016] In some embodiments, several different processing threads assigned to several different pixels are executed simultaneously on one computer or several different processing units on several computers. In some embodiments, the different processing units are different cores of one or more processors, such as a central processing unit (CPU), a graphics processing unit (GPU), and a tensor processing unit (TPU). The different processing threads are, in some embodiments, similar threads that perform a single-instruction multiple data (SIMD) computation technique for their assigned pixels. SIMD computation is an optimal computation technique for parallel processing of a single instruction across multiple datasets. GPUs and TPUs are often used for such parallel processing of SIMD computations.
[0017] Each processing thread, for its assigned pixel, (1) receives a pixel-based definition of the shape, (2) parses the pixel-based definition to generate edges within a first threshold distance (specified by, for example, the search window) of the given pixel, and (3) examines each generated edge to determine whether it violates the MRC rules. In these operations, each processing thread dynamically generates edge data and stores it in the volatile runtime memory (e.g., RAM) of the computer in its processing unit. This edge data is then discarded from volatile memory after the thread has completed its operation on that pixel.
[0018] In some embodiments, this method examines each generated edge to determine whether the generated edge is within a second threshold distance of a particular pixel or the edge on which the particular pixel resides. In some embodiments, a processing thread for a particular pixel needs to generate not only nearby edges on which nearby pixels reside, but also edges on which the particular pixel resides. To generate edges, each pixel processing thread, in some embodiments, first generates a piecewise linear version of the edge, and then, through a curve fitting operation, transforms the piecewise linear edge into another edge which may be a curved edge with one or more curved (e.g., curved) segments.
[0019] When converting a shape contour definition to a pixel definition, the rasterization operation, in some embodiments, generates an image containing a large number of pixels. Each pixel in the generated image has a pixel value assigned to it by the rasterization operation. The pixel values are classified into three categories (also referred to below as types): (1) a first category of pixel values indicating that the pixel is entirely within the shape; (2) a second category of pixel values indicating that the pixel is entirely outside any shape; and (3) a third category of pixel values for pixels along the edges of the shape.
[0020] In some embodiments, the third category of pixel values is decimal values, and the first and second categories of pixel values are values of 1 and 0, respectively. In other embodiments, the pixel values are values in the range of values greater than and less than a threshold. In some of these embodiments, values less than the threshold are values related to pixels outside of any shape, the threshold is a value along the boundary of the shape, and values greater than the threshold are values for pixels within the shape.
[0021] In some embodiments, each specific processing thread generates edges for its particular pixel by performing an edge detection and drawing process, which (1) identifies a third type of pixel value within the search window and (2) generates edges connecting adjacent identified third type pixel values. In some embodiments, the edge detection and drawing process is a marching-square (MS) process. The generated edges may be piecewise linear (PWL) edges or curved edges formed by one or more straight edges. In the former case, each straight edge may, in some embodiments, be defined by a linear segment that can be defined by referring to a linear polynomial such as y = mx + b, where x and y are coordinates along the line, m is the slope, and b is the y-intercept. In some embodiments, each curved edge may also be defined by referring to one of several common methods for defining curves, such as a polynomial of degree two or higher, a Bézier function, or a spline function (B-spline function).
[0022] In some embodiments, a particular processing thread examines each edge it generates (e.g., each PWL or curved edge) to determine whether it needs to be modified (e.g., modifying a generated straight or curved edge to become a more accurate curved edge or a more accurate PWL edge) in order to more accurately cover the area that matches the pixel values assigned (by the rasterization operation) to the area the edge traverses. If the thread determines that it needs to modify the generated edge, in some embodiments, the thread uses the edge to generate a new temporary PWL or curved edge with the desired coverage area, and then uses this newly generated edge to perform rule checks applied by the thread (e.g., performing its spacing rule check or width spacing rule check).
[0023] Other embodiments perform pixel-based rule checks on layouts (e.g., IC design or manufacturing layouts) in a manner different from some of the above-described approaches. For example, for a region composed of pixels of a layout, the pixel-based rule checking process of some embodiments (1) causes several processing threads to dynamically generate local edges for different pixels in the region of the layout, (2) stores these edges in a memory shared between the processing threads (e.g., a volatile runtime memory such as RAM), and then (3) performs pixel-based rule checks for different pixels in the region using the dynamically generated edges. In some of these embodiments, the pixel-based rule check verifies spacing rules between non-edge pixels (i.e., pixels that do not lie on the edges of objects in the layout) and edge pixels (i.e., pixels that lie on the edges of objects in the layout).
[0024] The above summary is intended to serve as a brief introduction to some embodiments of the present invention. The above summary is not intended to serve as an introduction or overview of all inventive subject matter disclosed in this specification. The following detailed description and the drawings referenced in the detailed description further explain the embodiments described in the summary and other embodiments. Therefore, to understand all the embodiments described in this specification, the summary, detailed description, drawings, and claims must be thoroughly reviewed. Furthermore, the subject matter recited in the claims is not limited by the illustrative details of the summary, detailed description, and drawings.
[0025] The novel features of the present invention are set forth in the appended claims. However, for illustrative purposes, several embodiments of the present invention are shown in the following drawings. [Brief Description of the Drawings]
[0026] [Figure 1] An example of a layout having several curved shapes is shown. [Figure 2]Shows examples of two types of rules that are checked as part of DRC or MRC in many cases. [Figure 3] Shows the spacing distance between two nearby shapes with curved edges where the edges curve toward and away from each other. [Figure 4] Shows an example of a curved edge that is converted into a pixel dose map by rasterization. [Figure 5] Shows a process for efficiently performing rule checks on layout shapes with curved boundary contours, as used in some embodiments. [Figure 6] Shows an example of the output of a rasterization operation for two of the shapes in Figure 1. [Figure 7] Presents a block diagram conceptually illustrating several modules that perform the operations of the process. [Figure 8] Shows an example of a search window centered on a pixel on the right boundary of a shape. [Figure 9] Shows the process performed by a pixel processing thread. [Figure 10] Shows an example of a method by which some embodiments implement a marching squares process to dynamically generate edges for pixels within a search window. [Figure 11] Shows an example of a method by which some embodiments implement a marching squares process to dynamically generate edges for pixels within a search window. [Figure 12] Shows an example of a method by which some embodiments implement a marching squares process to dynamically generate edges for pixels within a search window. [Figure 13] Shows an example of an implicit edge generated for a corner of a shape within a search window. [Figure 14] Shows the process performed by a pixel processing thread to dynamically generate a local edge traversing the pixel when the assigned pixel of the pixel processing thread lies on the contour boundary of a shape in the layout. [Figure 15]This shows the rule-checking process that a thread performs on the MSG pixels assigned to it. [Figure 16] This shows the interval rule check performed on MSG pixels. [Figure 17] The process of manually or automatically correcting and flagging the shape of pixels associated with a violation is shown in several embodiments. [Figure 18] The process of automatic correction and automatic correction of flagged shapes is shown in several embodiments. [Figure 19] This shows an example of automatically correcting shapes that violate the minimum width rule. [Figure 20] This example shows how to automatically correct shapes that violate the minimum spacing rule. [Figure 21] The process for designing and manufacturing ICs is shown according to several embodiments. [Figure 22] This conceptually illustrates an electronic system in which several embodiments are implemented. [Modes for carrying out the invention]
[0027] The following detailed description of the present invention includes numerous details, examples, and embodiments. However, it will be obvious to those skilled in the art that the present invention is not limited to the embodiments described and that it can be carried out without some of the specific details and examples discussed.
[0028] Some embodiments provide a method for performing pixel-based rule checking on layouts used in the process of designing or manufacturing integrated circuits. The pixel-based method in some embodiments uses multiple processing threads running simultaneously on multiple processing units to perform rule checking on individual pixels present along the boundary contours of shapes (e.g., patterns, interconnects, vias, etc.) in the layout. This pixel-based method provides an optimal technique for performing rule checking on layouts having shapes with curved contours. In some embodiments, the method performs optimal pixel-level rule checking on curved edges where one or more pixels reside. In some embodiments, the layout is a mask layout, the shape of the mask layout is a mask pattern shape, and the rule check is a mask rule check (MRC). In other embodiments, the layout is a design layout, the shape of the design layout is an IC component shape for IC design, and the rule check is a design rule check (DRC).
[0029] Figure 1 shows an example of a layout 100 having several curved shapes 105. Each of these shapes has a curved contour. Although not shown, the layout shapes may, in some embodiments, include shapes having only PWL edges (also called straight edges or edges composed of straight lines), shapes having only curved edges, and shapes having both PWL edges and curved edges. In some embodiments, layout 100 is a mask layout, and shape 105 is a mask pattern shape representing transparent portions (also called holes or transparent areas) of a mask through which light can pass. Such a mask layout is used to manufacture a mask, which is then used to manufacture an IC by a lithography process. In other embodiments, layout 100 is a design layout, and shape 105 are circuit components (e.g., transistor gates, etc.) and interconnects (e.g., wiring and vias) in the design layout. In some embodiments, the design layout is a design layout after the physical design stage (e.g., after routing or compaction).
[0030] In some embodiments, the mask layout has an overall mask image for each device or wiring layer. The overall mask image for each layer can be broken down into several individual mask images by using a coloring technique, for example, assigning one of several different colors to each shape in the overall mask image, and then assigning the shapes to individual mask images of that color. Each mask image for each layer can be used to generate masks that can be used later to fabricate the components of that layer. The design layout, in some embodiments, has a layout for each device layer and each wiring layer, and the layout for each design / wiring layer includes the shapes of the components defined in that layer.
[0031] Figure 2 shows examples of two types of rules that are often checked as part of the DRC or MRC. These rules are a width rule that specifies a minimum width of 205 for a shape (e.g., a component or mask pattern) and a spacing rule that specifies a minimum spacing of 210 between two shapes (e.g., two components or mask patterns). Examples of other types of rules that are checked by some embodiments include (1) a minimum encirclement spacing rule that specifies the minimum overlapping distance between one object (e.g., one metal contact on one layer) and another object (e.g., another metal object on another layer), (2) a minimum area rule that specifies the minimum area for a shape in a layout, and (3) a maximum local edge curvature rule that specifies the maximum allowable curvature for the contour of a shape in a layout.
[0032] Checking these rules becomes more complex when the shapes in the layout have curved edges. For example, Figure 3 shows the distance between two nearby shapes having curved edges 305 and 310 such that the edges curve toward and away from each other. To determine the distance between the curved edges, the rule checker needs to determine the radius of the largest circle 315 that can have a center extending along one edge and not touch the other edge. If such an operation needs to be performed for each curved shape in the layout being checked, it can be quite time-consuming.
[0033] Semiconductor manufacturing at the most advanced nodes is rapidly shifting to curved masks. In strict Manhattan designs, calculations using rectangles and, in some cases, triangles are acceptable and better for CPU-based calculations. However, in the case of curved designs where at least some parts of the design involve curved shapes, some embodiments use pixel-based calculations with sufficient pixel resolution because pixel-based calculations are better, especially for single-instruction multiple-data (SIMD) calculations such as those performed by GPUs.
[0034] When some parts of the design and verification flow are contour-based and others are pixel-based, some embodiments use rasterization and contour extraction operations to transition between contour-based and pixel-based definitions. In some embodiments of the present invention, Figure 4 shows an example of a curved edge 405 that is converted to a pixel dose map 410 by rasterization. This is an example of a raster tone map (RTM), in which the pixel data created by rasterization has three types of pixels: outer pixels with a value of 0, inner pixels with a value of 1, and edge pixels with a value greater than 0 and less than 1.
[0035] In some embodiments, edge pixels correspond to regions in the original geometry data that have edges, and the dose value in any one edge pixel directly represents the area of the pixel covered by the passing edge (for example, 0.9 if the edge occupies 0.9 (90%) of the pixel). The accuracy of rasterization depends on the pixel size used to sample the geometry so that the pixel value, i.e., the dose, indicates the normalized area of the geometry data that overlaps with the corresponding pixel region. As shown in Figure 4, contour extraction is the reverse process of rasterization. Contour extraction reconstructs the geometry data from pixels.
[0036] Instead of RTM, other embodiments use a continuous tone map (CTM) or a quantized tone map (QTM). In such tone maps, pixel values are in a range that starts below a threshold and ends above a threshold. In CTMs or QTMs, the data typically varies more gradually between pixels than in rasterized data. Also, in some embodiments of CTMs or QTMs, pixels with values below a threshold are outer pixels, pixels with values above a threshold are inner pixels, and pixels with values at or near the threshold are edge pixels. CTM and QTM values are often used when the source of the pixel data is computational lithography. QTM values are quantized two-dimensional values of a continuous function, and the pixel values do not directly encode the area coverage.
[0037] Because both rasterization and contour extraction operations are computationally intensive, some embodiments remain in the pixel-based computation domain for efficiency. For example, in some embodiments, pixel-based MRC verification is performed as part of OPC / ILT or in Mask Process Correction (MPC), and this verification is performed entirely in the pixel domain to eliminate the need for conversion to and from the contour domain.
[0038] MRC has several rules that have evolved into very specific "corner cases" that are important for legacy mask lithography systems but probably not for modern mask lithography systems. Adjusting the rules for modern machines becomes easier as the data processing paradigm shifts to a pixel-centric model in some embodiments. State-of-the-art IC mask production requires the use of multi-beam mask lithography systems that operate on a pixel-by-pixel basis. One example of a multi-beam mask lithography system for a state-of-the-art node uses hundreds of thousands of electron beams operating in parallel, each beam corresponding to a dose value for a particular pixel.
[0039] Older generations of mask lithography systems used a single beam with a variable-shape aperture. These older machines, called VSB mask lithography systems, did not operate on a pixel-by-pixel basis. Mask geometry processing methods developed over the past 30 years or so have been adapted to the operation of these older machines. Furthermore, the vocabulary used to express mask rules is also suited to these older machines. Other machines used lasers to expose the resist coated on the mask. Some laser lithography systems are also multi-beam machines.
[0040] In contrast, the operating principle of multibeam machines is that raster data ("pixels") uniquely determine the shape to be drawn on the mask. Therefore, some embodiments use pixel-based MRC on masks drawn using modern multibeam machines, instead of contour-based conventional MRC techniques. Pixel-centric MRC can be implemented in a natural way within the multibeam machine dataflow. Some multibeam machines are integrated with very powerful GPU-based supercomputers, on which many pixel-based algorithms can be implemented at speeds one to three orders of magnitude faster than any known equivalent algorithm defined in the contour domain. The dataflow within a multibeam machine is, naturally, represented as pixels. By using the pixel-based MRC methods of some embodiments, the need for round-trip conversion from edge-based representations to pixels in current MRC techniques is avoided. Since operation in the contour domain introduces non-uniformity into the dataflow, and therefore makes the dataflow more complex and slower, the pixel-based MRC methods of some embodiments are also faster and more efficient.
[0041] The mask drawing process begins when the mask design data passes the MRC. The photoresist is deposited onto a specially prepared substrate called a mask blank. This photoresist is a material sensitive to an energy source, typically an electron beam (e-beam) at the cutting edge node. Next, a multi-beam machine irradiates the photoresist with several parallel electron beams (called beamlets). Each beam can have a different electron density; some beams are set to high values, while others are completely blocked, for example, so that only negligible electron charges are delivered to certain locations. Patterning is performed as follows: The photoresist, exposed to electrons, undergoes some chemical reaction that alters its physical and chemical properties. Exposed and unexposed areas of the photoresist react differently to certain special developers and etchants that are later applied. While there are several variations of the photoresist and development processes, the creation of patterns on the mask relies on these different reaction methods. The electron beams determine the shapes created on the mask. These shapes are determined by the pixel values used by the machine to set the dose values of the electron beamlets. Under conventional methods, contour data delivered to the machine was converted into a raster image (i.e., rasterized) before being used internally to draw a mask. Under the new method, pixel information is used directly, and this more direct approach has the potential to streamline the mask drawing process.
[0042] In summary, performing mask rule checks in the pixel domain is beneficial because the execution time for mask rule checks in the pixel domain does not increase exponentially, as it does when the number of vertices increases in polygonal operations. Since masks (especially masks with curved shapes) are often drawn using multi-beam mask lithography systems, it is possible to perform rule checks in the pixel domain without losing theoretical precision or accuracy. Multi-beam mask lithography systems often have a fixed aperture size. Therefore, there are known resolution limits to the method of drawing the mask. Since inspection, repair, and measurement often involve viewing data using images composed of pixels, the data ultimately needs to be in the pixel domain. Regardless of the input shape, no matter how fine-grained the data may be, and even if circles are described with vertices spaced 1 nm or 10 nm apart, the shapes that can be projected onto the physical mask are limited by the bandwidth determined by the pixel size of the multi-beam lithography system. Pixel domain operation naturally takes this into account, and any unnecessary precision lost in the mask drawing process is ignored anyway.
[0043] Figure 5 shows a process 500 for efficiently performing rule checking on layout shapes with curved boundary contours (also called curved boundary edges), as used in several embodiments. Process 500 uses a pixel-based method in which multiple processing threads running simultaneously on multiple processing units perform rule checking on individual pixels in the layout. In some embodiments, process 500 is performed only on pixels that exist along the boundary contours of the shape (which may be formed by PWL edges and / or curved edges), while in other embodiments, process 500 inspects every pixel in the layout. The pixel-based method in Figure 5 is particularly well-suited for shapes with curved contours because it does not require pre-defining and storing edges along these contours on disk, as will be detailed later.
[0044] As shown in the figure, process 500 begins when it receives a layout having several shapes (in 505). In some embodiments, the layout is a mask layout, the shape of the mask layout is a mask pattern shape, and the rule check is a mask rule check (MRC). In other embodiments, the layout is a design layout, the shape of the design layout is an IC component shape for IC design, and the rule check is a design rule check (DRC). Figure 1 above presents a layout 100 having several shapes 105 with curved boundaries. In some embodiments, the received layout is defined in the pixel domain (e.g., the layout is the output of an ILT-based OPC tool), while in other embodiments, the received layout is defined in the contour domain (i.e., each shape is defined by referring to the geometric definition of the shape's boundary contour).
[0045] If the received layout is defined in contour domains, process 500 (in 510) performs a rasterization operation to generate pixel-based definitions of shapes in the received layout from contour-based definitions used to define shapes in the layout. The rasterization operation generates a pixel-based image representing the received layout. Each pixel in the generated image has a pixel value assigned to each pixel by the rasterization operation. In some embodiments, rasterization generates pixel values that fall into one of three categories (hereinafter also called types): (1) a first category of pixel values indicating that a pixel is entirely within a shape, (2) a second category of pixel values indicating that a pixel is entirely outside any shape, and (3) a third category of pixel values for pixels along the edges of a shape.
[0046] In some embodiments, a first category of pixel values corresponding to pixels that are completely within a shape is assigned a value of 1, while a second category of pixel values corresponding to pixels completely outside of any shape is assigned a value of 0. In these embodiments, pixels in each third category along the boundary of a shape are assigned a decimal value between 0 and 1 based on the extent to which the pixel is covered by the boundary edge. These first, second, and third category values are called pixel dose values because they relate to the extent to which a pixel is covered by a shape. The pixel dose is 1 if the pixel is completely covered by a shape, 0 if the pixel is not covered by any shape, and ranges from 0 to 1 based on the percentage to which the pixel is covered by a shape (i.e., the boundary of the shape). As described above and will be detailed later, in other embodiments, the pixel values are based on CTM or QTM values, ranging from below a threshold to above a threshold.
[0047] Figure 6 shows an example of the output of a rasterization operation on two shapes 105a and 105b of the shape in Figure 1. The result of the rasterization is 605 square pixels, to which these pixels are assigned 0, 1, or decimal values. For the purpose of relating these values to the two shapes, the contours of the two shapes 105a and 105b are drawn as dashed lines on the pixel grid array 610 that defines the pixels 605. However, the contours of these shapes are not explicitly defined by the geometric definition in the image file. Rather, these contours are only identifiable through a series of decimal pixel values that form a boundary encompassing a series of pixel values equal to 1. Pixels not covered by either shape (i.e., pixels located outside the boundary-defining pixels) are assigned 0, indicating that no shape exists at these pixel locations.
[0048] In 515, process 500 selects the boundaries of a shape in the layout for which one or more rule checks should be performed. In some embodiments, process 500 selects these boundaries by identifying a region of consecutive values of 1 that has a boundary of 1 or a decimal pixel value surrounded by a region of consecutive values of 0. In Figure 6 and the examples described later, it is assumed that process 500 first selects the boundary of the pixel values defined for shape 105a in Figure 1. As shown in Figure 6, most of the boundary pixel values have decimal values between 0 and 1, with few having a value of 1.
[0049] Figure 7 presents a block diagram conceptually illustrating several modules that perform the operation of process 500. These modules include a rasterizer 705, a raster image generator 707, a boundary selector 710, a pixel-thread assigner 715, and several rule-checking threads 720. As shown in the figure, the rasterizer 705 generates a pixel-based image 704 for a layout 702 defined in the contour domain. The raster image generator 707, on the other hand, natively defines the pixel image layout 704 in the pixel domain. One example of a raster image generator is an ILT-based OPC tool that defines a mask layout in the pixel domain. The pixel-defined layout is stored in the pixel-based image store 717. From the pixel-based image 704, the boundary selector 710 iteratively selects the boundaries of each layout shape for rule checking and selects several pixels on each selected boundary for the pixel-thread assigner 715, which will be discussed later.
[0050] After selecting the boundary of a shape for rule checking, process 500 assigns several pixels that exist along the selected boundary (in 520) to several different rule checking processing threads that run simultaneously on several processing units. In some embodiments, the different processing units are different processing cores of one or more multi-core processors (for example, a single computer on which process 500 runs or a multicomputer on which different rule checking processing threads run).
[0051] In some embodiments, the pixel-thread assignment operation (in 520) is performed by the pixel-thread assigner 715 in Figure 7, which, after receiving different pixels to process, selects different rule-checking threads 720 for each different pixel and instructs each thread to process its assigned pixel (for example, by providing the pixel coordinates to the thread). In some embodiments, the pixel-based rule-checking operation and threads 720 of process 500 are not performed only on boundary pixels that exist along the outer boundaries of shapes in the layout. These embodiments perform the pixel-based rule-checking operation on all pixels in the layout. Therefore, these embodiments do not perform the boundary selection operation 515 and also do not have a boundary selector 710. As shown by the dashed lines in Figure 7, the pixel-thread assigner 715 directly selects each pixel in the layout from the pixel-based image store 717.
[0052] Each pixel check thread 720 performs one or more sets of rule checks on the pixel to which it is assigned by inspecting the region defined around the pixel, (1) identifying other nearby boundaries, and (2) performing a set of rule checks on the other boundaries found, if any other boundaries exist. The inspected region is, in some embodiments, a search window defined around the pixel assigned to the thread. Figure 8 shows an example of such a search window 805 centered on a pixel 800 on the right-hand boundary of shape 105a. This search window also captures pixels along the boundary of shape 105b and pixels on the same boundary of shape 105a, but on its left-hand boundary.
[0053] In some embodiments, different processing threads assigned to several different pixels are executed simultaneously on one computer or several different processing units on several computers. In some embodiments, the different processing units are different cores of one or more processors, such as a CPU, GPU, or TPU. The different processing threads are, in some embodiments, similar threads that perform a SIMD computation technique on the assigned pixels. SIMD computation is the optimal computation technique for parallel processing of a single instruction across multiple datasets.
[0054] (In 520) After assigning different pixels to different threads, process 500 then (In 525) uses each specific processing thread to identify other edge pixels that are within a first threshold distance (e.g., defined by the search window) of the assigned pixel and are either on an edge of a different shape or on an edge on an opposing edge of the same shape as the assigned pixel. For each specific edge pixel identified as being within the first threshold distance of the assigned pixel (e.g., identified as being within the search window of the assigned pixel), the processing thread (In 530) performs one or more rule checks to determine whether the identified specific edge violates one or more rules. To perform this determination in 530, each processing thread dynamically generates edges on which nearby pixels exist and on which the assigned pixel exists, as will be detailed later in some embodiments.
[0055] If the layout is a mask layout or a design layout, the rule checks, in some embodiments, include spacing checks and / or width checks. The spacing check ensures that no two edges of two nearby shapes are closer than a threshold spacing distance. In such a check, a nearby edge pixel identified by a processing thread lies on an edge of a different shape than the pixel assigned to the processing thread. The width check, on the other hand, ensures that no two edges of a single shape are closer than a threshold width distance. In such a check, a nearby edge pixel identified by a processing thread lies on an edge of the same shape as the pixel assigned to the processing thread. This edge lies on the side opposite the processing thread's pixel in that shape.
[0056] In some embodiments, the processing thread determines, based on the value of an intervening pixel, whether a nearby edge lies on the same or different shape as the assigned pixel. For example, if the pixel value is an RTM value between 0 and 1, the processing thread determines whether the intervening pixel between that pixel and the identified edge is 0 or 1. If the intervening pixel is 1, the identified edge lies on the same shape; if the intervening pixel is 0, the identified edge lies on a different shape. In other embodiments, a separate pixel map is used in which each region is assigned a unique integer number rather than 1. In this way, the algorithm can identify edges in the same region by explicitly checking such integer numbers associated with inner pixels adjacent to the edge pixel.
[0057] In Figure 8, the spacing check ensures that pixels that lie on the boundary of shape 105b and are within the search window 805 are not closer than the threshold spacing distance of pixel 800. After determining that one or more boundary pixels of shape 105b are within the search window 805 of pixel 800, the processing thread for pixel 800 dynamically generates an edge 815 and calculates the distance between pixel 800 and the dynamically generated edge 815. To calculate this distance, the processing thread also dynamically generates an edge 820 on which the assigned pixel resides, and then uses both generated edges to calculate the distance between them.
[0058] In some embodiments, the edge generation process dynamically generates either curved edges or PWL edges formed by one or more straight segments for boundary pixels (i.e., pixels that lie on the boundary of a shape in the layout). In some embodiments, a straight segment may be defined by reference to a linear polynomial such as y = mx + b, where x and y are coordinates along the line, m is the slope, and b is the y-intercept. In some embodiments, a curved edge may be defined by reference to one of several common methods for defining a curve, such as a polynomial of degree two or higher, a Bézier function, or a spline function (B-spline function).
[0059] In Figure 8, the width check ensures that, in some embodiments, pixels on opposite sides of the same shape 105a and within the search window 805 are not closer than the threshold width distance of pixel 800. After determining that one or more pixels on the boundary of opposite sides of shape 105a are within the search window 805 of pixel 800, the processing thread for pixel 800 dynamically generates an edge 825 and calculates the distance between pixel 800 and the dynamically generated edge 825. To calculate this distance, the processing thread also dynamically generates an edge 820 on which the assigned pixel resides, and then uses both generated edges to calculate the distance between them.
[0060] In the example above, the processing thread performs spacing and width checks by (1) calculating the distance between the pixel or a dynamically generated edge of that pixel and (2) the dynamically generated edge of a nearby pixel within the search window of that pixel. In other embodiments, the processing thread simply measures the distance between the assigned pixel and a nearby pixel within the search window of the assigned pixel that has a different shape or an opposite edge of the same shape, rather than dynamically generating an edge and using the edge to calculate the spacing and / or width check.
[0061] When a processing thread identifies a rule check violation (e.g., a spacing violation or a width violation), the processing thread stores a record of this violation in a datastore (in 530). In some embodiments, the datastore is a database or another non-volatile datastore, while in other embodiments, the datastore is memory, and the records stored in this memory are then transferred to a database or another type of non-volatile datastore.
[0062] From a database or other non-volatile data store, stored violation records (if any) are subsequently retrieved for processing by another program or for presentation to a designer or engineer reviewing the layout in relation to the rule violations. The presentation is presented in the user interface of a program (e.g., a program for MRC or DRC) or transmitted as a report via electronic communication (e.g., email). In some embodiments, the IC designer or mask layout engineer can review these violations and make the necessary adjustments to the IC design layout or mask layout to eliminate them. Additionally or alternatively, in some embodiments, one or more automated software processes analyze the recorded violations and adjust the circuit design or mask to eliminate them.
[0063] At 535, the process determines whether it has inspected all boundary pixels of the currently selected shape boundary. If not, the process returns to 520 to select another batch of boundary pixels and assigns them to several processing threads for analysis (i.e., to perform operations 525 and 530). When the process determines (at 535) that it has inspected all boundary pixels of the currently selected shape boundary, the process determines (at 545) whether it has inspected all shape boundaries in the image composed of pixels. If not, the process returns to 515 to select another boundary of a different shape and then repeats operations 520-535 for this shape. When the process determines (at 545) that it has inspected all boundaries of all shapes, the process terminates.
[0064] As described above, process 500 inspects not only boundary pixels but all pixels of the layout. Therefore, in these embodiments, process 500 does not perform operation 535, but instead (at 545) determines whether all pixels of the layout have been inspected, and if not, returns to 515 to select another pixel of the layout.
[0065] Each processing thread, in some embodiments, (1) receives a pixel-based definition of the shape of its assigned pixel, (2) parses the pixel-based definition to dynamically generate edges within a first threshold distance (specified by, for example, a search window) of the specific pixel, and (3) examines each generated edge to determine whether the generated edge violates one or more rules being checked by the thread. In these operations, each processing thread, in some embodiments, dynamically generates edge data and stores it in the volatile runtime memory (e.g., RAM) of the computer of its processing unit. In some embodiments, this edge data is then discarded from volatile memory after the thread has completed its operation on that pixel. Dynamic generation of edges is advantageous because it eliminates the need to pre-divide the curved boundaries of the layout shape into a large number of edges that are stored on disk (i.e., their descriptions are stored) for subsequent processing by one or more rule checkers. Edges are dynamically generated by the rule checkers, stored in fast-accessible, high-speed local memory, and discarded when the rule checkers have completed their operation.
[0066] Figure 9 shows a process 900 performed by a pixel processing thread (such as thread 720 in Figure 7). As shown in the figure, process 900 starts when it receives identification information for a pixel assigned to it for checking (e.g., by the pixel-thread assigner 715) (in 905). In some embodiments, this pixel lies along the boundary of a particular shape, while in other embodiments, this pixel can be any pixel in the layout. Next, in 910, process 900 searches within a search window (e.g., window 805) defined around the received pixel to determine whether this window contains boundary pixels of other shapes or boundary pixels on the opposite side of the boundary where the received pixel resides. If it does not, the process terminates without identifying a rule check violation.
[0067] If process 900 determines (at 910) that the search window contains boundary pixels of another shape or boundary pixels of the opposite edge of the boundary where the received pixel exists, process 900 (at 915) selects one pixel within the search window. In Figure 8, the boundary pixel of shape 105b is within the window 805 defined with pixel 800 at its center.
[0068] For the selected pixels, process 900 then dynamically generates edges (in 920). In some embodiments, the process uses a marching square process to generate edges for the selected pixels, which will be described in detail later. After generating the edges, process 900, in some embodiments, determines whether the edges need to be modified (e.g., a straight edge modified to a curved edge) so that the edges cover an area that matches the pixel values assigned (by the rasterization operation) to the area the edges traverse (in 920). If the thread determines that the edges need to be modified, the thread, in some embodiments, uses the edges to generate a new PWL edge or curved edge (also called a curved edge) with the desired coverage area, and then uses this newly generated edge to violate rules applied by the thread (e.g., spacing rules or width spacing rules).
[0069] Next, in 925, the process determines whether the generated edge (which may have been modified to match the desired pixel area coverage) is within a second threshold distance of the pixel assigned in 905 or of the edge of this assigned pixel. When measuring the distance between the generated edge and the edge of the assigned pixel, process 900 also dynamically generates the edge of the assigned pixel by performing a marching square process, in some embodiments. If process 900 determines (in 925) that the generated edge violates one or more rules (e.g., a spacing rule or a width rule), process 900 stores a record of this violation in the datastore (in 925) as described above with respect to operation 530 in Figure 5.
[0070] In step 930, the process determines whether it has inspected all pixels within the search window. If not, the process returns to step 915 to select uninspected pixels that are along a boundary of a different shape than the specific shape of the received pixel, or on the opposite edge of the boundary where the received pixel exists, and then repeats steps 920-930. Once it determines that all boundary pixels that need checking have been inspected, process 900 terminates.
[0071] Figures 10–12 show several examples of how some embodiments perform the marching square process to dynamically generate edges for pixels within a search window. As shown in Figure 10, these embodiments use a marching square grid (MSG) of the same size as the layout pixel grid 1000 (also called the layout pixel grid), but offset by half a pixel vertically and horizontally from the layout pixel grid. In these examples, the layout pixel grid 1000 is drawn with dashed lines, and the marching square grid 1005 is drawn with solid lines.
[0072] The pixel dose values for each vertex of a pixel in MSG1005 are derived from the values of four pixels in the layout's pixel grid that the MSG pixels overlap. For example, for each specific vertex of an MSG pixel, some embodiments assign a pixel dose value of the layout grid pixel containing that particular vertex. Figure 11 shows one MSG pixel 1100 in MSG1005 that overlaps four pixels 1102-1108 in layout grid 1000. Each of the four vertices of MSG pixel 1100 is assigned one pixel dose value of the four layout grid pixels 1102-1108 that contain (i.e., include) that vertex.
[0073] In some embodiments, the pixel dose values of the vertices of MSG pixels are used to define marching square edges through MSG pixels by using a lookup table (LUT) that associates the pixel values of the vertices of pixels with predefined edges. Figure 12 shows 16 predefined edges stored in a LUT that specify 16 permutations of zero and non-zero pixel vertex values, where non-zero vertex values are drawn as black circles and zero vertex values are drawn as white circles. In order to use the LUT method, some embodiments perform a thresholding operation to set vertex pixel dose values that are not 0 or 1 to 0 or 1. Such thresholding operations will be described in detail later.
[0074] Implicit edges can be generated through MSG pixels within a search window by selecting a specific edge having at least one non-zero vertex value for each MSG pixel within the search window. Figure 13 shows an example of an implicit edge 815 generated for a corner of shape 105b within search window 805. This implicit edge consists of four edges 1300 defined for four MSG pixels within this search window. The dynamic edge generation process in some embodiments may generate different dynamic edges for different MSG pixels that are adjacent MSG pixels along a common boundary of the shape, as will be detailed later.
[0075] Herein, we describe some MRC processes in more detail for several embodiments. Those skilled in the art will recognize that these more detailed processes for some embodiments are also applicable to DRC processes, except that the shapes checked are shapes in the design layout, not shapes in the mask layout, and the rules checked are design rules for verifying the design layout, not mask rules for verifying the mask layout.
[0076] Some embodiments operate on sampled geometric data. In some embodiments, the amount of information about the mask shape is the pixel size P used in multibeam machines. MBM It is determined by the size of the pixels in some of these embodiments, which is the spatial sampling period of the geometry. In some of the current mask designs, P MBM Typically, the mask dimensions are 16 nm to 10 nm, and the wavelength used in EUV lithography is 13.5 nm, with the optical system reducing the image of the mask shape to one-quarter of its original size.
[0077] The task of developing pixel-based MRCs in some embodiments is to ensure that any mask shape described by OPC / ILT can be reliably drawn onto the mask. MBM When sampling using a spatial period grid, details that are too small or edges with too large a curvature cannot be reliably represented. Therefore, there may be polygonal or curved regions that produce the same raster image when rasterized. Pixel-based MRCs of some embodiments do not have such original polygons as a problem and examine the raster data regardless of how it was generated. For example, a region with a radius of curvature of 2*P MBMConsider an edge with a region less than . Information about this curvature value is lost during the sampling process, and the edge is effectively aliased as some other edge with a larger radius of curvature. From the pixel information, it is not even possible to infer what its original curvature was. However, by analyzing the sampled data, it may be possible to determine that the edges are too close together. Checking the distance between pixels-encoded edges, checking the area taken up by the pixels, and checking the local curvature of the edges are fundamental elements of pixel-based MRC in some embodiments. These checks are achieved by using the concepts of "pixel dose equivalence" and "implicit edges" described above and below.
[0078] In the rasterization process, many different curves can produce the same pixel value. As discussed in "You don't need 1nm contours for curvilinear shapes: Pixel-Based Computing is the Answer" by Abhishek Shendre, Aki Fujimura, Mariusz Niewczas, and Tom Kronmiller, Proceedings of the International Society for Optical and Photonics (SPIE) 12293, Photomask Technology 2022, 1229307 (December 1, 2022), if any two given curves cover the same area of a pixel, those curves are called pixel dose equivalent at those pixels. Since many geometries can correspond to the same pixel value, there are many possible contours that can be inferred from given pixel data. In some embodiments, implicit edges are defined as smooth curves through pixels that accurately represent the pixel data, insofar as the pixel data is generated from the band-limited geometry. A band-limited geometry of a given pixel size can be defined (e.g., rasterized) as geometric data that can be sampled using pixels without losing frequency information (e.g., while satisfying the Nyquist-Shannon sampling condition). Typically, QTM is obtained as a result of sampling band-limited data, whereas rasterized geometry is not. In rasterized geometry, some embodiments define implicit edges from edges defined by the commonly known marching square procedure.
[0079] To process edge position information from pixel values, some embodiments opt for a convenient curved form and employ methods for finding implicit edges in that form. For example, the commonly known marching square process constructs line segments that approximate the position of the edge contour. Another method is to create a complex polynomial approximation (e.g., a B-spline or Bézier curve) of the curved edge passing through each pixel. In such cases, since we are approximating band-limited data, the degree of the polynomial only needs to be 2 or greater.
[0080] In some cases, unless there is some prior knowledge about the curves, the sampled data may not contain enough information to reproduce any detailed curve within each pixel. An example of such prior knowledge is the knowledge that the original data before rasterization was Manhattan geometry.
[0081] Some embodiments generate implicit edges and calculate edge distances when processing the geometric information of the pixel domain. Unlike conventional edge-based methods, some embodiments of the pixel domain algorithm do not require the generated implicit edges to be stored for subsequent use. In these embodiments, implicit edges are created on the fly as local objects or treated as abstract mathematical concepts without further explicit object representation in memory, used to calculate edge distances, and then discarded once the required distance calculations are complete.
[0082] Implicit edges work because raster images containing band-limited data can be upsampled to represent the edges of a region with arbitrary high precision. Shannon's sampling theorem shows that if a process samples band-limited data at a frequency greater than twice the highest frequency present in the data, no information is lost. Therefore, pixel images in a multibeam machine contain very accurate information about the edges of a region, even if the exact location of the edges is not apparent in an obvious way. This precision is theoretically limited by the pixel size and, in practice, may also be limited by the process used to create the pixel image.
[0083] It should be noted that the latter limitation becomes irrelevant if the entire processing flow remains within the pixel domain. However, if the pixel image is created in a rasterization process, it is necessary to smooth the image with special filters to prevent aliasing when Fourier analysis is applied. With this condition in mind, since the process is assumed to operate on bandwidth-limited data, a procedure called Fourier interpolation can be used to obtain an accurate pixel image with arbitrary detail. In short, the image is transformed using a 2D discrete Fourier transform (e.g., the 2DFFT algorithm).
[0084] Next, in the spatial frequency domain, the 2D array representing the transformation is expanded, and zero values are inserted into all new entries representing high frequencies (zero padding). Because the signal is band-limited, this zero padding represents the absence of high-frequency terms in the transformation without loss of precision. Next, an inverse 2DFFT is applied to this expanded data, which generates an upsampled pixel image. Such an upsampled image can be contour-extracted using, for example, a commonly known marching square algorithm to obtain a highly accurate edge-based description. Some embodiments use the assumption, without loss of generality, that edges occur at positions where the pixel map values are interpolated to 0.5. Under special circumstances, some other threshold may be assumed, but this does not change the progress of the contour-extraction operation. From the above procedure, it can be seen that it is possible to infer very accurate edge position information from the implicit curves presented in the image map in a multibeam machine. Therefore, the use of implicit curves is reasonable and does not lead to an intrinsic loss of precision.
[0085] After confirming that the processed data in the pixel image is bandwidth-limited and that implicit edges can be defined from the pixel image with arbitrary precision when the initial data is bandwidth-limited, we can describe some embodiments of pixel-based MRC. Some embodiments of MRC check the following three rules: (1) no region is narrower than a certain minimum width, (2) the minimum distance between any two regions is not less than a certain minimum interval, and (3) the minimum area covered by a given region or the minimum area not covered is greater than a certain minimum area.
[0086] The minimum width rule stipulates that two pixels violate the minimum width if the distance between them along an implicit curve is less than the minimum width. If two edge pixels are closer to each other along the same implicit curve than maxEdgePath, the width violation is ignored. In some embodiments, this internal parameter of the algorithm is set as follows:
[0087] maxEdgePath=0.5*π*max(minWidth,minSpacing) The minimum distance rule check ensures that the distance between any two regions is not less than a given minSpacing. This means that the distance between any pixels from two regions is not less than minSpacing. Since the two regions can be connected, in some embodiments of MRC, the maxEdgePath constraint is also applied to these pixels. The minimum area rule check ensures that the minimum area covered by or not covered by a given region is greater than the minArea value.
[0088] In some embodiments, the input to the MRC process includes a rasterized pixel image ImageIn, where each pixel is represented by a floating-point value P representing the percentage of this pixel covered by the curved mask region. a A given P having ∈[0.0,1.0] MBM This input includes the values of minWidth, minSpacing, minArea, and the required precision criterion MaxPlacementError (e.g., P MBM =10nm, minWidth=25nm, minSpacing=26nm, minArea=625nm 2 , MaxPlacementError=0.05nm).
[0089] Regarding MaxPlacementError, the accuracy of width, spacing, and area determines the upsampling rate. For example, in some embodiments, the MRC process upsamples 4x to create a raster image with a resolution of 2.5 nm for the exemplary numbers described above. This allows the MRC process to use the marching square process to find edge positions with an accuracy of more than 0.5 nm. In general, sufficiently large upsampling can make the EPE sufficiently small. For these exemplary numbers, 4x upsampling was sufficient.
[0090] Next, the input image (ImageIn) is upsampled four times using Fourier interpolation. This results in the upsampled image (ImageIn4x). The MRC process creates a distance map ImageInD from ImageIn and ImageIn4x as follows: (1) ImageInD is created as a map of the same size as ImageIn by initializing all pixels in ImageInD to the value 2*max(minWidth,minSpacing), and (2) for each pixel in ImageIn, all edge-pixel pairs in the opposite direction relative to the center of this pixel are checked, and the pair with the minimum distance is selected.
[0091] Here, with reference to Figures 14-16, another example of pixel-based rule checking in several embodiments is described. In these embodiments, the pixel-based rule checking process divides a layout (e.g., a mask layout or design layout) into regions consisting of one or more pixels. For each region consisting of pixels, the process assigns a different processing thread to a different MSG pixel within the region. Each processing thread then determines whether its assigned MSG pixel is a boundary pixel (i.e., exists along the boundary of a shape), and if it does, dynamically generates a local edge extending through that MSG pixel.
[0092] After a thread dynamically generates edges for its associated pixels, it stores the generated edges in memory shared among processing threads (e.g., volatile runtime memory such as RAM). Each processing thread then uses the stored generated edges to perform pixel-based rule checking on each of its pixels. In some embodiments, the pixel-based rule checking examines spacing rules for non-edge pixels (i.e., pixels that do not lie on the edges of an object in the layout) and edge pixels (i.e., pixels that lie on the edges of an object in the layout). Some embodiments perform the edge generation and rule checking processes for MSG pixels using the same thread, while others use different threads to perform this process for MSG pixels.
[0093] Figure 14 shows process 1400 performed by the pixel processing thread to dynamically generate a local edge that traverses the assigned pixel if the assigned pixel lies on the boundary of a shape in the layout. In some embodiments, the pixel processing thread performs process 1400 whenever a pixel to be processed is assigned to the pixel processing thread by a pixel-based rule-checking process. Process 1400 begins when the thread receives a pixel to be processed (in 1405). In some embodiments, the received pixel is an MSG pixel (e.g., pixel 1100 in Figure 11) defined in an MSG (e.g., MSG 1005 in Figure 10).
[0094] If the rule-checking process does not receive a layout in a pixelated format (for example, a layout in a contour domain) in order to provide MSG pixels to each thread, the rule-checking process, in some embodiments, constructs the layout with pixels using a pixel grid and associates pixel dose values with each pixel in the pixel grid. In some embodiments, the rule-checking process overlays the MSG onto the pixelated layout and then divides the layout into one or more regions for iterative processing. If two or more regions are defined, the rule-checking process, in some embodiments, overlaps the regions so that rule-checking can be performed on shapes near the boundaries of the regions.
[0095] In step 1410, process 1400 determines whether the assigned pixel lies along the boundary of a shape in the layout. In some embodiments, as described above with reference to Figures 10 and 11, each MSG pixel has four vertices that lie within four pixels of a layout pixel grid that makes up the layout of pixels. In some of these embodiments, process 1400 determines that the MSG pixel lies along the boundary of a shape if at least one of its vertices lies within a layout-grid pixel that has a pixel dose value related to the boundary of the shape (for example, having a non-integer pixel dose value of 0 to 1 in embodiments where the outer and inner pixels are 0 and 1 and the boundary pixel is 0 to 1).
[0096] If process 1400 determines (in 1410) that the assigned MSG pixel does not exist along the boundary of the layout shape, process 1400 terminates its edge generation operation. In some embodiments, the thread that performs the edge generation operation on an MSG pixel also performs a rule check operation (for example, an operation described later with reference to Figure 15) on that MSG pixel once other threads have completed their edge generation operations. In other embodiments, the rule check process assigns separate threads for the edge generation operation and the rule check operation for each MSG pixel, so that one thread does not perform both operations on a single MSG pixel in the area being processed.
[0097] If process 1400 determines (in 1410) that the assigned MSG pixel lies along the boundary of the layout shape, process 1400 (in 1415) sets a pixel dose value for each vertex of the MSG pixel to be equal to the pixel dose value of the pixel in the pixel grid containing the pixel. For example, in the case of MSG pixel 1100 in Figure 11, the process assigns the pixel dose values of pixels 1102-1108 to the four vertices of MSG pixel 1100. In other embodiments, the pixel dose values of the vertices of the MSG pixel are defined before process 1400 is called.
[0098] Next, in 1420, process 1400 performs a thresholding operation that assigns a lookup value of 0 or 1 to each vertex of the MSG pixel. In some embodiments, this thresholding operation compares the assigned pixel dose value of each vertex to a threshold, and then assigns a lookup value of 1 to the vertex if the assigned value is greater than or equal to the threshold, or assigns a lookup value of 0 to the vertex if the assigned value is less than the threshold. Other embodiments perform this thresholding operation in a different way (for example, assigning a lookup value of 1 to the vertex if the assigned value is greater than the threshold, or assigning a lookup value of 0 to the vertex if the assigned value is less than or equal to the threshold).
[0099] Next, process 1400 (at 1425) uses the assigned lookup values of the MSG pixel vertices to perform a lookup in the MSG LUT to identify PWL edges (formed by one or more linear segments) that traverse the MSG pixels. Figure 12 above shows an example of such a LUT. In this example, the 16 predefined linear edges shown are defined for 16 permutations of zero and non-zero pixel vertex values, where non-zero vertex values are drawn as black circles and zero vertex values are drawn as white circles.
[0100] In the example LUT in Figure 12, each pixel is a square pixel with four sides, and a straight edge traversing an MSG pixel intersects two or four sides (pixel edges) of this pixel. Next, in 1430, process 1400 performs an interpolation operation (e.g., linear interpolation) to adjust the PWL edge identified in 1425 to more closely match the pixel dose values assigned to the vertices of the MSG pixel along the intersecting sides of the MSG pixel (in 1415). For example, suppose the identified PWL edge is edge 1205 in Figure 12, and the pixel dose values at the top-left and top-right vertices of the MSG pixel are 0 and 0.1, respectively. The interpolation operation of process 1400 adjusts the identified PWL edge to have a positive slope as it moves from left to right across the MSG grid.
[0101] In step 1435, the process then performs a parametric curve fitting operation as needed to convert the line segments of the MSG pixels remaining after step 1430 into curved edges that traverse the pixels. Dynamically generated edges passing through MSG pixels can become PWLs or curves after the parametric curve fitting operation 1435. The parametric curve fitting operation 1435 finds the mathematical curve description that best fits a given region according to some optimal fit criteria. These criteria are either that the total distance from the relevant MSG line segments is minimized, or that it covers the same area as the area to which the pixel is assigned.
[0102] In some embodiments, this parametric curve fitting operation generates a curved edge of an MSG pixel by (1) examining the pixel dose values of the vertices of the assigned MSG pixel, and (2) examining the line segments identified for that MSG pixel. In other embodiments, this parametric curve fitting operation generates a curved edge by (1) the line segments identified for the assigned MSG pixel, and (2) the line segments identified for MSG pixels adjacent to the assigned MSG pixel in the MSG. In some embodiments, the line segments of adjacent MSG pixels are identified by process 1400 by performing operations 1415-1430 on those adjacent MSG pixels. In other embodiments, these line segments are identified by another thread that (1) processes the adjacent MSG pixels (by executing another instance of process 1400) and (2) stores the results in memory shared with process 1400. In these embodiments, process 1400 stores the line segments obtained after the adjustment operation in 1430 in shared memory.
[0103] Dynamically generated edges passing through MSG pixels can become PWLs or curves after the parametric curve fitting operation 1435. In 1440, process 1400 then performs an edge adjustment operation to adjust the generated edges as needed to more closely match the pixel dose values associated with the processed MSG pixels (i.e., the MSG pixels received in 1405). In some embodiments, this adjustment is based only on the pixel dose values of the pixels that the received MSG pixels overlap in the pixel grid, while in other embodiments, this adjustment is based on the pixel dose values associated with the processed MSG pixels and the MSG pixels adjacent to the processed MSG pixels in the MSG.
[0104] In 1445, the process stores the remaining edges after the edge adjustment operation 1440 in memory shared with other pixel processing threads, and then terminates. In some embodiments, the generated edges are edges that pass only through MSG pixels processed by process 1400 (i.e., MSG pixels received in 1405), while in other embodiments, dynamically generated edges are edges that process 1400 generates for its assigned MSG pixels and MSG pixels adjacent to its assigned MSG pixels.
[0105] Figure 15 shows the rule-checking process 1500 that a thread performs on the MSG pixels assigned to it. This process 1500 is illustrated with reference to the example shown in Figure 16, which illustrates the interval rule-checking performed on pixel 1600 in MSG 1604. In this example, dotted lines represent pixels in a pixel grid 1602 that consists of pixels in a 9x10 pixel area, and solid lines represent marching square pixels.
[0106] In some embodiments, all processing threads dynamically identify and generate edges along the boundaries of one or more shapes in the region, store the generated edges in shared memory, and then process 1500 is executed for the MSG pixels in the region. In 1505, the process defines a search window centered on the MSG pixel being processed. The search window 1610 in Figure 16 is a search window defined centered on the MSG pixel 1600.
[0107] Next, in 1510, process 1500 determines whether the search window contains two or more MSG pixels from which two or more edges are dynamically generated. If it does not, process 1500 terminates because two or more MSG pixels are required to perform the spacing rule check. On the other hand, if the process determines (in 1510) that the search window contains two or more MSG pixels, the process identifies different pairs of MSG boundary pixels to check (in 1515). Both pixels in each identified pair are, in some embodiments, pixels within the search window identified in 1505.
[0108] In some embodiments, the MSG pixel pairs may be pairs of pixels on the boundary of two shapes where process 1500 needs to perform a spacing check to ensure the two shapes are sufficiently far apart, or pairs of pixels on the boundary of one shape where process 1500 needs to perform a minimum width check. Figure 16 shows spacing rule checks for two pixels 1615 and 1620 that exist along the boundary of two different shapes, one being a left subcircle and the other a right subrectangle. In this example, process 1500 also checks all combinations of MSG pixel pairs where there is one pixel in the search window along the left subcircle and one pixel in the search window along the right subrectangle.
[0109] After identifying one or more pairs of MSG boundary pixels to check (at 1515), the process performs the rule check for each identified pair based on two dynamically generated edges for each pixel in the pair to identify rule check violations (at 1520). In the example in Figure 16, process 1500 is shown as checking whether the distance between two pixels 1615 and 1620 (i.e., the sum of the distances between pixel 1600 and each of these two pixels 1615 and 1620) is less than the required minimum spacing distance. The distance between edges can be calculated by any method well known in analytical geometry.
[0110] In 1525, process 1500 records the rule check violations identified in 1520 into a data store and then terminates. In some embodiments, the stored rule check violations identify the rule that was violated, one or more shapes that violated the rule, and location data that specifies the location of the violation in the layout. In some embodiments, an IC designer or mask layout engineer can later review these violations and make the necessary adjustments to the IC design layout or mask layout to eliminate them. Additionally or alternatively, one or more automated software processes, in some embodiments, analyze the recorded violations and adjust the circuit design or mask to eliminate them.
[0111] As described above, in some embodiments, one processing thread assigned to a single pixel (e.g., pixel 1600) can perform a rule-checking process 1500 on two edges (e.g., edges 1615 and 1620) dynamically generated by two other processing threads (e.g., two threads running two instances of process 1400). However, in other embodiments, one processing thread not only performs rule-checking on its assigned pixel, but also dynamically generates one or more edges (crossing one or more boundary pixels) that need to be analyzed for rule-checking purposes for its assigned pixel.
[0112] One advantage of the MRC process in some embodiments is that pixels can be processed entirely in massive parallelism by processors (such as GPUs and TPUs), with each pixel treated as a parallel unit. The data required by each thread can be held in shared memory. This means that data access is extremely fast. Furthermore, the process requires very little communication between threads, which contributes to very high performance.
[0113] In some embodiments, the MRC process performs the following actions to check for width / spacing violations using ImageInD. This process checks for width / spacing violations using each blank pixel and stores the violation value and pixel pair index in the corresponding element of the distance map. This process also checks for width / spacing violations using each edge pixel and whether its neighbors are also edge pixels, and checks for width / spacing violations for these pairs. If a violation is found, the violation is stored in the distance map. The distance map makes it possible to store the minimum distance or error value for each width, spacing, and area violation. In some embodiments, the MRC process generates error markers by propagating the error value from blank pixels to edge pixels using the stored indices. It also post-processes the error markers to eliminate those where both edges exist on an edge with a length less than maxEdgePath.
[0114] Pixel-based area calculation, in some embodiments, is based on aggregating pixels from a pixel inside an area, through all adjacent pixels, until all adjacent pixels are space or exceed minArea. For example, some embodiments calculate the area covered by an arbitrary shape using the pixel dose values of pixels within and on the boundary of a shape. Similarly, these embodiments calculate the area between any two shapes using the inverted pixel dose values of pixels between and on the boundary of shapes. If the calculated area of a shape or between shapes is less than minArea, some embodiments find a minimum area violation. Minimum area checks are also performed in some embodiments to catch small protruding notches of a shape (i.e., a smaller shape that is part of a larger shape and protrudes from a larger portion of the larger shape) that are smaller than the minimum allowable size of such notches.
[0115] Another rule applied by some embodiments is the minimum encirclement spacing rule, which stipulates that the minimum spacing required for one object (e.g., one metal contact on one layer) to overlap another object (e.g., another metal object on another layer) must exceed the application of a threshold. As mentioned above, some embodiments also apply the maximum local edge curvature rule, which defines the maximum allowable curvature of the shape's contour in the layout. To do this, some embodiments calculate the first and second derivatives along the boundary contour of the shape, and then use these derivatives to determine whether any curvature along the boundary of the shape violates the maximum local edge curvature rule.
[0116] For example, some embodiments dynamically generate boundary edges of a shape at each boundary pixel of the shape (i.e., each pixel existing along the boundary of the shape), and then calculate the first and second derivatives of each dynamically generated boundary edge. Next, these embodiments use these derivatives to quantify the slope of the tangent to the boundary edge and the rate of change of this slope. Based on these quantified values, these embodiments then perform a maximum local edge curvature rule check (for example, by determining whether the rate of change of the slope exceeds a threshold). If the maximum local edge curvature (e.g., the rate of change of the slope) exceeds a threshold, these embodiments determine that the shape has a curved edge that violates the maximum local edge curvature rule.
[0117] Many of the rule checks described above and below are used to ensure that the shape on one layer of a layout (e.g., a design layout or mask layout) conforms to one or more rules applied to the layout or that layer of the layout. As mentioned above, examples of such rules include minimum spacing rules, minimum width rules, minimum area rules, and maximum curvature rules. Therefore, these rules are evaluated with respect to the shape on each individual layer of the layout.
[0118] Other rules are applied to evaluate the relationships between different shapes on different layers of the layout. For ICs with numerous Z-axis connections (e.g., via connections) between different IC layers (e.g., between different metal layers of the IC), some embodiments apply a minimum encirclement rule to the layout of the IC (e.g., its design layout). This minimum encirclement rule ensures that for each via, the via contacts on different layers have sufficient overlap. Some embodiments also apply this minimum encirclement rule to the layout.
[0119] Some embodiments use an automated process that not only detects rule check violations in the layout (e.g., MRC or DRC violations) but also corrects the detected violations. The automated process in some embodiments only corrects detected violations that are smaller than a threshold size because larger violations may require relatively large changes to the layout, which can be problematic (e.g., requiring changes to items in the layout that have some undesirable side effects on the physical characteristics of the circuit). Since manually resolving small violations is very time-consuming, eliminating violations smaller than a threshold size is still very useful.
[0120] Figure 17 shows process 1700, which proceeds through detected rule check violations (e.g., DRC or MRC violations) and tags each violation as either manual or automatic correction. Automatically corrected and tagged violations are processed by automated process 1800 in Figure 18 to correct the violations. Process 1700 first determines (at 1705) whether a pixel in the pixel-based definition of the layout is related to a rule check violation (e.g., at 530, 925, or 1525 in processes 500, 900, or 1500). If it is not related, the process terminates.
[0121] If the process determines (in 1705) that a pixel is associated with a rule check violation (e.g., spacing violation, width violation, area violation, curvature violation, etc.), the process (in 1710) selects one such pixel and then (in 1715) determines whether the violation associated with the selected pixel exceeds a threshold size. When a pixel rule check process of some embodiments (e.g., processes 500, 900, or 1500) performs a rule check on a pixel, the process records a quantity that identifies the size of the violation. For example, for a spacing violation of a first pixel in a first shape, a pixel rule check process of some embodiments records how much smaller the dynamically generated edge of the first pixel is than the minimum spacing requirement relative to the adjacent edge of a second shape. Similarly, for a width violation of a first pixel in a first shape, a pixel rule check process of some embodiments records how much smaller the dynamically generated edge of the first pixel is than the minimum spacing requirement relative to other edges of the first shape.
[0122] If the process determines (in 1715) that the number of violations associated with the selected pixels exceeds a threshold size, the process (in 1720) flags the shape of the selected pixels for manual correction by a layout engineer (e.g., a design layout engineer or a mask layout engineer) (e.g., associates the shape with a first manual correction value of a flag variable). This flagging also causes process 1700 to record or retain a record prior to identifying the rule-violating pixels of the flagged shapes. Through the layout editor's user interface (e.g., a graphical user interface), the engineer then reviews all shapes tagged for manual correction along with the rule-violating pixels and provides input for manually correcting the shapes that have been flagged for manual correction.
[0123] If multiple pixels of a shape are associated with rule check violations, and one of these violations is greater than a threshold size in some embodiments (or greater than or equal to a threshold size in other embodiments), process 1700 flags the shape for manual correction and designates all other rule check violations of the shape's pixels as having been handled by process 1700, and as a result, other detected rule check violations of the shape cannot subsequently be designated for automatic correction, even if the other rule check violations are less than a threshold size. In other embodiments, process 1700 designates some of the shape's smaller violations (e.g., irrelevant violations) for automatic correction and some of the other violations (e.g., larger violations or smaller violations related to larger violations) for manual correction. From 1720, process 1700 returns to 1705, which will be described in detail later.
[0124] If the process determines (in 1715) that the violation associated with the selected pixel (i.e., the pixel selected in the last iteration of 1705) does not exceed a threshold size (or is less than or equal to the threshold size in other embodiments), the process (in 1720) flags the shape associated with the selected pixel with automatic correction (for example, the process associates this shape with a second automatic correction value of the flag variable). In some embodiments, process 1700 may later change this flagging (for example, change the flag to a first manual correction value) if it determines in a subsequent iteration that another rule-violating pixel of the shape has a rule violation that exceeds a threshold. When flagging a shape with automatic correction, process 1700 also records or retains a prior record of identifying the rule-violating pixel of the automatically corrected and flagged shape. Process 1800 then performs the automatic correction operation using the identification information of the rule-violating pixel. From 1725, process 1700 returns to 1705.
[0125] When process 1700 returns to 1705 from either 1720 or 1725, process 1700 determines if there are any other rule-violating pixels in the layout that have not yet been inspected by process 1700 (e.g., selected in a previous iteration through 1710 or designated in 1720 as something to be inspected). If process 1700 determines (in 1705) that it has inspected all rule-violating pixels, it terminates. Otherwise, the process proceeds to 1710 to select another rule-violating pixel that process 1700 has not yet inspected (e.g., not selected in a previous iteration through 1710 or designated in 1720 as something to be inspected).
[0126] As described above, in some embodiments, process 1700 does not automatically correct and flag a shape if the shape has one or more sections that violate the rule by a threshold amount, even if the shape has one or more sections that violate the rule by a threshold amount. However, other embodiments flag shapes in a different way. For example, some embodiments automatically correct and flag sections with small violations (smaller than the threshold size) and manually correct and flag sections with large violations (larger than the threshold size).
[0127] Figure 18 shows process 1800 automatically corrects pixel rule violations (e.g., without user input) for shapes in a layout tagged for automatic correction by the automatic process 1700 of Figure 17. These shapes are, in some embodiments, layout shapes that have only violations smaller than (or less than or equal to) the threshold size, as described above. First, process 1800 performs operations 1805-1820, iterating through each layout shape that has been automatically corrected and tagged by process 1700, in order to generate an adjustment map that identifies an initial set of adjustment values to apply to the contours of the automatically corrected and tagged shapes.
[0128] Specifically, in 1805, process 1800 selects layout shapes that have been automatically corrected and flagged by process 1700. Next, in 1810, process 1800 identifies the rule violation amount for each pixel, identifying each pixel (of the shape) that has been identified as violating a layout rule and the amount by which the pixel violates the rule. In some embodiments, each rule-checking process identifies the rule violation amount for each rule-violating pixel of the shape as part of the rule check, after identifying that the pixel of the shape violates the rule being checked. Thus, in these embodiments, the identification in 1810 involves obtaining, for the selected shape, from a memory structure (1) identification information of any of the pixels of the selected shape that have been tagged as violating a rule, and (2) the amount of rule violation for this pixel.
[0129] In 1815, process 1800 adds the violation amounts identified in 1810 for the shapes selected in 1805 to an initial adjustment map that specifies adjustment values for the shape contours at pixels that violate the layout rules. The adjustment value for each rule-violating pixel of the selected shape is, in some embodiments, simply the identified amount of violation for the pixel, while in other embodiments, it is an adjustment value derived from the identified amount of violation. Examples of initial adjustment maps will be described in detail later with reference to Figures 19 and 20.
[0130] As will be detailed later with reference to Figures 19 and 20, some embodiments generate a single marker that identifies each location along a shape having multiple nearby rule-violating pixels (e.g., multiple adjacent pixels) associated with one particular rule violation. These embodiments then adjust all the values of the neighboring rule-violating pixels associated with each marker together so that each adjustment for each rule-violating location on the shape can be performed for each violation. In this way, each such adjustment takes into account the fact that the set of neighboring rule-violating pixels associated with one marker is associated with one violation, as opposed to adjusting these pixel values individually as if they were unrelated to each other. As will be detailed later, the adjustment of a set of adjacent rule-violating pixels associated with one rule-violating location on the shape may, in some embodiments, also modify the pixel values of one or more pixels near the set of rule-violating pixels.
[0131] In some embodiments, the adjustment amount (e.g., violation amount) in the adjustment map for each rule-violating pixel of the shape is represented by a pixel dose value. On the other hand, as will be detailed later with reference to Figures 19 and 20, in other embodiments, the adjustment amount for each rule-violating pixel of the shape is represented by the length (e.g., in nanometers) of the contour passing through the pixel that violates the layout rule. To represent each adjustment amount (e.g., violation amount) for each rule-violating pixel, some embodiments measure the adjustment amount using dynamically generated edges, and the adjustment amount is, in some cases, the violation amount or an amount derived from the violation amount.
[0132] At the start of process 1800, the adjustment map is initialized to specify a default adjustment value of 0 for each pixel of the layout, in some embodiments. For each rule-violating pixel of the flagged shape, process 1800 modifies the default adjustment value to a non-default adjustment value when process 1800 modifies the initial adjustment value for the pixel in 1815, as described above and further detailed later with reference to Figures 19 and 20, in some of these embodiments. If the layout is a multi-layer layout (e.g., a design layout having one layout for each device layer or wiring layer), the adjustment map also includes, in some embodiments, a set of map values for each layer of the layout.
[0133] Next, at 1820, process 1800 determines whether it has inspected all autocorrected and flagged layout shapes. If it has not, process 1800 returns to 1805 to select another shape and performs operations 1810 and 1815 on this shape. If the process determines that it has inspected all autocorrected and flagged layout shapes, process 1800 (at 1825) performs a variable resize operation based on the adjustment values in the adjustment map to generate one or more adjustment values for (1) each rule-violating pixel of each autocorrected and flagged shape, and optionally (2) one or more non-rule-violating pixels near one or more rule-violating pixels along the contour of each flagged shape.
[0134] In some embodiments, the variable resize operation generates a set of pixel dose adjustment values to apply to the pixel dose values of one or more sets of pixels in the layout to correct the contours of autocorrected and flagged shapes. For each flagged shape, the adjusted set of pixels to which the pixel dose adjustment set is applied typically includes rule-violating pixels along the contour of that shape, and may also include one or more pixels that are not tagged as rule-violating pixels, but are instead near the rule-violating pixels (e.g., pixels adjacent to the rule-violating pixels). In some embodiments, this operation specifies adjustment values for non-rule-violating pixels to ensure that the contour adjustment of the flagged shape (i.e., autocorrected and flagged shape) is performed in such a way that the contour has desired properties (e.g., desired smoothed properties). Examples of pixel dose adjustment values generated by the variable resize operation will be described in detail later with reference to Figures 19 and 20.
[0135] Next, in 1830, process 1800 modifies the pixel dose values of the pixels that form the layout with a representation composed of the pixels of the layout, using the resulting adjustment values generated by the variable resize operation. Operation 1830 includes, in some embodiments, adding any adjustment values generated by the variable resize operation in 1825 to the pixel dose value of that pixel. Operations 1825 and 1830 are two distinct operations in some embodiments, but in other embodiments, these operations are performed together as a single operation.
[0136] For example, in some embodiments, process 1800 performs a curve fitting operation for each flagged shape (i.e., each shape that is automatically corrected and flagged), using the pixel dose value of each rule-violating pixel along with an adjustment value calculated in 1810 for that pixel (e.g., the rule-violating amount or a value derived from the rule-violating amount). This curve fitting operation adjusts the pixel dose value of every rule-violating pixel, and sometimes adjusts one or more pixels adjacent to the rule-violating pixel, to automatically correct the automatically corrected and flagged shapes. In these embodiments, this curve fitting operation is a single operation that implicitly performs both operations 1825 and 1830.
[0137] After correcting the pixel dose values at 1830, process 1800 then starts a set of one or more rule-checking processes (such as processes 500, 900, or 1500) (at 1835) to recheck the corrected layout, and then terminates. The set of rule-checking processes is started to determine whether the corrections to the flagged shapes have resolved the issues with those shapes and / or have not caused any other rule-checking violations with respect to other shapes in the layout.
[0138] After performing this recheck, some embodiments repeat processes 1700 and 1800 to identify smaller violations and automatically correct these smaller violations. Some embodiments perform (1) rule violation check processes (such as processes 500, 900, or 1500), followed by (2) automatic correction processes 1700 and 1800, two or more iterations, then terminate these iterations, flagging any uncorrectable small violations for review by a layout engineer. After 1835, the process terminates.
[0139] Figure 19 shows an example of automatically correcting shapes that violate the minimum width rule. This figure shows examples in four operating stages 1901 to 1904. The first operating stage shows a pixel dose map of shape 1900, which looks like a figure eight. In this pixel dose map, pixels that are completely inside the shape have a dose value of 1, pixels that are completely outside the shape have a dose value of 0, and pixels on the boundary of the shape have a dose value of 0 to 1 depending on how much of the pixel is inside the shape.
[0140] The second step 1902 shows that in the central region 1910 of shape 190, shape 1900 violates the minimum width rule because two opposing edges of the shape are too close to each other. In some embodiments, the minimum width rule is checked for all parts of the shape that are a required threshold distance away from the protruding tips of the shape. In this example, the protruding tips of shape 1900 are the top and bottom of the shape. In this example, any two dynamically generated edges of two pixels on opposing edges of the shape must not be closer to each other than 1.8 pixels if the two edges are not part of the protruding tips.
[0141] The central region 1910 contains four pixels that violate this minimum width limit. In other words, the contour of the shape that crosses these four pixels is too narrow in this region. In some embodiments, the automatic correction process defines a marker for the central region 1910 and identifies it as a single location along the shape 1900 that violates one of the layout rules. The four pixels in the central region 1910 are associated with this marker. The values of these four pixels and some nearby pixels are adjusted together to resolve this single rule violation, as will be detailed later.
[0142] In some embodiments, the automatic correction process calculates an initial correction value for each of the four pixels in the central region 1910 in the correction map calculated in 1815. In the correction map, the correction value for each such pixel is, in some embodiments, expressed as the length (e.g., in nanometers) of the contour crossing the pixel that violates the layout rule. In some embodiments, the correction value in the correction map for each of the four pixels in the central region 1910 is the violation amount or a quantity derived from the violation amount. For example, for the four rule-violating pixels in the central region 1910, the automatic correction process calculates, in some embodiments, a correction amount of 0.1 or 0.2 of the pixel length.
[0143] After identifying the markers in the central region 1910, the autocorrection process in some embodiments then performs a curve fitting operation to generate a set of pixel dose adjustment values shown in the third stage 1903, using the original pixel dose values shown in the first stage 1901 and the adjustment amounts (in the adjustment map) calculated for the rule-violating pixels identified in the second stage 1902. To calculate the adjustment values, the autocorrection process in some embodiments uses the inverse function of the function used to map the dose values to the positions of the contours of shapes passing through the pixels (i.e., uses a function that maps the positions of the contours of shapes to the pixel dose values). To solve this inverse function, different embodiments use different solution processes, such as a local gradient search process or a nonlinear optimization process.
[0144] After calculating the pixel dose adjustment values, these adjustment values are then added to the pixel dose values of shape 1900 to obtain the modified shape 1905 shown in the fourth stage 1904. This curve fitting operation is a variable resizing operation because different pixel dose adjustment values can be specified for different pixels. The modified shape 1905 no longer has pairs of opposing segments that are a required threshold distance from any protruding tip of the shape and closer than a minimum width of 1.8 pixels. As shown in the third stage 1903, the pixel dose adjustment values include not only the adjustment values for the four rule-violating pixels in region 1910, but also the adjustment values for a certain number of adjacent pixels around these four rule-violating pixels.
[0145] These pixel dose adjustment values for adjacent pixels and for rule-violating pixels ensure that the corrected shape 1905 has the desired contour characteristics (e.g., a smooth contour). In other words, the curve fitting operation in some embodiments ensures that the automatic correction does not result in undesirable contours in the automatically corrected shape (e.g., a shape with jagged edges). Some of the calculated pixel dose adjustment values move the contour of the shape from one pixel to another (e.g., changing the dose value of a pixel that previously had a decimal dose value to 1, changing the dose value of a pixel that previously had a dose value of 0 to a decimal, etc.).
[0146] In some embodiments shown in Figure 19, the curve fitting operation first generates a pixel dose adjustment value based on the original pixel dose value and the adjustment amount specified by the adjustment map, and then adds the generated pixel dose adjustment value to the original pixel dose value. However, in other embodiments, the curve fitting operation does not first generate a pixel dose adjustment value that is later added to the original pixel dose value. These embodiments directly generate the modified pixel dose value of the modified shape by using the original pixel dose value of the shape together with the adjustment amount specified in the adjustment map of the rule-violating pixels identified by the rule-checking process. Under this curve fitting technique, the pixel dose adjustment value is implicitly calculated and applied to the pixel dose value of the original shape to generate the modified shape as part of the curve fitting operation. In addition, the curve fitting operation in these embodiments also ensures that the modification to the shape does not result in undesirable contour characteristics for the shape (e.g., ensuring that the shape has smooth edges).
[0147] Figure 20 shows an example of automatically correcting shapes that violate the minimum spacing rule. This figure shows examples in four operating stages 2001-2004. The first operating stage shows a pixel dose map that includes parts of two shapes 2000 and 2006. In this pixel dose map, pixels that are completely inside the shape have a dose value of 1, pixels that are completely outside the shape have a dose value of 0, and pixels on the boundary of the shape have a dose value of 0 to 1 depending on how much of the pixel is inside the shape.
[0148] In the bent portion 2010 of shape 2000, shapes 2000 and 2006 violate the minimum spacing rule because these two shapes are too close to each other. In some embodiments, the minimum spacing rule is checked for each pixel along the boundary of each shape, while in other embodiments, the minimum spacing rule is checked for each pixel in the pixel dose map as described above.
[0149] If two shapes are determined to be too close to each other, the spacing rule checking process in some embodiments flags both shapes as violating the spacing check and identifies the pixels of each shape that violate the spacing check. If the two shapes are considered to be too close to each other by a certain amount X, the rule checking process, in some embodiments, assigns half of the amount X as the violation amount to each of the two shapes. In other embodiments, the rule checking process uses other heuristics to distribute the violation amount X between the two rule-violating shapes.
[0150] The second stage 2002 shows a layout area 2012 containing six pixels along the boundaries of two shapes 2000 and 2006 that have been identified as violating a spacing rule that defines the minimum distance between the contours of two different shapes. In this example, any two dynamically generated edges that cross the boundaries of two shapes near each other must not be closer than two pixels to each other. The six rule-violating pixels shown in the second stage 2002 have a violation amount of 0.1 to 0.4 pixels.
[0151] In some embodiments, the automatic correction process 1800 specifies these violation amounts or values derived from these amounts as length adjustment amounts in the adjustment map specified in 1815. In some embodiments, the automatic correction process 1800 also defines one marker in region 2012 to identify it as a single layout region containing two sections of two shapes 2000 and 2006 that violate the spacing rule, and associates six pixels in region 2012 with this marker. The values of these six pixels and the values of some nearby pixels are then adjusted together to resolve this single rule violation, as will be detailed later. In other embodiments, the automatic correction process 1800 defines two different markers for each identified spacing violation, one marker being (1) defined along the boundary of each shape 2000 or 2006 and (2) associated with the identified rule-violating pixels of that shape for its associated spacing violation.
[0152] In some embodiments, the automatic correction process performs a curve fitting operation to calculate the pixel dose adjustment value shown in the third stage 2003, using the original pixel dose value shown in the first stage 2001 and the adjustment amount (in the adjustment map) identified for the pixels in region 2012 shown in the second stage 2002. To calculate the adjustment value, in some embodiments, the automatic correction process uses the inverse function of the function used to map the dose value to the location of the shape contour passing through the pixels (i.e., a function that maps the location of the shape contour to the pixel dose value). To solve this inverse function, different embodiments use different solution methods, such as a local gradient search process or a nonlinear optimization process.
[0153] After calculating the pixel dose adjustment value, the calculated pixel dose adjustment value is then added to the original pixel dose value from the first step 2001 to obtain the two modified shapes 2005 and 2007 shown in the fourth step 2004. This curve fitting operation is a variable resizing operation because different pixel dose adjustment values can be specified for different pixels.
[0154] The contours of the corrected shapes 2005 and 2007 no longer exist within each other's two pixels at any position along the contour. As shown in the third stage 2003, the pixel dose adjustment value includes not only a pixel dose value that corrects the pixel dose values of the six rule-violating pixels in region 2012, but also a pixel dose adjustment value that corrects the pixel dose values of a certain number of neighboring pixels around these six rule-violating pixels.
[0155] These pixel dose adjustment values for adjacent pixels and for rule-violating pixels ensure that the corrected shapes 2005 and 2007 have the desired contour characteristics (e.g., smooth contours). In other words, the curve fitting operation in some embodiments ensures that the automatic correction does not result in undesirable contours in the automatically corrected shapes (e.g., shapes with jagged edges). Some of the calculated pixel dose adjustment values move the contour of the shape from one pixel to another (e.g., changing the dose value of a pixel that previously had a decimal dose value to 1, changing the dose value of a pixel that previously had a dose value of 0 to a decimal, etc.).
[0156] In some embodiments shown in Figure 20, the curve fitting operation first generates a pixel dose adjustment value based on the original pixel dose value and the adjustment amount specified by the adjustment map, and then adds the generated pixel dose adjustment value to the original pixel dose value. However, in other embodiments, the curve fitting operation does not first generate a pixel dose adjustment value that is later added to the original pixel dose value. These embodiments directly generate the modified pixel dose value of the modified shape by using the original pixel dose value and the specified adjustment amount specified in the adjustment map of the rule-violating pixels identified by the rule-checking process. Under this curve fitting technique, the pixel dose adjustment value is implicitly calculated and applied to the pixel dose value of the original shape to generate the modified shape as part of the curve fitting operation. In addition, the curve fitting operation in these embodiments also ensures that the modification to the shape does not result in undesirable contour characteristics for the shape (e.g., ensuring that the shape has smooth edges).
[0157] In the examples shown in Figures 19 and 20, the pixel dose map is an RTM dose map where the pixel dose value directly relates to the extent to which the pixel is covered by the shape. As described above, other embodiments use CTM and QTM dose map values where the pixel dose value is indirectly related to the extent to which the pixel is covered by the shape (for example, by using a function that maps dose values to pixels).
[0158] Design rule checking and mask rule checking are two steps commonly performed throughout the process of designing and manufacturing ICs. Figure 21 conceptually illustrates an example of one such process for designing and manufacturing an IC. Process 2100 in this figure uses the pixel-based design and mask rule checking operations described above to ensure that the design layout and mask layout generated by the process do not violate one or more design rules and mask rules.
[0159] Process 2100 begins by defining code that specifies the IC design (in 2105) and performing functional verification and testing against this code. In some embodiments, the process specifies the code using one of the common hardware description languages (HDL). In some embodiments, the HDL code describes the desired structure, behavior, and timing of the IC. To perform functional verification and testing against the code of the IC, some embodiments specify one or more modules and / or circuit components in the code and check the functional accuracy of the specified modules and / or circuit components.
[0160] Next, process 2100 (in 2110) performs a synthesis operation, which converts the HDL description into a circuit representation that typically includes digital circuit components such as logic gates, flip-flops, and other larger digital components (e.g., adders, multipliers, etc.). The synthesis operation is typically performed by a synthesis tool.
[0161] In step 2115, process 2100 performs verification and testing on the circuit representation generated by the synthesis operation. In some embodiments, verification and testing checks the circuit representation to determine whether it satisfies the desired timing constraints and any other constraints of the HDL code. If verification and testing fails (for example, if part of the circuit representation does not meet the constraints), process 2100 returns to step 2110 (indicated by a dashed arrow) and performs synthesis again to modify the circuit representation to resolve this failure.
[0162] If the verification and testing in 2115 is successful, process 2100 performs a set of physical design operations 2118, including operations 2120-2135, in which process 2100 may be repeated multiple times, as will be detailed later. In 2120, process 2100 performs a floorplan operation that defines the general location for some or all of the circuit blocks (e.g., various large circuit blocks). For example, in some embodiments, the floorplan divides the design layout into one or more sections dedicated to different purposes (e.g., ALU, memory, decoding, etc.) and assigns some or all of the circuit blocks to these sections based on the purpose that these blocks serve.
[0163] In 2125, process 2100 performs a placement operation, which defines a specific position and orientation for each circuit block in the design layout based on floor plan data. The placement operation is an automated process that attempts to find the optimal placement for each circuit block based on one or more optimization criteria, such as the congestion or estimated length of interconnects (e.g., metal wiring) required to connect the nets associated with the circuit blocks. In some embodiments, a net includes two or more sets of pins of one or more circuit blocks that need to be electrically connected (e.g., via sets of wiring, contacts and / or vias). After performing the placement operation, process 2100 may return to the floor plan operation if it determines that the floor plan needs to be modified to improve the results of the placement operation.
[0164] Once the placement operation is completed without issue, the process performs a routing operation (in 2130) that defines the routes necessary to connect each net (i.e., connect each set of pins that need to be interconnected). Each defined route includes one or more interconnect segments (also called wiring segments) that traverse one or more interconnect layers (also called wiring layers), and one or more vias and / or contacts that connect pins and / or wiring segments on different wiring layers.
[0165] To define routes, some embodiments divide routing operations into global routing operations and detailed routing operations. For each net, global routing defines a global route that more generally defines the route of the net (e.g., defines a general area in the design layout that the route traverses). For example, in some embodiments, the global router divides the IC into individual global routing areas called Gcells. Then, for each net, a Groute is created by listing the global routing areas (Gcells) that the global route (Groute) of that net should traverse.
[0166] Detailed routing defines the actual route for each net (for example, a route connecting the set of pins that make up the net). As described above, each defined route includes one or more interconnect segments that traverse one or more interconnect layers and one or more vias and / or contacts that connect pins and / or wiring segments on different interconnect layers. In some embodiments, the detailed router uses the global router's Group data when performing its detailed routing operation, for example, by biasing the detailed route discovery of the net to the Group regions traversed by the Global Router.
[0167] During or after the detailed routing operation, process 2100, in some embodiments, performs DRC operations to ensure that the defined routes do not violate design rules. In some embodiments, process 2100 performs one or more of the design rule checks for each defined route using the pixel-based DRC operations described above. One example of a design rule check performed on a route is to ensure that the route is not closer to another route or component in the design layout on each layer the route traverses than the minimum acceptable spacing requirement for that layer. A route that violates the minimum spacing constraint can result in excessive capacitance and, in some cases, cause an electrical short circuit in the IC.
[0168] In some embodiments, process 2100 may iterate through global routing and detailed routing multiple times to identify a better Global for some nets in order to improve the detailed routes of those nets or other nets. In some embodiments, process 2100 may also return from any of these routing operations to a preceding operation in the EDA flow (e.g., a placement operation) to improve the result of this preceding operation in order to improve the routes defined by a later routing operation.
[0169] After routing, process 2100 performs a compaction operation (in 2135). In some embodiments, the compaction operation compresses the design layout in one or more directions to reduce the size of the IC die manufactured based on the design layout (e.g., reduce the two-dimensional area of the IC die). By reducing the size of the IC, the performance of the IC is improved in some embodiments. The compressed design layout also reduces the cost of ICs manufactured using the design layout, as more ICs can be manufactured on a given wafer size.
[0170] After the compaction operation, process 2100 (in 2140) performs a layout verification operation to ensure that the compressed design layout (e.g., the compressed route in this design) satisfies one or more verification criteria. This verification operation includes a DRC operation to ensure that the compressed design layout does not violate design rules. In some embodiments, process 2100 uses the pixel-based DRC operation described above to perform one or more of its design rule checks on different items in the design layout (e.g., the route, pins, and other components of the design layout).
[0171] One example of a design rule check performed on a given route is to ensure that the route is not closer to another route or component in the design layout on a layer than the minimum acceptable spacing requirement for each layer the route traverses. Other examples of design rule checks include, as mentioned above, the minimum area, minimum width, and maximum curvature of an item's shape in the design layout (e.g., a route, pin, contact, via, or other component).
[0172] Layout verification, in some embodiments, includes other operations such as extraction. Extraction, in some embodiments, calculates parasitic values (e.g., parasitic capacitance or parasitic inductance) acting on items (e.g., wiring segments) in the design layout. In some embodiments, the extraction operation calculates capacitance coefficients for one or more conductive components in the design layout (e.g., for each wiring segment or each entire route in the design layout) and uses the capacitance coefficients to calculate the parasitic effect (e.g., capacitance, resistance, or inductance) on the conductive components.
[0173] After the compaction operation in 2135 or the subsequent verification operation 2140, process 2100 may, in some embodiments, return to a preceding operation in the EDA flow (e.g., placement operation, global routing operation, or detailed routing operation) to improve the results of this preceding operation, such as improving the compressed design defined by the subsequent compaction operation. For example, if the design was not verified in 2140 (e.g., if a design problem was detected during verification), process 2100 may return to the preceding physical design operations 2120-2135 and perform this physical design operation and any subsequent physical design operations again on part or all of the design layout. In some embodiments, the design layout that exists after the compaction operation and has passed the subsequent verification operation 2140 on this layout is the final result of the physical design process, referred to as the physical design layout, and is used as input to subsequent operations 2145-2155 that form the manufacturing subprocess of process 2100.
[0174] In some embodiments, the physical design subprocess includes other operations not shown in Figure 21. These other operations are not shown for brevity. Examples of such operations include partitioning, power planning, and clock tree synthesis (CTS). In some embodiments, partitioning divides the design layout into subsets of similar size to ensure that the number of connections between subsections is minimized. Power planning defines a power delivery network (PDN) that includes interconnections for supplying power from power supply circuits to the circuits defined by the IC design layout. In some embodiments, CTS defines a clock delivery network for supplying one or more clock signals to the circuits defined by the IC design layout. In some embodiments, CTS also inserts buffers and / or inverters along the clock signal paths on the clock delivery network to balance the load and reduce or eliminate clock skew or delay.
[0175] In some embodiments, the manufacturing subprocess includes a mask generation operation (in 2145) which is performed after a physical design verification operation (in 2140) has been performed and it has been verified that the physical design layout passes one or more verification criteria. In some embodiments, mask generation includes mask layout generation, mask simulation, and wafer simulation. Mask layout generation defines the mask layout using commonly known techniques such as OPC (Optical Proximity Correction) and / or ILT (Inverse Lithography Technique) operations.
[0176] During or after mask layout generation, process 2100 performs MRC operations to ensure that the shapes defined in the mask layout do not violate MRC rules. In some embodiments, process 2100 uses the pixel-based MRC operations described above to perform one or more MRC rule checks on each shape in the mask layout. Examples of MRC rules include minimum spacing, minimum width, maximum curvature, and minimum area of shapes in the mask layout.
[0177] The mask simulation operation simulates mask production using the generated mask layout. In some embodiments, the mask simulation includes operations such as mask data preparation (MDP) and mask process correction (MPC). In some embodiments, MDP prepares a mask layout for a mask drawing device. In some embodiments, this operation includes "fracturing" the data into trapezoids, rectangles, or triangles. In some embodiments, MPC geometrically modifies the shape and / or assigns doses to the shape in order to bring the resulting shape on the mask closer to a desired shape. MDP can take the generated mask layout or the result of the MPC as input. MPC may be performed as part of fracturing or other MDP operations. Other corrections may also be performed as part of fracturing or other MDP operations. In some embodiments, the mask simulation operation also calculates several possible mask images by using charged particle beam simulation.
[0178] In some embodiments, the wafer simulation operation calculates possible patterns to be generated on a manufactured IC by using a mask generated based on a mask layout. In some embodiments, the wafer simulation operation includes a lithography simulation using the calculated mask image. Further descriptions of mask generation, mask simulation, and wafer simulation operation are provided in U.S. Patent No. 8,719,739, entitled “Method and System for Forming Patterns Using Charged Particle Beam Lithography,” which is incorporated herein by reference.
[0179] After a wafer simulation is performed on a given mask layout, the generated wafer pattern is inspected to determine whether the mask layout should be modified and / or whether one or more physical design operations should be repeated to modify the physical design layout. In some embodiments, wafer pattern inspection includes comparing the generated simulated wafer pattern with an ideal target pattern (e.g., to ensure that the predicted wafer image is within the minimum deviation of the target wafer image).
[0180] Additionally or alternatively, this inspection includes performing a DRC check (such as the pixel-based DRC check described above) on the generated wafer pattern predicted by the wafer simulator to appear on the IC die. In some embodiments, process 2100 may iteratively repeat suboperations of mask generation operation 2145 (i.e., mask layout generation, mask simulation, and wafer simulation) to improve the overall quality of the generated mask, or it may return to one of the preceding physical design operations 2118 as described above.
[0181] Once the mask layout is generated and verified, process 2100 generates the specified masks for all layers of the IC based on the mask layout. In some embodiments, mask generation converts each mask image (also called a mask layer in some embodiments) of the mask layout into one or more lithography masks. Once the masks are generated, process 2100 (in 2150) performs wafer fabrication to manufacture multiple IC dies on an IC wafer (e.g., a silicon wafer) using the generated masks. Masks for the substrate and each wiring layer are used to generate the devices and wiring on the substrate and each wiring layer of each IC die. Typically, each IC die is tested. If the IC die test determines that the IC has defects due to the IC design or mask, process 2100 must return to the preceding operation and improve the design layout, mask layout, or mask generation operation. Finally, process 2100 (in 2155) performs packaging to place each IC die into a single chip package. In some embodiments, packaging includes slicing the wafer into multiple IC dies, placing each die on a substrate, and encapsulating them to form a chip package. After packaging is completed, process 2100 ends.
[0182] While several embodiments have been described above relating to performing pixel-based rule checking on design layouts and / or mask layouts used in the design and / or manufacture of ICs, those skilled in the art will understand that other embodiments can be used to perform pixel-based rule checking on design layouts and mask layouts created for the design and manufacture of silicon interposers (e.g., wiring patterns on silicon interposers).
[0183] Further embodiments are used to design and manufacture patterns on other types of substrates. For example, some embodiments use the pixel-based rule process described above to check design layouts for designing displays such as flat panel displays (e.g., monitors, televisions, glasses, etc.) or curved displays (e.g., displays for virtual reality or augmented reality headsets) and / or mask layouts for manufacturing such displays. Such design layouts define a pattern of controllable pixels on a display substrate, and such mask layouts define masks that can be used to deploy such a pattern of controllable pixels on a display substrate.
[0184] Further embodiments use the pixel-based rule process described above to check design layouts for designing other patterns of other elements for other substrates and / or mask layouts for deploying these other patterns of other elements on such other substrates. Examples of such other substrates include substrates used in the manufacture of micro-electromechanical systems (MEMS) and other such similar devices.
[0185] Many of the features and applications described above are implemented as software processes, specified as a set of instructions recorded on a computer-readable storage medium (also called a computer-readable medium). When these instructions are executed by one or more processing units (e.g., one or more processors, processor cores, or other processing units), these instructions cause the processing units to perform the actions instructed by the instructions. Examples of computer-readable media include, but are not limited to, CD-ROMs, flash drives, RAM chips, hard drives, and EPROMs. Computer-readable media do not include carrier waves and electronic signals transmitted via wireless or wired connections.
[0186] In this specification, the term “software” includes firmware residing in read-only memory or applications stored in magnetic storage devices that can be loaded into memory for processing by a processor. In some embodiments, multiple software inventions may be implemented as sub-parts of a larger program while remaining separate software inventions. In some embodiments, multiple software inventions may also be implemented as separate programs. Finally, any combination of separate programs that implement together the software inventions described herein is within the scope of the invention. In some embodiments, a software program defines one or more specific mechanical embodiments that, when installed to run on one or more electronic systems, perform and carry out the operation of the software program.
[0187] Figure 22 conceptually illustrates an electronic system 2200 in which several embodiments of the present invention are implemented. The electronic system 2200 may be a computer (e.g., a desktop computer, personal computer, tablet computer, server computer, mainframe, blade computer, etc.), a telephone, a PDA, or any other type of electronic device. As shown in the figure, the electronic system includes various types of computer-readable media and interfaces for various other types of computer-readable media. Specifically, the electronic system 2200 includes a bus 2205, a processing unit 2210, a system memory 2225, a read-only memory 2230, a persistent storage device 2235, an input device 2240, and an output device 2245.
[0188] Bus 2205 collectively refers to all system buses, peripheral buses, and chipset buses that communicate with a number of internal devices of the electronic system 2200. For example, bus 2205 communicates with the processing unit 2210 to read-only memory (ROM) 2230, system memory 2225, and persistent storage device 2235. From these various memory units, the processing unit 2210 obtains instructions to be executed and data to be processed in order to perform the process of the present invention. The processing unit may be a single processor or a multi-core processor in various embodiments.
[0189] ROM 2230 stores static data and instructions required by the processing unit 2210 and other modules of the electronic system. On the other hand, persistent storage device 2235 is a read-write memory device. This device is a non-volatile memory unit that stores instructions and data even when the electronic system 2200 is turned off. Some embodiments of the present invention use a mass storage device (such as a magnetic or optical disk and its corresponding disk drive) as the persistent storage device 2235.
[0190] Other embodiments use removable storage devices (such as floppy disks or flash drives) as persistent storage devices. Similar to the persistent storage device 2235, the system memory 2225 is a read-write memory device. However, unlike the storage device 2235, the system memory is a volatile read-write memory, such as random-access memory. The system memory stores some of the instructions and data that the processor needs at runtime. In some embodiments, the processes of the present invention are stored in the system memory 2225, the persistent storage device 2235, and / or the read-only memory 2230. From these various memory units, the processing unit 2210 retrieves the instructions to be executed and the data to be processed in order to execute the processes of some embodiments.
[0191] Bus 2205 also connects to input device 2240 and output device 2245. The input device allows the user to communicate information to the electronic system and select commands. Input device 2240 includes an alphanumeric keyboard and a pointing device (also called a "cursor control device"). Output device 2245 displays images generated by the electronic system. Output device includes a printer and a display device such as a cathode ray tube (CRT) or liquid crystal display (LCD). Some embodiments include a device such as a touchscreen that functions as both an input and output device.
[0192] Finally, as shown in Figure 22, bus 2205 also connects electronic system 2200 to network 2265 via a network adapter (not shown). In this way, the computer may be part of a network of several networks, such as a local area network ("LAN"), a wide area network ("WAN"), an intranet, or the Internet. Any or all components of electronic system 2200 may be used in conjunction with the present invention.
[0193] Some embodiments include electronic components such as a microprocessor, storage, and memory for storing computer program instructions in a machine-readable or computer-readable medium (referred to as computer-readable storage medium, machine-readable medium, or machine-readable storage medium). Some examples of such computer-readable media include RAM, ROM, read-only compact discs (CD-ROM), recordable compact discs (CD-R), rewritable compact discs (CD-RW), read-only digital multipurpose discs (e.g., DVD-ROM, dual-layer DVD-ROM), various recordable / rewritable DVDs (e.g., DVD-RAM, DVD-RW, DVD+RW, etc.), flash memory (e.g., SD card, miniSD card, microSD card, etc.), magnetic and / or solid-state hard drives, read-only and recordable Blu-ray (registered trademark) discs, ultra-high density optical discs, any other optical or magnetic media, and floppy disks. A computer-readable medium is executable by at least one processing unit and can store a computer program containing a set of instructions for performing various operations. Examples of computer programs or computer code include files containing machine code, such as that generated by a compiler, and high-level code executed by a computer, electronic component, or microprocessor using an interpreter.
[0194] The above discussion primarily refers to microprocessors or multicore processors that run software, but some embodiments are implemented by one or more integrated circuits, such as application-specific integrated circuits (ASICs) or field-programmable gate arrays (FPGAs). In some embodiments, such integrated circuits execute instructions stored within the circuit itself.
[0195] As used herein, the terms “computer,” “server,” “processor,” and “memory” all refer to electronic devices or devices of other technologies. These terms exclude humans or groups of humans. For the purposes of this specification, the terms “display” or “display” mean to display on an electronic device. As used herein, the terms “multiple computer-readable media,” “one computer-readable media,” and “machine-readable media” are entirely limited to tangible physical objects that store information in a form readable by a computer. These terms exclude any radio signals, wired download signals, and any other transient or temporary signals.
[0196] Although the present invention has been described with reference to many specific details, those skilled in the art will recognize that the invention can be embodied in other specific forms without departing from the spirit of the invention. For example, some drawings conceptually illustrate a process. Certain operations of these processes do not have to be performed in the exact order illustrated and described. Certain operations do not have to be performed in a single consecutive series of operations, and different specific operations may be performed in different embodiments. Furthermore, a process may also be implemented using several subprocesses or as part of a larger macroprocess. Accordingly, those skilled in the art will understand that the invention is not limited by the above-described exemplary details but is defined by the appended claims.
Claims
1. A method for performing rule checking on a set of shapes in a layout used to design or manufacture components on a circuit board, Assigning multiple pixels, which are part of the aforementioned layout, to multiple processing threads executed by one or more processing units, Using a specific processing thread assigned to each specific pixel, rule checks are performed on a set of shapes that fall within a threshold distance of the said specific pixel. After identifying a rule check violation for the aforementioned specific pixel, record a set of one or more layout locations associated with the identified rule check violation in storage for subsequent analysis and modification of the layout to resolve the identified rule check violation. A method that includes this.
2. Assigning the aforementioned multiple pixels means Assigning each specific pixel in the area of the layout to a different processing thread to determine whether the pixel is located along the boundary of the shape in the layout, For each specific pixel determined to exist along the boundary of a specific shape, dynamically generate an edge that passes through the specific pixel. including, and The method according to claim 1, wherein using each specific processing thread includes performing the rule check using one or more dynamically generated edges produced by one or more processing threads.
3. The method according to claim 2, wherein each processing thread stores any edges dynamically generated by the processing thread in memory shared with other processing threads, so that all processing threads have access to any edges dynamically generated by any other processing thread in order to enforce the rule check violations of pixels allocated to the processing thread.
4. The method according to claim 1, wherein each specific processing thread includes using a first processing thread assigned to a first pixel to (i) define a search window centered on the first pixel, and (ii) within the search window, identify a pair of pixels that (1) lie along one or more boundaries of one or more shapes in the layout, and (2) violate the rule check.
5. The method according to claim 4, wherein the first processing thread determines that the identified pixel pair violates the rule check by determining that two dynamically generated edges for the pixel pair violate the rule check.
6. The method according to claim 5, wherein the two dynamically generated edges of the identified pixel pair are generated by the first processing thread.
7. The method according to claim 5, wherein the two dynamically generated edges of the identified pixel pair are generated by two processing threads other than the first processing thread, and the different processing threads dynamically generate different edges along the same or different shapes and share those dynamically generated edges with each other.
8. The aforementioned rule check is, (i) Spacing rule check to apply the minimum spacing between different shapes in the layout, (ii) Width rule check to ensure that each shape in the layout has a minimum width, (iii) Area rule check to ensure that each shape in the layout has the minimum area, and (iv) Maximum curvature rule check to ensure that no shape in the layout has a curvature exceeding the maximum curvature value. The method according to claim 1, comprising one of the following.
9. The method according to claim 1, wherein the layout is a mask layout for manufacturing the component on the substrate.
10. The method according to claim 1, wherein the layout is a design layout used to specify the design of the components on the substrate.
11. The method according to claim 1, wherein different processing threads are executed simultaneously on different processing units, which are different processors or different cores of one or more processors.
12. The method according to claim 1, wherein the set of processing units is a set of processing units of one or more computers, and each processing thread (i) receives a pixel-based definition of the shape, (ii) generates data and stores it in one or more sets of volatile runtime memories of the set of computers, and (iii) after the processing thread has completed its operation, causes the stored data to be discarded from the memory set.
13. The method according to claim 1, further comprising performing a rasterization operation to generate a pixel-based definition of each shape from a contour-based definition used to define the shape in the layout.
14. The method according to claim 1, further comprising modifying the layout to resolve the identified rule check violations.
15. The method of claim 14, wherein modifying the layout includes, in the user interface, displaying the location of the rule-check violations relating to the shape in the layout, and receiving manual edits to the shape from the designer to resolve the rule-check violations.
16. The method according to claim 14, wherein modifying the layout includes, without user input, an automated process of identifying modifications to the shape in the layout to resolve the identified rule check violations, and modifying the shape based on the identified modifications.
17. A method for detecting and correcting rule violations in a layout used to design or manufacture components on a circuit board, Identifying one or more shapes in the layout that violate the rules applied to the layout by examining different pixels in the pixel representation of the layout, wherein the pixel representation of the layout includes (i) a plurality of pixels and (ii) for each pixel a value representing the extent to which the pixel is covered by the shape in the layout. To correct the shape and thereby resolve the rule violation, an automated process is implemented to modify two or more sets of values for two or more sets of pixels associated with the shape identified as violating the rule. A method that includes this.
18. The method according to claim 17, wherein the value of each pixel is either (i) a first value when the pixel is entirely within the shape, (ii) a second value when the pixel is entirely outside any shape, and (iii) a decimal value or a percentage value representing the amount of the pixel covered by the boundary when the pixel is along the boundary of the shape.
19. The method according to claim 17, wherein the automated process modifies the set of two or more pixel values without receiving user input.
20. The method according to claim 17, wherein each value of each pixel is an RTM (raster tone map) value that directly represents the extent to which the pixel is covered by the shape.
21. The method according to claim 17, wherein each value of each pixel is a QTM (quantized tone map) value that indirectly represents the extent to which the pixel is covered by the shape.
22. The method according to claim 17, wherein inspecting different pixels includes defining a search window centered on a first pixel, and within the search window, identifying a pair of pixels that (1) lies along one or more boundaries of one or more shapes in the layout, and (2) violates the rule.
23. The method according to claim 22, wherein identifying the pair of pixels includes dynamically generating two edges that traverse the two pixels and lie along two boundaries of the one or more shapes, and determining that the two dynamically generated edges violate the rule.
24. Inspecting different pixels is Identifying specific pixels that exist along the boundaries of the shape in the aforementioned layout, Dynamically generating edges that pass through the aforementioned specific pixels, The rules are checked using the dynamically generated edges. The method according to claim 17, including the method described in claim 17.
25. The method according to claim 17, wherein the rule ensures that no two edges of two nearby shapes are closer than a threshold distance.
26. The method according to claim 17, wherein the rule ensures that no two edges of a shape are closer than a threshold distance.
27. A non-temporary machine-readable medium for storing a program for carrying out the method according to any one of claims 1 to 26.
