Layout design rule checking method, system, equipment, medium and product

Abstract

The invention relates to an application method of a GPU (Graphics Processing Unit) in design rule inspection in the field of integrated circuits, in particular to a layout design rule inspection method, system and equipment, a medium and a product. The layout design rule checking method comprises the following steps: inputting initial layout data, analyzing a design rule checking task to be executed, and marking the priority and complexity level of the task; the method comprises the following steps: dividing layout data into a plurality of data blocks according to regions on the basis of regional characteristics of the layout data, distributing tasks and corresponding data blocks to a GPU computing core according to task priorities and complexity levels, and distributing new data blocks according to the overall load condition of the GPU computing core after the GPU computing core completes data block processing, and repeating the steps until all tasks are executed, and outputting a layout design rule check result. The system, the computer equipment, the computer readable storage medium and the computer program product have the same beneficial effects as the layout design rule checking method.

Description

TECHNICAL FIELD

[0001] The present application relates to the field of integrated circuit design, and in particular to a layout design rule checking method, system, device, medium and product. BACKGROUND

[0002] In the field of integrated circuit design, design rule checking is a key link to ensure chip manufacturing yield. With the evolution of semiconductor technology to advanced processes, the scale and complexity of integrated circuit layout grow exponentially, and traditional design rule checking methods are difficult to meet the demand in efficiency and accuracy. Graphics processing unit (GPU) provides a new way to accelerate design rule checking with its powerful parallel computing capability, which can significantly shorten the checking time by processing a large amount of data in parallel.

[0003] However, in practical applications, there is a serious problem of load imbalance when applying GPU to design rule checking. On the one hand, design rule checking tasks are diverse, such as geometry size checking, spacing checking, and interlayer connection checking, with significant differences in computational complexity. The layout area with simple rule shapes has small computational load, while the complex irregular structure requires a large number of geometric and Boolean operations, resulting in uneven load of GPU computing cores. On the other hand, the density and scale of integrated circuit layout data vary in different regions, with large and complex data volume in key functional modules and small and simple data volume in auxiliary modules, which easily causes load imbalance of GPU computing cores when distributing tasks according to physical distribution.

[0004] In addition, traditional static task allocation strategies only divide computing tasks according to task types or data regions, which cannot adapt to dynamic changes in task execution and cannot meet the needs of design rule checking task diversity and complexity, seriously affecting the utilization of GPU computing resources and the processing efficiency of design rule checking tasks. SUMMARY

[0005] To solve the technical problem of uneven load of GPU computing cores caused by task complexity differences, data scale imbalance, and limitations of traditional static allocation strategies in the process of applying GPU to design rule checking, the present application provides a layout design rule checking method, system, device, medium and product.

[0006] The solution to the technical problem of the present invention is to provide a layout design rule checking method, comprising the following steps: inputting initial layout data and a design rule file, parsing the design rule file, obtaining all design rule checking tasks to be executed, marking the priority and complexity level of each design rule checking task according to the task type and the characteristics of the layout area involved; dividing the layout data into multiple data blocks according to the regional characteristics of the initial layout data; monitoring the load of the GPU computing core in real time, and allocating the design rule checking task and its corresponding data block to the GPU computing core according to the priority and complexity level of the design rule checking task; after the GPU computing core completes the data block processing, The method allocates new design rule checking tasks and their corresponding data blocks according to the overall load of the computing core; repeats the above task allocation steps until all design rule checking tasks are completed, and outputs the layout design rule checking results; wherein the priority of the design rule checking task is marked according to at least one of the following information: the dependency between tasks, whether the layout data area involved in the task belongs to the wiring part or the fixed unit layout part, and whether the task belongs to the check of basic rules or the check of complex rules; and / or, the complexity level of the design rule checking task is marked according to at least one of the following information: the size of the area of ​​the layout data involved in the task, the wiring density of the layout data area involved in the task, and the complexity of the rules checked by the task.

[0007] Preferably, the characteristics of the layout data region include the computational complexity of the layout data, and the size of the data blocks divided into the layout data region with high computational complexity is smaller than the size of the data blocks divided into the region with low computational complexity.

[0008] Preferably, when the GPU computing core processes the design rule checking task, the following steps are also included: real-time monitoring of the GPU computing core, when the load of the GPU computing core exceeds a preset threshold, migrating part of the tasks of the high-load GPU computing core to the low-load GPU computing core.

[0009] Preferably, the priority and complexity level of the design rule task are adjusted according to the load of the GPU computing core, and / or the size of the layout data area data block is adjusted.

[0010] Preferably, the load status of the GPU computing core includes at least one of the following load information: the number of completed tasks, the estimated remaining time of the current task, the video memory utilization, the computing core utilization, the task execution queue length, and the memory access frequency.

[0011] The application further provides a layout design rule checking system, which comprises a user terminal and a micro-service terminal in communication connection; the micro-service terminal receives a to-be-processed command input by the user terminal, and executes the steps of the layout design rule checking method according to the to-be-processed command.

[0012] Preferably, the to-be-processed command is stored in a script file, and when the preset command does not uniquely match the to-be-processed command and / or there is no preset command matching the to-be-processed command, the execution of the script file is interrupted.

[0013] The application further provides a computer device, which comprises a storage, a processor and a computer program stored in the storage; the processor executes the computer program to realize the steps of the layout design rule checking method.

[0014] The application further provides a computer readable storage medium, which stores a computer program; the computer program realizes the steps of the layout design rule checking method when executed by a processor.

[0015] The application further provides a computer program product, which comprises a computer program; the computer program realizes the steps of the layout design rule checking method when executed by a processor.

[0016] Compared with the prior art, the layout design rule checking method, system, device, medium and product provided by the application have the following advantages: 1. The layout design rule checking method provided by the embodiment of the application overcomes the technical problem that, in the prior art, the GPU is applied to the design rule checking process, and due to the difference in task complexity, the imbalance in data size and the limitation of the traditional static allocation strategy, the load of the GPU computing core is imbalanced. Specifically, the layout design rule checking method divides the priorities of all design rule checking tasks based on the dependency relationship, the involved region features and the complexity of the rules involved by the tasks before performing the design rule checking, and determines the execution sequence of each design rule checking task before the tasks are allocated to the GPU computing core. The complexity level of the tasks is further divided based on the size of the layout region involved by the tasks, the wiring density of the layout region, and the rule complexity of the task checking; and the complexity level is pre-divided to provide an accurate basis for subsequent dynamic load balancing.

[0017] Further, the layout data is divided into multiple data blocks according to regions, and the data blocks corresponding to tasks are distributed to GPU computing cores for processing according to the priority and complexity level of the tasks, so that the calculation load in the data blocks distributed to each GPU computing core is relatively balanced, and local task backlog and core idling caused by differences in complexity of layout regions are effectively avoided. After processing the data blocks, new design rule checking tasks are distributed to the GPU computing cores according to the overall load of the GPU computing cores, so as to maintain the relatively balanced load of the GPU computing cores.

[0018] In addition, the layout design rule checking method provided by the present application can automatically optimize the task allocation strategy and data processing mode according to the priority, complexity and data size of the tasks. Whether it is processing a simple data region or dealing with a complex key function module layout, the load of each computing core can be balanced to ensure stable operation of the system.

[0019] 2. The layout design rule checking method provided by the embodiment of the present application is based on the calculation complexity of the layout data, and the size of the data block divided for a layout data region with high calculation complexity is smaller than the size of the data block divided for a region with low calculation complexity; that is, for a region with high calculation complexity, each data block contains fewer layout units; and for a region with low calculation complexity, each data block contains more layout units. By dividing the layout data regions into data blocks of different sizes based on the calculation complexity, the calculation load is pre-balanced at the data level, and each GPU computing core is provided with task units with similar calculation amounts, thereby laying the foundation for efficient parallelism and effectively eliminating the local performance bottleneck caused by traditional uniform block division, significantly improving the overall utilization efficiency of hardware resources. Further, by dynamically distributing data blocks, the amount of data processed by each computing core within a period of time and the calculation complexity are relatively balanced.

[0020] 3. The layout design rule checking method provided by the embodiment of the present application further includes real-time monitoring of the GPU computing cores, and when it is confirmed that the load of the GPU computing cores exceeds a preset threshold, part of the tasks of the GPU computing cores with high load are migrated to the GPU computing cores with low load. By real-time monitoring of the load of the GPU computing cores and adjusting the distribution of tasks, the GPU computing cores with high load are avoided from being long-term backlog, and the GPU computing cores with low load are in an idle state, which leads to unbalanced load of the GPU computing cores and seriously slows down the overall processing speed of the tasks.

[0021] 4、The layout design rule checking method provided by the embodiment of the present application adjusts the priority and / or complexity level of the design rule checking task and / or adjusts the data block partition size of the layout data region when the load condition of the GPU computing core exceeds the preset threshold value. Through this adaptive adjustment mechanism, the system can dynamically respond to the runtime load fluctuation, optimize the task scheduling and resource allocation strategy in real time, thereby continuously maintaining the efficient load balancing among the GPU computing cores and significantly improving the adaptability to different layout checking tasks and the overall stability of the system.

[0022] 5、The layout design rule checking method provided by the embodiment of the present application acquires the load information of the GPU computing core, including the number of completed tasks, the estimated remaining time of the current task, the utilization rate of the display memory, the utilization rate of the computing core, the length of the task execution queue, and the memory access frequency, so as to judge the overall load condition of the GPU computing core from multiple aspects, thereby realizing more accurate task allocation and data processing.

[0023] 6、The embodiment of the present application further provides a layout design rule checking system, which comprises a user terminal and a micro-service terminal in communication connection; the micro-service terminal receives the inputted processing command of the user terminal and executes the steps of the above layout design rule checking method according to the processing command.

[0024] It should be noted that the layout design rule checking system provided by the present application has the same beneficial effects as the above layout design rule checking method, which will not be repeated here.

[0025] 7、The embodiment of the present application further provides a computer device, which comprises a storage, a processor, and a computer program stored in the storage; the processor executes the computer program to realize the steps of the above layout design rule checking method.

[0026] It should be noted that the computer device provided by the present application has the same beneficial effects as the above layout design rule checking method, which will not be repeated here.

[0027] 8、The embodiment of the present application further provides a computer readable storage medium, which stores a computer program; the computer program realizes the steps of the above layout design rule checking method when executed by a processor.

[0028] It should be noted that the computer readable storage medium provided by the present application has the same beneficial effects as the above layout design rule checking method, which will not be repeated here.

[0029] 9、The embodiment of the present application further provides a computer program product, which comprises a computer program; the computer program realizes the steps of the above layout design rule checking method when executed by a processor.

[0030] It should be noted that the computer program product provided by the present application has the same beneficial effects as the layout design rule checking method described above, and will not be repeated here. BRIEF DESCRIPTION OF DRAWINGS

[0031] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings needed to be used in the embodiments or prior art description will be briefly introduced as follows. Obviously, the drawings in the following description are only some embodiments of the present application, and other drawings can also be obtained by those skilled in the art without creative labor.

[0032] Figure 1 is a flowchart of steps S1 to S5 in a layout design rule checking method provided by an embodiment of the present application.

[0033] Figure 2 is a layout data block diagram of a layout design rule checking method provided by an embodiment of the present application.

[0034] Figure 3 is a flowchart of a layout design checking method provided by an embodiment of the present application to determine whether the GPU exceeds the preset threshold.

[0035] Figure 4 is a framework diagram of a layout design rule checking system provided by an embodiment of the present application.

[0036] Figure 5 is a framework diagram of a computer device provided by an embodiment of the present application.

[0037] Figure 6 is a framework diagram of a computer readable storage medium provided by an embodiment of the present application.

[0038] Figure 7 is a framework diagram of a computer program product provided by an embodiment of the present application.

[0039] BRIEF DESCRIPTION OF DRAWINGS 1. A layout design rule checking system; 11, user end; 12, micro-service end; 2. Computer device; 21, storage; 22, processor; 3. Computer readable storage medium; 4. Computer program product; 100. Computer program; A, layout data; A1, layout data area with high computational complexity; A2, layout data area with low computational complexity. DETAILED DESCRIPTION

[0040] In order to make the objects, technical solutions and advantages of the present application clearer, the present application will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely intended to explain the present application and should not be used to limit the present application.

[0041] In the embodiments provided by the present application, it should be understood that "B corresponding to A" means that B is associated with A, and B can be determined according to A. However, it should also be understood that the determination of B according to A does not mean that B is determined only according to A, but B can also be determined according to A and / or other information.

[0042] It should be understood that "one embodiment" or "an embodiment" mentioned throughout the specification means that the specific features, structures or characteristics related to the embodiment are included in at least one embodiment of the present application. Therefore, "in one embodiment" or "in an embodiment" appearing throughout the specification does not necessarily refer to the same embodiment. In addition, these specific features, structures or characteristics can be combined in one or more embodiments in any suitable manner. Those skilled in the art should also know that the embodiments described in the specification are all optional embodiments, and the actions and modules involved are not necessarily required by the present application.

[0043] In various embodiments of the present application, it should be understood that the size of the serial number of the above processes does not mean the inevitable sequence of execution, and the execution sequence of the processes should be determined according to its function and inherent logic, and should not constitute any limitation on the implementation process of the embodiments of the present application.

[0044] In the flowcharts and block diagrams of the drawings of the present application, the possible implementation architecture, function and operation of the system, method and computer program product according to various embodiments of the present application are illustrated. In this regard, each block in the flowchart or block diagram can represent a module, a program segment or a part of code containing one or more executable instructions for implementing the specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks can also occur in a different order from that indicated in the drawings. For example, two blocks indicated in succession can actually be executed substantially in parallel, and sometimes they can be executed in reverse order, based on the functions involved. It should be particularly noted that each block in the block diagram and / or flowchart, and the combination of blocks in the block diagram and / or flowchart, can be implemented by a dedicated hardware-based system performing the specified functions or operations, or can be implemented by a combination of special-purpose hardware and computer instructions.

[0045] In the field of integrated circuit design, when GPU is applied in design rule checking, tasks are usually allocated according to physical distribution, ignoring the diversity of design rule checking task types and the difference between different task computing complexities. Further, the density and scale of integrated circuit layout data are different in different regions, the data amount of key functional modules is large and complex, and the data amount of auxiliary modules is small and simple. Task allocation according to physical distribution is easy to cause load imbalance of GPU computing cores.

[0046] To solve the technical problem that, in the prior art, GPU is applied in the design rule checking process, due to the difference in task complexity, the imbalance in data scale, and the limitation of traditional static allocation strategy, leading to load imbalance of GPU computing cores, the present application provides a layout design rule checking method, system, device, medium and product.

[0047] First, please refer to Figure 1 The layout design rule checking method provided by the embodiment of the present application comprises the following steps: S1: input initial layout data and a design rule file, parse the design rule file to obtain all design rule checking tasks to be executed, and mark a priority and a complexity level for each design rule checking task according to the task type and the features of the layout region involved; S2: divide the layout data into multiple data blocks according to regions based on the region features of the initial layout data; S3: monitor the load condition of GPU computing cores in real time, and allocate design rule checking tasks and their corresponding data blocks to the GPU computing cores according to the priority and complexity level of the design rule checking tasks; S4: after the GPU computing cores complete data block processing, allocate new design rule checking tasks and their corresponding data blocks according to the overall load condition of the GPU computing cores; S5: repeat the above steps S3-S4 until all design rule checking tasks are executed, and output the layout design rule checking result.

[0048] It can be understood that the layout design rule checking method provided by the embodiment of the present application overcomes the technical problem that, in the prior art, GPU is applied in the design rule checking process, due to the difference in task complexity, the imbalance in data scale, and the limitation of traditional static allocation strategy, leading to load imbalance of GPU computing cores.

[0049] Specifically, the layout design rule checking method divides all design rule checking tasks into priorities based on the dependency relationship, the involved region features, and the complexity of the task involved rules before performing the design rule checking, and determines the execution order of each design rule checking task before assigning the task to the GPU computing core. The task complexity level is also divided based on the layout region size involved by the task, the wiring density of the layout region, and the rule complexity of the task checking; and the complexity level is divided in advance to provide accurate basis for subsequent dynamic load balancing.

[0050] Further, the layout data is divided into multiple data blocks according to regions, and the data blocks corresponding to the tasks are assigned to the GPU computing cores for processing according to the priority and complexity level of the task, so that the computing load in the data block assigned to each GPU computing core is relatively balanced, effectively avoiding local task backlog and core idling caused by the complexity difference of the layout region. After processing the data block, new design rule checking tasks are assigned to the GPU computing cores according to the overall load of the GPU computing cores, so as to maintain the relative balance of the load of the GPU computing cores.

[0051] In addition, the layout design rule checking method provided by the present application can automatically optimize the task allocation strategy and data processing mode according to the priority, complexity and data size of the task. Whether it is processing a simple data region or dealing with a complex key function module layout, the load balance of each computing core can be maintained to ensure stable operation of the system.

[0052] The specific steps S1 to S5 of the layout design rule checking method will be described below.

[0053] First, in step S1, the initial layout data is input, and all design rule checking tasks to be executed are parsed, and the priority and complexity level of each design rule checking task are marked according to the task type and the features of the design layout region.

[0054] The priority of the design rule checking task is marked according to at least one of the following information: the dependency relationship between tasks, whether the layout data region involved by the task belongs to the wiring part or the fixed cell layout part, whether the task belongs to the checking of basic rules or the checking of complex rules.

[0055] In the design rule checking for integrated circuits, the dependency relationship between design rule checking tasks mainly reflects the mandatory constraint of the execution order. For example, some set rule checking must be based on the completion of the geometric Boolean operation of the related layer as a prerequisite; for example, the preparation work for the data divided on the layout is superior to the checking work of the design rule. This dependency relationship ensures the logical correctness of the checking process and avoids task blocking or errors due to unmet dependencies.

[0056] That is, the design rule checking task depends on the priority of the preceding task, which is lower than the preceding task it depends on.

[0057] When the layout data region involved in the task belongs to the layout part of the fixed cell, since the layout part of the fixed cell is relatively stable and the change cost is high, the design rule checking task can be performed later.

[0058] Therefore, if the layout data region involved in the design rule checking task is the layout part of the fixed cell, the priority of the task is higher than the task whose layout data region is the layout part of the fixed cell.

[0059] When the design rule checking task involves the checking of basic rules, such as the checking of minimum line width and minimum spacing, this type of task is simple and fast, and can quickly find obvious errors. When the design rule checking task involves the checking of complex rules, such as the checking of layer alignment and electrical rules, this type of task takes a long time and may require more computing resources. The priority of the checking task of the basic rules is higher than that of the checking task of the complex rules, which can quickly exclude obvious errors and then deeply check complex problems, improve the overall checking efficiency, and avoid wasting resources on the layout with basic errors.

[0060] Based on the dependency relationship between tasks, the layout data region involved in the task is the layout part of the fixed cell, and finally the priority is divided into three levels of high, medium and low according to whether the task rule belongs to the checking of basic or complex rules.

[0061] Based on the priority determination mechanism, an efficient and orderly execution sequence can be constructed before the design rule checking task is started, ensuring that critical tasks occupy computing resources first, significantly reducing delays caused by dependency waiting or error accumulation, optimizing the load distribution of GPU computing cores from the source, and improving the overall checking efficiency and iteration speed.

[0062] The complexity level of the design rule checking task is marked according to at least one of the following information: The size of the layout data region involved in the task, the wiring density of the layout data region involved in the task, and the complexity of the rules checked by the task.

[0063] It can be understood that the complexity level of the task with large layout data region is higher than that of the task with small layout data region; the complexity level of the task involving dense wiring region is higher than that of the task involving simple wiring region; the more complex the rules checked by the task, the higher the complexity level.

[0064] Based on the above three aspects, the complexity level of the design rule checking task can be classified into high, medium and low levels.

[0065] In some preferred embodiments, the system quantifies the final complexity level estimate (Estimated Complexity, EC) of the task through a product model, which is calculated as: EC = A × D × R. Wherein, A represents the normalized estimate of the size of the layout area involved in the task, D represents the normalized estimate of the wiring density of the area, and R represents the normalized estimate of the complexity of the checked rule itself. According to the distribution of EC values of all tasks, the system classifies them into high, medium and low complexity levels in proportion. This comprehensive evaluation method avoids the limitations of single dimension and can more accurately predict the computational load of the task.

[0066] By classifying the complexity level of the task, the computational intensity of each design rule checking task can be predicted, providing a key basis for subsequent GPU resource allocation and dynamic scheduling, thereby fundamentally avoiding the risk of load imbalance and maximizing parallel computing efficiency.

[0067] Based on the analysis of the design rule checking task, the task will be classified into different priority levels and complexity levels before the design rule checking task starts to execute. For example, high-precision transistor size checking is marked as high priority and high complexity because it directly determines the electrical characteristics of the device and the calculation involves precise geometric measurement; while the regular interlayer insulation spacing rule is simple and has relatively minor impact on performance, and is marked as low priority and low complexity. Classifying design rule checking tasks provides basic information for subsequent load balancing allocation.

[0068] Based on the classification of the design rule checking task, a task priority list, a task complexity level label, and a task dependency graph are generated.

[0069] In step S2, the features of the layout data area corresponding to the design rule checking task are obtained, and the layout data is divided into multiple data blocks according to the features.

[0070] The features of the layout data area include the features obtained when classifying the priority and complexity level of the task, and the computational complexity of the layout data area is measured by obtaining the associated features of the layout data area and the task.

[0071] According to the computational complexity of each region of the layout data, the layout data is divided into data blocks of appropriate size to generate a data block list. The data block list includes the layout data area to which the data block belongs, the estimated computational amount, and the associated task ID.

[0072] In some embodiments, when the layout data is divided into blocks, the data block size of a region with high computational complexity is smaller than that of a region with low computational complexity. For example, for a region with high complexity such as a processor core, the division size of the data block is small, and each data block contains fewer layout units; for example, for a simple region such as a power routing, the division size of the data block is large, and each data block contains more layout units.

[0073] Referring to Figure 2 For example, in layout data A, A1 is a region of layout data with high computational complexity, and A2 is a region of layout data with low computational complexity, wherein the data block size of the A1 region is smaller than that of the A2 region.

[0074] By dividing the layout data regions into data blocks of different sizes based on computational complexity, the computational load is pre-balanced at the data level, providing each GPU computing core with task units of similar computational amount, thereby laying the foundation for efficient parallelism, effectively eliminating the local performance bottleneck caused by traditional uniform blocking, and significantly improving the overall utilization efficiency of hardware resources. Further, by dynamically allocating data blocks, the amount of data processed by each computing core is relatively balanced over time.

[0075] In some embodiments, the blocking of the layout data also takes into account its physical continuity, i.e., when dividing the data blocks, layout units that are adjacent in physical location and need to be processed simultaneously by the same design rule check are preferentially divided into the same data block. This effectively ensures that most of the data required for geometric rule checking is completed within a single data block, minimizing cross-block data access, transmission, and synchronization operations caused by processing boundary graphics, thereby significantly reducing communication overhead, improving the actual data processing throughput of the GPU computing core, and reducing cross-block data interaction.

[0076] In step S3, the load of the GPU computing core is monitored in real time, and the design rule check tasks are assigned to the GPU computing core according to the priority and complexity level of the design rule check tasks.

[0077] By monitoring the load of the GPU computing core in real time, the load information of the GPU computing core is obtained, including but not limited to: the number of completed tasks, the estimated remaining time of the current task, the utilization rate of the video memory, the utilization rate of the computing core, the length of the task execution queue, the memory access frequency, and other key indicators. The overall load of the GPU computing core is determined from multiple aspects to achieve more accurate task allocation and data processing.

[0078] At the beginning of the design rule checking task execution, based on the task priority list, task complexity level label and task dependency graph generated in step S1, the data blocks corresponding to the tasks of high priority and medium complexity level are preferentially allocated to the low-load GPU computing cores. According to the real-time feedback of the load of the GPU computing core, the data blocks corresponding to the tasks allocated to the high-load GPU computing core and the data blocks of the tasks not bound to the GPU computing core are allocated to the low-load GPU computing core.

[0079] It can be understood that the initial state of the low-load GPU computing core is "idle and light load", and the utilization rate of the computing unit, the memory surplus, the cache occupation and other computing resources are in a relatively relaxed state. If the data blocks corresponding to the tasks of high priority and high complexity are directly allocated, the following two problems may occur.

[0080] First, the computing resources are saturated at a moment; high complexity level tasks usually involve a large number of set operations, Boolean operations or high-precision checks, which require continuous occupation of a large number of computing cores and memory resources. The low-load GPU computing core may suddenly undertake the processing of such task data blocks, and directly jump from the "low-load" state to the "high-load" state, or even run out of resources, thereby becoming a new load bottleneck.

[0081] Second, the task execution period is prolonged; the high complexity level task has a long predicted execution time, and additional overheads may be generated during the process due to data dependency or intermediate result interaction. If the low-load GPU computing core is occupied by the high complexity level task for a long time, it will not be able to quickly respond to new task allocation, reducing the flexibility of the overall task scheduling.

[0082] And allocating the data blocks corresponding to the tasks of high priority and medium complexity level to the low-load GPU computing core can control the demand for resources, quickly utilize the idle resources of the low-load GPU computing core, and ensure that the core is in a "high-efficiency and unsaturated" state, maintaining the overall dynamic balance.

[0083] The core of dynamic scheduling is to achieve load balancing by frequently adjusting light tasks. If high complexity level tasks are introduced, it will be difficult to quickly correct the load deviation during task allocation and scheduling, and even cause global load shock.

[0084] In step S4, if the GPU computing core completes the processing of the data block, the data block corresponding to the new design rule checking task is allocated according to the overall load of the GPU computing core.

[0085] When a GPU computing core finishes processing a data block, the data block involved in the task of the high-load core or the data block of the task not yet bound to the core will be allocated to an existing idle low-load GPU computing core in combination with the real-time load of each GPU computing core. The data block involved in the task is allocated to the GPU computing core with efficient data transmission to ensure load balancing of each core.

[0086] In step S5, the above steps S3-S4 are repeated until all design rule checking tasks are executed and the layout design rule checking result is output.

[0087] Referring to Figure 3 In some embodiments, when the above steps S3 and S4 are executed, the following step is also executed synchronously: real-time monitoring of the GPU computing core, and when the load of the GPU computing core exceeds the preset threshold, the data block involved in the task of the high-load GPU computing core is migrated to the low-load GPU computing core.

[0088] The preset threshold can be defined as a multi-dimensional dynamic triggering condition, and the judgment basis includes but is not limited to: a preset upper limit of the utilization rate of the GPU computing core, and / or the number of data blocks to be processed in the task queue of the GPU computing core exceeds the processing capacity of the core, and / or the preset upper limit of the saturation state of the memory bandwidth usage, and can be further combined with the duration of the above load state to make a judgment.

[0089] For example, the preset threshold can be defined as: when the GPU computing core utilization rate is higher than 90% and the duration is more than 5 minutes.

[0090] By setting the preset threshold, an explicit and quantifiable load balancing triggering benchmark is provided for the system, which ensures that the system can timely and accurately identify the core with abnormal load, thereby maintaining the efficient and stable operation of the entire design rule checking process.

[0091] In some embodiments, when the load of the GPU computing core exceeds the preset threshold, the priority and / or complexity level of the design rule checking task are adjusted, and / or the block size of the layout data region data block is adjusted.

[0092] Specifically, when it is detected that the GPU computing core exceeds the preset threshold, the priority weight of some key region checking tasks can be automatically increased to speed up the completion of the task, or the segmentation granularity of the data block in the high-load GPU computing core is temporarily refined to achieve more fine-grained load dispersion.

[0093] Through the dynamic adjustment and adaptive capability, the task scheduling strategy and data distribution can be continuously optimized when the design rule checking task is assigned, and the adaptability to the complex layout data checking scene is significantly improved. Through real-time feedback and detection, the task assignment, data block division and related parameters are dynamically adjusted to adapt to the change of the design rule checking task and data, so that the efficient and stable load balancing level is still maintained under the condition of limited hardware resources.

[0094] The steps of the layout design rule checking method provided by the embodiment of the application solve the technical problem that, in the prior art, the GPU is applied to the design rule checking process, the load of the GPU computing core is unbalanced due to the difference in task complexity, the imbalance in data scale and the limitation of the traditional static allocation strategy.

[0095] Through the above layout design rule checking method, the initial layout data is input, the design rule checking task to be executed is parsed, and the priority and complexity level of the task are marked. Based on the features of the layout data region, the layout data is divided into multiple data blocks according to the region, and the task and the corresponding data block are allocated to the GPU computing core according to the priority and complexity level of the task. After the GPU computing core completes the data block processing, new data blocks are allocated according to the overall load of the GPU computing core, and the above steps are repeated until all the tasks are checked, and the layout design rule checking result is output.

[0096] The layout design rule checking method classifies the design rule checking task according to the priority and complexity level, lays a foundation for the load balancing task allocation of the GPU computing core, avoids wasting GPU computing resources caused by only fixedly dividing the computing task according to the task type or data region, and ignores the priority and complexity difference of the task. Further, the layout region is divided into data blocks, so that the GPU computing core processes each data block, and the flexible scheduling of the task is realized. Finally, the subsequent task allocation and scheduling are performed based on the real-time monitoring of the load of the GPU computing core, the utilization rate of the GPU computing resource and the processing efficiency of the design rule checking task are improved, and the load balancing layout design rule checking method is realized.

[0097] Please refer to Figure 4 The embodiment of the application also provides a layout design rule checking system, which comprises a user terminal 11 and a micro service terminal 12 in communication connection; the micro service terminal 12 receives a to-be-processed command input by the user terminal 11, and executes the steps of the above layout design rule checking method according to the to-be-processed command.

[0098] It can be understood that the micro-service end 12 is responsible for executing the steps of the above-mentioned layout design rule checking method, and outputs a preset command uniquely matched with the to-be-processed command to the user end 11 after executing the related steps, and the user end 11 submits the preset command to the interpreter for checking and parsing after receiving the preset command, and finally executes by the EDA software.

[0099] It should be noted that the layout design rule checking method provided by the foregoing embodiments is implemented by using the micro-service-based layout design rule checking system 1, and the micro-service is specifically to separate a single-module unit from an original, comprehensive monomer application, so that the original software architecture is more clear and simple, so as to update, maintain and further iterate and improve the function that can be implemented by the single-module unit.

[0100] Specifically, the layout design rule checking system 1 of the embodiment of the application separates the layout design rule checking function in the integrated circuit design software to form the micro-service end 12, through this design, the person skilled in the art or the user skilled in the integrated circuit design software only needs to deploy a set of micro-service of the layout design rule checking in advance, and can request the micro-service on the integrated circuit design software of different versions in the local area network, and then realizes the layout design rule checking through the micro-service end 12, and reduces the occupation of the memory resource.

[0101] In some embodiments, the to-be-processed command is stored in a script file, and when the preset command is not uniquely matched with the to-be-processed command, and / or there is no preset command matched with the to-be-processed command, the execution of the script file is interrupted.

[0102] Please refer to Figure 5 The embodiment of the application also provides a computer device 2, which comprises a storage 21, a processor 22 and a computer program 100 stored on the storage 21, and the processor 22 executes the computer program 100 to realize the steps of the above-mentioned layout design rule checking method.

[0103] It can be understood that the computer device 2 provided by the embodiment of the application has the same beneficial effects as the layout design rule checking method provided by the above-mentioned embodiment when the computer device 2 is running and the processor 22 executes the computer program 100.

[0104] In some embodiments, the computer device 2 is a computer device applied to the field of integrated circuit design technology, including but not limited to obtaining initial layout data, parsing design rule checking tasks, dividing layout data into multiple data blocks, assigning data blocks to GPU computing cores, obtaining the load conditions of the GPU computing cores, etc., which will not be described here. In theory, the method steps involved in the technical solutions of the present application can be realized by participating in the control of the computer device 2, and the related parameters involved can also be adjusted by the computer device 2. The related parameters include but are not limited to the preset command set and the preset option set.

[0105] In some embodiments, the processor 22 provided by the embodiments of the present application is a general-purpose processor, which is a microprocessor or any conventional processor, such as a central processing unit (CPU), a digital signal processor (DSP), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA) or other programmable logic device, a discrete gate or transistor logic device, a discrete hardware component, which can implement or execute the methods, steps and logic block diagrams disclosed in the embodiments of the present application.

[0106] In some embodiments, the method steps disclosed in the embodiments of the present application can be implemented by a hardware processor or a combination of hardware and software modules in the processor 22.

[0107] Please refer to Figure 6 The embodiments of the present application also provide a computer readable storage medium 3, which stores a computer program 100, and the computer program 100 implements the steps of the layout design rule checking method when executed by a processor.

[0108] It can be understood that the computer readable storage medium 3 provided by the embodiments of the present application stores a computer program 100, and the computer program 100 can be called by a processor to execute the layout design rule checking method described in the above embodiments.

[0109] It should be noted that the computer readable storage medium 3 provided by the embodiments of the present application has the same beneficial effects as the layout design rule checking method provided by the above embodiments, which will not be described here.

[0110] Specifically, the computer readable storage medium 3 can include at least one type of storage medium, such as flash memory, hard disk, multimedia card, card-type memory, random access memory (RAM), static random access memory (SRAM), programmable read-only memory (PROM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), magnetic memory, magnetic disk, optical disk, etc.

[0111] In some embodiments, the computer readable storage medium 3 comprises a non-volatile computer readable storage medium, which can be used to store non-volatile software programs, non-volatile computer executable programs and modules.

[0112] In particular, the computer readable storage medium 3 has storage space for computer programs 100 that perform any of the method steps of the above layout design rule checking method, which can be read from or written into one or more computer program products.

[0113] In some embodiments, the computer programs 100 can be compressed in an appropriate form.

[0114] Referring to Figure 7 The embodiments of the present application also provide a computer program product 4 comprising the computer programs 100, which, when executed by a processor, implement the steps of the above layout design rule checking.

[0115] It can be understood that the computer program product 4 provided by the embodiments of the present application comprises the computer programs 100, and the computer programs 100 can be called by a processor to execute the layout design rule checking method described in the above embodiments, which will not be described here.

[0116] The layout design rule checking method, layout design rule checking system, device, medium and product disclosed by the embodiments of the present application are described in detail above, and the principles and implementation manners of the present application are described by applying specific examples. The above embodiment descriptions are only used to help understand the method of the present application and its core idea.

[0117] Meanwhile, for those skilled in the art, according to the idea of the present application, there will be changes in specific implementation manners and application ranges, and the above description should not be understood as a limitation of the present application. Any modification, equivalent replacement and improvement within the principles of the present application should be included in the protection scope of the present application.

Claims

1. A layout design rule checking method, characterized in that: The following steps are involved: Input the initial layout data and design rule file, parse the design rule file, obtain all the design rule checking tasks to be executed, and mark the priority and complexity level of each design rule checking task based on the task type and the characteristics of the layout area involved; Based on the regional features of the initial layout data, dividing the layout data into multiple data blocks according to the regions; Monitor the GPU computing core's load in real time and assign design rule checking tasks and their corresponding data blocks to the GPU computing core according to their priority and complexity level. After the GPU computing core completes data block processing, assign new design rule checking tasks and their corresponding data blocks based on the overall GPU computing core load. Repeat the above task assignment steps until all design rule checking tasks are completed, and output the layout design rule checking results; The priority of the design rule check task is marked according to at least one of the following information: Dependencies between tasks, whether the layout data area involved in the task belongs to the routing part or the fixed cell layout part, whether the task belongs to the basic rule check or the complex rule check; and / or, The complexity level of a design rule checking task is marked based on at least one of the following: The size of the layout data area involved in the task, the wiring density of the layout data area involved in the task, and the complexity of the rules checked by the task.

2. The layout design rule checking method according to claim 1, wherein: The characteristics of the layout data area include the computational complexity of the layout data, and the size of the data blocks divided into the layout data area with high computational complexity is smaller than the size of the data blocks divided into the area with low computational complexity.

3. The layout design rule checking method according to claim 1, wherein: When the GPU computing core processes the design rule checking task, the following steps are also included: Monitor the GPU computing core in real time. When the load of the GPU computing core exceeds a preset threshold, migrate the data blocks involved in some tasks of the high-load GPU computing core to the low-load GPU computing core.

4. The layout design rule checking method according to claim 3, wherein: When the load of the GPU computing core exceeds a preset threshold, the priority and / or complexity level of the design rule checking task is adjusted, and / or the size of the data block of the layout data area is adjusted.

5. The layout design rule checking method according to claim 3, wherein: The load status of the GPU computing core includes at least one of the following load information: The number of completed tasks, the estimated remaining time of the current task, video memory utilization, computing core utilization, task execution queue length, and memory access frequency.

6. A layout design rule checking system, characterized by: The layout design rule checking system includes a user end and a microservice end that are communicatively connected; The microservice end receives the pending command input by the user end, and executes the steps of the layout design rule checking method according to any one of claims 1 to 5 according to the pending command.

7. The layout design rule checking system according to claim 6, wherein: The command to be processed is stored in a script file. When the preset command does not uniquely match the command to be processed, and / or there is no preset command matching the command to be processed, the execution of the script file is interrupted.

8. A computer device comprising a memory, a processor, and a computer program stored on the memory, wherein: The processor executes the computer program to implement the steps of the layout design rule checking method according to any one of claims 1 to 5.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the computer program implements the steps of the layout design rule checking method according to any one of claims 1 to 5.

10. A computer program product comprising a computer program, characterized in that When the computer program is executed by a processor, the computer program implements the steps of the layout design rule checking method according to any one of claims 1 to 5.

Images