Parallel computing-based reverse photoetching OPC polygon data processing method and system

Abstract

The invention relates to the technical field of photoetching data processing, in particular to a reverse photoetching OPC polygon data processing method and system based on parallel computing, and the system comprises a hierarchical task decomposition module, a dynamic load balancing module, a multi-stage data partitioning module, an edge smoothing module, a global optimization module, a compression coding module and the like. The polygon data processing efficiency is improved through a hierarchical task decomposition and dynamic load balancing strategy; boundary errors are reduced through cooperation of multi-stage data partition and edge smoothing; compact data representations are generated by sparse coding and entropy coding. According to the method, the calculation time can be remarkably shortened, the photoetching precision and the resource utilization rate are improved, and large-scale layout design requirements are met.

Description

Technical Field

[0001] This invention relates to the field of photolithography data processing technology, and more specifically, to a method and system for processing reverse photolithography OPC polygon data based on parallel computing. Background Technology

[0002] In recent years, with the continuous shrinking of integrated circuit process nodes and the rapid increase in chip design complexity, optical proximity correction (OPC) has become increasingly important in photomask design. Inverse lithography (ILT), as an advanced lithography optimization method, can significantly improve exposure results by accurately simulating and optimizing polygonal contours. However, within the current technological framework, ILT calculations involve contour optimization, edge smoothing, and light intensity distribution calculations for a large amount of polygonal data. The computational load is enormous, and the algorithms are complex, making it difficult to meet the demands of rapid iteration in chip design.

[0003] Existing polygon data processing methods primarily rely on serial computation, processing each polygon one by one. This results in lengthy reverse lithography processes and limited real-time optimization capabilities. Especially in large-scale layout or high-density chip design scenarios, computation time increases exponentially with data size, limiting the effectiveness of traditional methods in shortening design cycles and enabling rapid iteration. Furthermore, complex polygon data processing flows easily introduce boundary errors and accumulated data deviations, further impacting lithography accuracy. Moreover, current technologies offer limited support for efficient parallel computing in polygon data processing, failing to fully utilize multi-core CPUs, GPUs, or other parallel computing resources. Due to complex data dependencies and inadequate task partitioning, direct parallelization faces significant challenges, hindering speed improvements.

[0004] Therefore, with the continuous upgrading of process nodes and the increasing complexity of chip design, there is an urgent need for a reverse lithography method and system that can efficiently process polygon data in parallel, so as to significantly improve processing efficiency while ensuring computational accuracy and meet the needs of rapid iteration and large-scale mask design. Summary of the Invention

[0005] This invention addresses the problems of low efficiency in polygon data processing, accumulated boundary errors, and insufficient utilization of parallel computing resources in existing technologies by introducing a hierarchical task decomposition mechanism and a dynamic load balancing strategy, combined with multi-level data partitioning and feature extraction modules. This method significantly improves the polygon contour optimization capability in large-scale layout design while reducing algorithm complexity and computation time.

[0006] To achieve the above objectives, this invention proposes a method for processing reverse lithography OPC polygon data based on parallel computing, comprising: A polygon data processing framework based on hierarchical task decomposition is constructed, and a dynamic load balancer is designed to divide polygon data into multiple independent task units. Based on task units, computing resources are allocated on multi-core CPUs or GPUs, and a distributed storage mechanism is used to cache and manage polygon data. The contour information of each polygon is divided into blocks based on the multi-level data partitioning module to generate block feature descriptors. Based on the combination of block feature descriptors and edge smoothing modules, a local light intensity distribution matrix is ​​generated. Based on the local light intensity distribution matrix and the global optimizer, the geometric parameters of the polygon contour are adjusted to generate optimized polygon data. Based on the optimized polygon data, a compact polygon representation is generated by a compression encoder and output to the mask design system.

[0007] Furthermore, when the dynamic load balancer generates a dynamic load balancing strategy based on task units, it includes: Based on real-time monitoring of the computational load of each polygon data processing task, a task load distribution map is generated. Adjust the allocation ratio of computing resources based on the task load distribution map and dynamic load balancer; The adjusted computing resource allocation ratio is mapped to the thread scheduler of a multi-core CPU or GPU to generate task scheduling instructions.

[0008] Furthermore, when the multi-level data partitioning module divides the contour information of each polygon into blocks, it includes: The vertex coordinate sequence of each polygon is divided into multiple sub-regions using a spatial partitioning algorithm; Feature extraction is performed on the vertex coordinate sequence of each sub-region to generate block feature descriptors; The block feature descriptor is matched with the feature descriptors of adjacent sub-regions to generate a consistency check result.

[0009] Furthermore, when the spatial partitioning algorithm divides the vertex coordinate sequence of each polygon to generate multiple sub-regions, it includes: The vertex coordinate sequence of each polygon is mapped to a two-dimensional grid space based on the grid partitioning algorithm; Perform density analysis on each grid cell in the two-dimensional grid space to generate a grid density distribution map; Based on the grid density distribution map, the boundary of each sub-region is determined using an adaptive threshold algorithm.

[0010] Furthermore, when the edge smoothing module generates the local light intensity distribution matrix based on the block feature descriptor, it includes: The block feature descriptor is input into the edge smoothing filter to generate a smoothed vertex coordinate sequence; The local light intensity distribution gradient is calculated based on the smoothed vertex coordinate sequence, and a local light intensity distribution matrix is ​​generated. The local light intensity distribution matrix is ​​combined with the constraints of the global optimizer to generate the optimization objective function.

[0011] Furthermore, when the global optimizer adjusts the geometric parameters of the polygon contour based on the local light intensity distribution matrix, it includes: The geometric parameters of each polygon are iteratively optimized based on the objective function to generate intermediate optimization results; Boundary error correction is applied to the intermediate optimization results to generate the final optimization results; The final optimization result is mapped to the vertex coordinate sequence of the polygon outline to generate optimized polygon data.

[0012] Furthermore, when the compression encoder generates a compact polygon representation based on the optimized polygon data, it includes: The optimized polygon data is used to generate a sparse representation vector through a sparse coding algorithm; The sparse representation vector is quantized to generate a quantized representation vector. The quantized representation vector is then used to generate a compact polygonal representation through an entropy coding algorithm.

[0013] Furthermore, when generating sparse representation vectors for optimized polygonal data, the sparse coding algorithm includes: Feature dictionary is generated by extracting features from optimized polygon data based on dictionary learning algorithm. The feature dictionary is matched with the optimized polygon data to generate a sparse representation vector; Redundancy analysis is performed on the sparse representation vector to generate sparsity evaluation results.

[0014] Furthermore, when the entropy coding algorithm generates a compact polygonal representation of the quantized representation vector, it includes: The quantized representation vector is symbolized using the Huffman coding algorithm to generate a symbolic representation sequence. Perform frequency statistics on the symbolic representation sequence to generate a frequency distribution table; A compact polygonal representation is generated based on an arithmetic coding algorithm and a frequency distribution table.

[0015] Compared with existing technologies, the advantages of this invention are as follows: By constructing a polygon data processing framework based on hierarchical task decomposition, a structured decomposition of reverse lithography computation tasks is achieved. By dividing large-scale polygon data into multiple independent task units and introducing a dynamic load balancing controller, tasks can be adaptively allocated according to the real-time load of computing nodes, effectively avoiding computational congestion on some nodes and significantly improving the overall utilization of computing resources and parallel efficiency. This mechanism allows the system to be flexibly expanded in multi-core CPU or GPU clusters, thereby meeting the computational needs of photomask designs of different scales. Secondly, a distributed storage and cache management mechanism is adopted during task execution, enabling polygon data to be efficiently transmitted and shared among multiple computing nodes, reducing data read / write bottlenecks and communication latency. This mechanism not only improves data access speed but also ensures the consistency and reliability of computational results among multiple nodes, fundamentally improving the stability and scalability of the reverse lithography process. Furthermore, at the polygon data processing level, this invention introduces a multi-level data partitioning module to process the contour information of complex polygons in blocks and generate feature descriptors, enabling accurate extraction of morphological and edge features at the local scale, providing more representative input data for subsequent optical simulations. By combining with an edge smoothing module, the system effectively suppresses jagged edges of polygons and optimizes contour continuity, thereby improving the imaging accuracy and consistency of the lithographic pattern during exposure. Simultaneously, through collaborative control based on the local intensity distribution matrix and a global optimizer, the geometric parameters of the polygon contour are adaptively adjusted, achieving a balance between local detail optimization and global optical consistency. This mechanism not only improves the accuracy of reverse lithography results but also reduces redundant overhead caused by repetitive calculations in traditional methods. Finally, by using a compression encoder to compactly encode the optimized polygon data, the amount of data storage and transmission is significantly reduced, enabling the mask design system to load and process layout data more efficiently.

[0016] On the other hand, this application also provides a reverse lithography OPC polygon data processing system based on parallel computing, including: The decomposition module is used to divide polygonal data into multiple independent task units; The dynamic load balancer controller is electrically connected to the decomposition module. The dynamic load balancer controller is used to generate dynamic load balancing strategies based on the computational load of the task units. The data partitioning module is electrically connected to the dynamic load balancer. The data partitioning module is used to divide the contour information of each polygon into blocks and generate block feature descriptors. The edge smoothing module is electrically connected to the data partitioning module. The edge smoothing module is used to generate a local light intensity distribution matrix based on the block feature descriptor. The global optimizer, electrically connected to the edge smoothing module, is used to adjust the geometric parameters of the polygon contour based on the local light intensity distribution matrix to generate optimized polygon data. The compression encoder, electrically connected to the global optimizer, is used to generate a compact polygon representation based on optimized polygon data.

[0017] It is understood that the parallel computing-based reverse lithography OPC polygon data processing method and system module in the above embodiments of the present invention have the same beneficial effects, and will not be described again. Attached Figure Description

[0018] Various other advantages and benefits will become apparent to those skilled in the art upon reading the following detailed description of preferred embodiments. The accompanying drawings are for illustrative purposes only and are not intended to limit the invention. Furthermore, the same reference numerals denote the same parts throughout the drawings. In the drawings: Figure 1 A flowchart illustrating the reverse lithography OPC polygon data processing method based on parallel computing provided in an embodiment of the present invention; Figure 2 A flowchart illustrating the reverse lithography OPC polygon data processing method based on parallel computing provided in an embodiment of the present invention; Figure 3 This is a functional block diagram of a reverse lithography OPC polygon data processing system based on parallel computing, provided in an embodiment of the present invention. Detailed Implementation

[0019] Exemplary embodiments of the present disclosure will now be described in more detail with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be implemented in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided to enable a more thorough understanding of the present disclosure and to fully convey the scope of the disclosure to those skilled in the art. It should be noted that, unless otherwise specified, embodiments and features in the embodiments of the present invention can be combined with each other. The present invention will now be described in detail with reference to the accompanying drawings and embodiments.

[0020] A photomask design system is a professional design platform used to automatically generate and optimize photomask patterns according to integrated circuit layout rules to support semiconductor lithography manufacturing.

[0021] A scheduling algorithm is a type of computational method used to rationally arrange the execution order of tasks under limited resource conditions in order to improve system efficiency and throughput.

[0022] like Figures 1-2 As shown in some embodiments of this application, this embodiment provides a method for processing reverse lithography OPC polygon data based on parallel computing, including: Step S100: Construct a polygon data processing framework based on hierarchical task decomposition and design a dynamic load balancer to divide the polygon data into multiple independent task units.

[0023] Specifically, this invention employs a hierarchical task decomposition technique in the reverse lithography OPC polygon data processing process. This involves breaking down the complex polygon data processing task into multiple clearly structured, parallel-executable hierarchical tasks. Upper-level tasks primarily handle macroscopic control of the global geometric structure and optical constraints, while lower-level tasks focus on microscopic processing of polygon contours, edge details, and local features. This hierarchical architecture effectively reduces computational dependencies, improves task independence, and provides a theoretical foundation for subsequent parallel execution. After task decomposition, this invention further designs a dynamic load balancing controller as a key scheduling unit. This controller dynamically adjusts the task allocation strategy by monitoring the load status of each computing node or core, task execution progress, and data communication latency in real time. Its technical principle lies in utilizing scheduling algorithms (such as minimum load priority, task migration, or resource adaptive allocation algorithms) to achieve optimal allocation of computing resources in a multi-core CPU or GPU cluster. Through this mechanism, a uniform distribution of computational load can be achieved during task execution, avoiding overload or idleness of some nodes, thereby significantly improving the overall throughput and parallel efficiency of the system. Furthermore, this invention incorporates a Task Dependency Graph (TDG) model into its framework design to describe the logical dependencies and computation order among polygonal data. Through static analysis and dynamic adjustment of task dependencies, maximum parallel execution can be achieved while maintaining data consistency. This allows the system to flexibly schedule tasks across different computational layers, ensuring both the correctness of the results and optimizing the execution path.

[0024] Understandably, in traditional reverse lithography OPC polygon data processing, the high coupling between various geometric features and optical computation stages leads to complex computational dependencies and high parallelization difficulty due to the hierarchical task decomposition mechanism. This invention introduces a hierarchical approach into the algorithm structure, breaking down the originally holistic complex task into multiple levels based on data features, geometric complexity, and computational dependencies. Upper-level tasks focus on global parameter and optical constraint control, while lower-level tasks focus on local contour and edge feature optimization. This "macro-micro" hierarchical model theoretically reduces computational coupling between tasks, enabling parallel execution of tasks at different levels while ensuring computational correctness, thus providing structured support for large-scale data parallel processing. Secondly, the dynamic load balancing control principle embodies the adaptive optimization of computing resources. By monitoring parameters such as real-time load, task execution progress, and communication latency of each node in a multi-core CPU or GPU, a resource status feedback model is established, and the task allocation scheme is dynamically adjusted based on scheduling algorithms (such as minimum load priority scheduling, task migration, and resource weighted allocation strategies). The core of this principle lies in enabling computational tasks to adaptively migrate based on node status through load awareness and task reallocation mechanisms. This ensures a balanced computational load within the cluster, maximizing overall throughput and parallel efficiency while avoiding idle or overloaded computing resources. Furthermore, this invention utilizes a Task Dependency Graph (TDG) model to visualize and dynamically analyze logical dependencies between tasks. It models and constrains the computation order and data flow paths between polygonal data using a graph structure where nodes represent tasks and edges represent dependencies. Static dependency analysis is performed before task scheduling to identify a set of tasks that can be executed in parallel. During execution, the dependency graph structure is dynamically adjusted based on task completion status to achieve adaptive optimization of computational paths. This principle ensures that data consistency is not compromised during parallel execution while maximizing the utilization of computing resources, achieving efficient data flow scheduling and dependency management.

[0025] In a specific embodiment of this application, the above steps are implemented as follows: In the preprocessing stage of reverse lithography polygon data, the input mask layout is first analyzed for data features to extract the geometric complexity, boundary node density, and overlap relationship of adjacent regions of each polygon data. Based on these feature parameters, the overall computational task is structurally divided through a hierarchical task decomposition module: the upper-level task is used to handle global contour fitting, optical energy distribution estimation, and layout boundary constraints; the lower-level task is used to refine the edge smoothing, morphological optimization, and error compensation of individual or local polygons. Through this hierarchical mechanism, tasks at different levels can be executed logically independently, reducing cross-layer dependencies and thus achieving a multi-layer parallel computation mode. For example, when performing reverse lithography preprocessing on an advanced process mask layout containing tens of thousands of polygon units, the system first identifies a region with a large number of slender, multi-turn boundary complex auxiliary graphics, and detects that its boundary node density is significantly higher than that of the surrounding region, and that there are multiple small overlaps with adjacent regions. Based on these characteristics, the hierarchical task decomposition module incorporates the overall contour of the region into the upper-level task to perform large-scale contour fitting and estimation of the overall optical energy distribution of the region. Simultaneously, it assigns several polygons with the highest node density to the lower-level task for local edge smoothing, shape contraction compensation, and error correction. This distinction allows the upper-level task to perform global constraint calculations in the background, while the lower-level task iterates rapidly in parallel in a separate processing queue. This enables simultaneous advancement of global contour fitting and local geometric optimization during actual operation, significantly reducing overall processing latency.

[0026] After task partitioning, a dynamic load balancer is invoked to achieve real-time task scheduling and optimized resource allocation. This controller consists of a scheduling unit, a monitoring unit, and a migration unit. The monitoring unit collects real-time data on resource utilization, task execution time, and data communication latency of multi-core CPU or GPU computing nodes. The scheduling unit calculates task allocation priorities based on the monitoring results and dynamically adjusts the distribution of task units across different nodes using adaptive scheduling algorithms (including minimum load priority, weighted task allocation, and resource migration strategies). When the migration unit detects node overload or idleness, it migrates task units to nodes with lower loads with minimal data overhead, thus maintaining a balanced computing state. This mechanism significantly improves resource utilization and overall throughput performance while ensuring computational continuity.

[0027] Furthermore, the monitoring unit continuously collects operating parameters of each computing node, including CPU or GPU utilization, task execution time, memory usage, cache hit rate, and data transmission latency. This monitoring data is normalized by the status analysis module to form a node load vector, which quantitatively reflects the resource usage status of each computing node at the current moment. For example, when the average utilization of a node exceeds 80% and communication latency continues to rise, the node is determined to be in a high-load state; while when the utilization is below 40% and the task queue length is less than the threshold, it is determined to be a low-load node. Secondly, after obtaining the node load vector, the scheduling unit calculates task priority by combining it with the complexity index set of the tasks to be executed. Task complexity indicators include: ① polygonal geometric complexity (such as the number of vertices, boundary node density, and overlap rate of adjacent regions); ② computational dependency depth (determined by the hierarchical relationship in the Task Dependency Graph (TDG); ③ data access density (reflecting the frequency of task access to cache or GPU memory during computation). The scheduling unit calculates the comprehensive computational weight Wt of the task based on these indicators, for example: Wt = α1Cg + α2Dd + α3Am; where ϵ is a minor term to avoid a zero denominator. This priority function represents the comprehensive fitness of task t executed on node n; the larger the value, the higher the scheduling priority of the task on that node. Subsequently, the priority matrices of all tasks and nodes are sorted, prioritizing the allocation of high-weight, low-dependency tasks to low-load nodes to achieve balanced utilization of overall resources. For example, in polygon data processing in reverse lithography OPC, if a task unit involves high-density edge feature extraction and complex optical convolution calculations, its computational weight Wt is high; simultaneously, if the monitoring unit detects that the utilization rate of GPU node A is only 35% and the latency is low, the scheduling unit calculates the priority Pt of this task on node A, where A is the highest, and thus prioritizes the allocation of this task to node A for execution. Conversely, task units with low geometric complexity and deep dependencies are delayed in scheduling or allocated to nodes with higher resource occupancy to maintain a balanced overall task distribution. Finally, monitoring results are continuously updated during task execution, and the priority matrix is ​​dynamically adjusted using a sliding window approach. When the load on a node increases due to new task assignments, the scheduling unit triggers a task migration mechanism to reallocate some low-priority tasks to other idle nodes, achieving adaptive resource rebalancing. This real-time priority adjustment mechanism ensures that high throughput and low latency are maintained in scenarios involving large-scale parallel processing of polygonal data.

[0028] Furthermore, by dynamically adjusting the distribution of task units across different nodes through adaptive scheduling algorithms (including minimum load first, weighted task allocation, and resource migration strategies), real-time load balancing and optimal utilization of computing resources are achieved in multi-core CPU or GPU clusters. This process not only ensures the continuity of task execution and data consistency but also effectively improves overall throughput efficiency and response speed. First, during operation, the monitoring unit collects real-time metrics such as core utilization, task completion rate, GPU memory or cache occupancy, and communication latency for each computing node and converts them into a dynamic load vector. Based on this load information, the scheduling unit prioritizes the minimum load first scheduling strategy: when a new task unit is generated or awaiting allocation, it calculates the real-time load value of all nodes and prioritizes assigning the task to the node with the lowest load value. For example, when the average load of node A is 35%, node B is 60%, and node C is 75%, newly generated local edge optimization tasks will be automatically assigned to node A, thereby maintaining a balanced use of computing resources globally. This strategy can respond quickly in scenarios with large fluctuations in task density, preventing task backlog or node overload. Secondly, when there are significant differences in task complexity, a weighted task allocation strategy will be further implemented. This strategy assigns a corresponding weight coefficient to each task by comprehensively evaluating its computational complexity, data dependency depth, and communication overhead. For example, in reverse lithography OPC polygon data processing, if a task unit involves highly complex optical convolution and boundary correction, its computational weight is higher; while another task only needs to perform local geometric smoothing, its weight is lower. The scheduling unit calculates a comprehensive adaptation value based on the node's remaining computing power and the task weights.

[0029] Where At,n represents the fitness of task t on node n, Rn is the remaining computing resources of the node, Wt is the task weight, and δ is a small term to prevent the denominator from being zero. Based on the dynamic sorting of the fitness matrix, high-weight tasks are preferentially assigned to high-performance nodes, while low-weight tasks are assigned to general nodes, achieving optimal hierarchical allocation of resources. Finally, after running for a period of time, if the monitoring unit detects a significant imbalance in node load, such as task backlog on some nodes or execution time exceeding a set threshold, a resource migration strategy will be triggered. This strategy uses a migration unit to dynamically reallocate tasks across nodes. The migration process is based on the task's execution progress and dependencies: for tasks that have not yet started or are only in the initial stages of execution, data blocks and computation states can be directly migrated between different nodes; while for tasks that are nearing completion, a delayed migration mechanism is used, adjusting the node to which the task belongs only in the next scheduling cycle. For example, when node C experiences a load exceeding 90% due to executing multiple high-complexity tasks, while node B's load is only 40%, some low-priority tasks are automatically migrated from node C to node B, and their task status and cached data are synchronized to achieve real-time balancing. It can be seen that this adaptive scheduling mechanism effectively achieves intelligent distribution and dynamic adjustment of tasks across different nodes. The minimum load priority strategy ensures initial balanced task allocation, weighted task allocation achieves precise matching of computing resources and task complexity, and the resource migration strategy continuously corrects imbalances between nodes during operation. The synergistic effect of these three mechanisms gives the parallel processing of polygonal data a high degree of elasticity and adaptability, maximizing multi-core computing power while maintaining system stability and efficiency.

[0030] Furthermore, to achieve efficient coordination and data consistency among tasks, this embodiment introduces a Task Dependency Graph (TDG) model into the polygon data processing framework. In its implementation, each task unit is represented as a node in the graph, and its input-output relationships or dependency order are represented as directed edges. Through static analysis of the dependency graph, a set of tasks that can be executed in parallel can be identified. During the runtime phase, the dependency graph is updated in real time based on the task completion status, and executable tasks are dynamically released based on the updated dependency structure, thereby achieving maximum parallel execution. This model can establish data synchronization constraints between multi-level tasks, ensuring that the output of the upper layer is correctly transmitted to the input of the lower layer, thus guaranteeing the correctness and consistency of the calculation results.

[0031] In experimental settings, the hierarchical task decomposition and dynamic load balancing mechanism described in this embodiment improves task execution efficiency by approximately 3-5 times compared to traditional serial processing on a multi-core parallel platform, while maintaining a stable computational load distribution even in highly complex layout scenarios. Verification shows that this method significantly reduces overall computation time without affecting reverse lithography accuracy, meeting the high-performance data processing requirements of large-scale mask design at advanced process nodes.

[0032] The above scenarios are merely preferred embodiments of the present invention and are not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

[0033] Step S200: Allocate computing resources on multi-core CPUs or GPUs based on task units, and use a distributed storage mechanism to cache and manage polygon data.

[0034] Specifically, when the dynamic load balancer generates a dynamic load balancing strategy based on task units, it includes: generating a task load distribution map based on real-time monitoring of the computational load of each polygon data processing task; adjusting the computational resource allocation ratio based on the task load distribution map and the dynamic load balancer; and mapping the adjusted computational resource allocation ratio to the thread scheduler of a multi-core CPU or GPU to generate task scheduling instructions.

[0035] Understandably, by monitoring tasks on multi-core CPU or GPU platforms, key metrics such as computational load, cache utilization, task execution progress, and data communication latency of each computing core when processing polygonal data tasks are collected in real time. Based on these dynamic metrics, the system generates a load distribution map, which uses time as the horizontal axis and core computational load as the vertical axis to intuitively reflect the real-time load distribution of each core. This load distribution map not only reveals the operating pressure of each task unit but also reflects the dynamic imbalance of resource usage, providing a quantitative basis for subsequent resource adjustments. Next, the dynamic load balancing controller executes a resource ratio adjustment algorithm based on the load distribution map. It calculates the load offset by comparing the load weight of each computing core and dynamically corrects the resource allocation ratio using a feedback control mechanism. For example, when the load value of a certain core is higher than the average load threshold, the controller will trigger a task migration or computation thread reallocation strategy to migrate some pending task units to cores with lower loads; conversely, when some cores are detected to be idle or in a low-load state, the system will actively increase the task allocation weight of that core to fully utilize available computing power. This process can be implemented using heuristic algorithms (such as the least load first algorithm, proportional-integral adjustment algorithm, or gradient descent-based resource allocation optimization algorithm), ensuring real-time performance and convergence stability in resource adjustments. Finally, the controller maps the updated computing resource allocation ratio to the thread scheduler of the multi-core CPU or GPU, generating a new task scheduling instruction set. The thread scheduler reallocates task execution queues and memory channel access permissions based on this instruction set, thereby achieving resource reallocation and balanced utilization at the hardware level. Simultaneously, the system employs a distributed storage mechanism to cache and manage polygon data, ensuring data consistency and fast access during task migration, thus avoiding data bottlenecks caused by load balancing adjustments.

[0036] In a specific embodiment of this application, the above steps are implemented as follows: In actual photolithography pattern processing, it is necessary to perform geometric correction and optical model fitting on a large amount of polygonal graphic data. This polygonal data often has complex boundary features and local coupling relationships, resulting in significant computational time consumption in single-threaded computing mode. Therefore, this invention constructs a task allocation and dynamic scheduling mechanism in a multi-core CPU or GPU cluster. The system first decomposes the polygonal data into multiple independent task units according to regional features or block rules, and allocates them to different computing cores for execution. During execution, each core's CPU / GPU utilization, cache hit rate, task completion progress, and communication latency are recorded in real time by the task monitoring module, forming a real-time "task load distribution map".

[0037] Based on this, the dynamic load balancing controller determines the current resource utilization according to the task load distribution map. For example, if at a certain moment, it detects that the computing load of GPU1 reaches 90%, while that of GPU2 is only 40%, the controller will automatically trigger a "task migration strategy" to transfer some of the polygon data tasks to be executed from GPU1 to GPU2 to balance the system load. At this time, the controller calculates a new resource allocation ratio based on the load offset, such as adjusting the task weight of GPU1 from 0.6 to 0.4 and increasing the task weight of GPU2 from 0.4 to 0.6, and issuing new task instructions in real time through the thread scheduler to achieve resource reallocation.

[0038] Meanwhile, to prevent data synchronization delays or duplicate reads during task migration, the system employs a distributed caching mechanism. Under this mechanism, polygon data is stored in a shared cache pool across multiple nodes, with each node quickly locating the data block using a consistent hashing algorithm. When migrating tasks, the system does not need to reload all data; it only needs to call the corresponding data cache index in the new node, achieving "zero-copy" data switching. This significantly reduces the communication overhead of task migration, ensuring computational continuity and data consistency.

[0039] As can be seen, a real-time closed-loop optimization system is formed, encompassing task unit partitioning, load monitoring, resource ratio calculation, task migration and scheduling, and distributed cache data consistency maintenance. This mechanism enables the system to dynamically adjust resource allocation ratios based on changes in computational load during complex polygon data processing, achieving adaptive scheduling and efficient parallelism of task execution, accelerating overall computational convergence speed, and significantly improving system throughput.

[0040] The above scenarios are merely preferred embodiments of the present invention and are not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

[0041] Step S300: Based on the multi-level data partitioning module, the contour information of each polygon is divided into blocks to generate block feature descriptors.

[0042] Specifically, when the multi-level data partitioning module divides the contour information of each polygon into blocks, it includes: dividing the vertex coordinate sequence of each polygon into multiple sub-regions using a spatial partitioning algorithm; extracting features from the vertex coordinate sequence of each sub-region to generate block feature descriptors; and matching the block feature descriptors with the feature descriptors of adjacent sub-regions to generate consistency verification results.

[0043] Specifically, when the spatial partitioning algorithm divides the vertex coordinate sequence of each polygon to generate multiple sub-regions, it includes: mapping the vertex coordinate sequence of each polygon to a two-dimensional grid space based on the grid partitioning algorithm; performing density analysis on each grid cell in the two-dimensional grid space to generate a grid density distribution map; and determining the boundary of each sub-region based on the grid density distribution map using an adaptive threshold algorithm.

[0044] Understandably, by quantitatively describing the spatial distribution characteristics of polygon vertices, the optimal sub-region boundaries can be automatically determined, thereby achieving structured decomposition and efficient feature extraction of complex geometric data. First, a two-dimensional grid partitioning algorithm is used to map the vertex coordinate sequence of the polygon from geometric space to a discretized grid space. The technical principle of this process is to discretize the continuous polygon boundary information into computable grid cells, each representing a certain spatial range, and the number of vertices within each cell reflects the local geometric complexity. When a region of the polygon has denser vertices or complex contour changes, the corresponding grid density value is higher; while in regions with smooth geometry and small boundary changes, the grid density value is relatively lower. By statistically analyzing the number of vertices or the vertex distribution weights of each grid cell, a grid density map can be generated, which essentially reflects the spatial complexity of the polygon's geometric structure. Second, an adaptive thresholding algorithm is introduced to determine the boundaries of the sub-regions. The underlying principle is that traditional fixed-threshold partitioning often fails to account for the geometric complexity of different regions, easily leading to overly coarse or overly fine partitioning, thus disrupting the continuity of the polygon structure. To address this issue, this invention employs an adaptive mechanism, dynamically calculating the optimal partitioning threshold T(x,y) for each local region based on the statistical characteristics of the local mesh density (such as mean μ, standard deviation σ, gradient rate of change ∇ρ, etc.). Specifically, the adaptive threshold can be calculated as: T(x,y) = μ(x,y) + k⋅σ(x,y); where k is an adjustable parameter used to control the sensitivity of the partitioning. When the local mesh density is high and the geometric structure is complex, the σ value is large, and the algorithm automatically increases the partitioning threshold, thereby generating finer sub-regions; conversely, when the local density is low and the structure is simple, the threshold is lowered to reduce over-partitioning. This self-adjusting characteristic can adaptively determine the partitioning granularity based on the local features of the polygon, ensuring the rationality and accuracy of the partitioning. Furthermore, after the threshold is determined, region growing and boundary tracking algorithms are used to aggregate adjacent mesh cells into a complete sub-region based on density continuity, and corresponding boundary contours are generated. In this way, intelligent segmentation of complex polygonal structures can be achieved while maintaining the integrity of the original geometry. Each sub-region then generates a block feature descriptor to characterize local geometry, edge orientation, curvature distribution, and other information.

[0045] In a specific embodiment of this application, the above steps are implemented as follows: When performing reverse lithography optimization on the photomask layout of an advanced node chip (such as a 3nm process), the layout contains a large number of complex polygonal structures. These polygonal contours often have extremely high vertex density and drastic shape changes, such as curved corners, sharp edges, and micro-dimples. Traditional overall processing methods require global fitting and optical simulation of the complete polygonal boundaries, which is not only computationally intensive but also prone to deformation distortion during boundary smoothing, affecting the final lithography accuracy.

[0046] In an embodiment of this invention, the system first performs two-dimensional meshing on the polygonal contour data to be processed, for example, mapping the entire geometric region to a 1024×1024 mesh space. Each mesh cell records the number and distribution density of vertices within that region, generating a grid density map. The map clearly shows that the grid density at chip wiring corners and contact hole edges is significantly higher than in flat areas, reflecting the geometric complexity and high optical sensitivity of these regions.

[0047] Subsequently, the system applies an adaptive threshold algorithm to subdivide the density distribution map into sub-regions. For example, in a region with an average density μ = 18 and a standard deviation σ = 6, the system calculates a local threshold T = 21 based on the formula T(x,y) = μ + k·σ (when k = 0.5). The system automatically identifies regions with a grid density higher than 21 as "high-complexity sub-regions" and further refines their subdivisions; while regions with a density lower than 21 are automatically classified as "low-complexity regions" and processed with a larger granularity. This partitioning method allows for a more refined geometric description of complex regions, while avoiding unnecessary computational overhead for simple regions.

[0048] Next, the system employs region growing and boundary tracking algorithms to aggregate cells with continuous mesh density into independent sub-regions. For example, at the corner of a polygon, adjacent high-density mesh cells are identified as an independent sub-block, and a boundary curve is generated. This boundary not only preserves the geometric features of the original polygon but is also smoothed to eliminate data noise. Finally, each sub-block generates a corresponding block feature descriptor, which includes multi-dimensional feature parameters such as local curvature, edge direction vectors, and vertex density distribution matrix.

[0049] For example, for a complex rectangular gate pattern, the system might ultimately divide it into 12 sub-regions: 4 high-density corner regions (containing numerous vertex variations) and 8 low-density flat regions. The feature descriptors for the high-density regions will focus on recording curvature variations and edge gradients, while the descriptors for the low-density regions will focus on overall orientation and length features. In subsequent reverse lithography optimization, the system can employ differentiated optical simulation and shape correction strategies for different feature sub-blocks, achieving a balance between high precision and high efficiency.

[0050] This example demonstrates that the multi-level data partitioning and adaptive threshold algorithm described in this invention can not only automatically identify and decompose complex geometric regions, achieving block-level structured processing, but also significantly reduce global computational complexity. Compared to traditional methods, computational efficiency can be improved by approximately 40% to 60%, while maintaining lithography simulation errors within the sub-nanometer range. Therefore, this invention possesses significant practical application value and innovative technological advantages in complex chip layout processing, lithography process modeling, and large-scale OPC optimization.

[0051] The above scenarios are merely preferred embodiments of the present invention and are not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

[0052] Step S400: Based on the combination of block feature descriptors and edge smoothing modules, a local light intensity distribution matrix is ​​generated, and the geometric parameters of the polygon contour are adjusted based on the local light intensity distribution matrix and the global optimizer to generate optimized polygon data.

[0053] Specifically, when the edge smoothing module generates a local light intensity distribution matrix based on the block feature descriptor, it includes: inputting the block feature descriptor into the edge smoothing filter to generate a smoothed vertex coordinate sequence; calculating the local light intensity distribution gradient based on the smoothed vertex coordinate sequence to generate a local light intensity distribution matrix; and combining the local light intensity distribution matrix with the constraints of the global optimizer to generate an optimization objective function.

[0054] Specifically, when the global optimizer adjusts the geometric parameters of the polygon contour based on the local light intensity distribution matrix, it includes: iteratively optimizing the geometric parameters of each polygon based on the optimization objective function to generate intermediate optimization results; correcting the boundary errors of the intermediate optimization results to generate the final optimization results; and mapping the final optimization results to the vertex coordinate sequence of the polygon contour to generate optimized polygon data.

[0055] Understandably, by utilizing the local light intensity distribution information extracted from the block feature descriptors, the brightness variation trend of the corresponding region of the polygon outline in space is reflected. This light intensity gradient information is then structured into a local light intensity distribution matrix, serving as a "light intensity constraint" reflecting local geometric details. Finally, a global optimizer coordinates the local parameters globally under a unified optimization objective, ensuring that the optimization result preserves the true local shape while satisfying overall geometric consistency and boundary continuity. When generating the optimization objective function, the light intensity gradient information of each block in the local light intensity distribution matrix is ​​first combined with the constraints of the global optimizer. Specifically, the local light intensity distribution matrix provides the brightness variation trend around each vertex or boundary point, which is considered a local energy term. The global optimizer sets overall constraints, including shape smoothing constraints (preventing over-sharpening), topology preservation constraints (preventing boundary breaks), and boundary continuity constraints (maintaining geometric consistency between adjacent polygons). By fusing the local energy term and the global constraint term in a weighted manner, the overall optimization objective function is constructed. The objective function is typically expressed mathematically as a multi-objective minimization problem, aiming to simultaneously minimize local light intensity distribution errors and global geometric distortion, resulting in a visually smoother and geometrically more stable contour. During global optimization, the geometric parameters (including vertex positions, corner directions, and boundary curvature) of each polygon are iteratively solved based on the objective function. In this process, the global optimizer dynamically adjusts the parameters using optimization algorithms such as gradient descent or quasi-Newton, ensuring that the objective function value gradually converges with each iteration. Once the optimization reaches convergence, a boundary error correction mechanism is introduced to further improve boundary accuracy. The technical principle of this mechanism is as follows: a difference analysis is performed between the boundary points of the intermediate optimization results and the edges of the original light intensity gradient to calculate the boundary offset error vector; then, based on the error vector and the directional constraints of the local light intensity distribution, the vertex coordinates and boundary curvature are corrected. A dynamic weighting strategy is used during the correction process, increasing the correction intensity in areas with large boundary errors while maintaining smoothness in stable boundary areas, thereby avoiding boundary fluctuations caused by over-adjustment. Ultimately, the polygonal contour, after boundary error correction, can accurately recover its shape details under the guidance of local light intensity features, while achieving geometric continuity and topological consistency through global constraints, forming an optimized polygonal data model that balances local precision and overall coordination. This technical principle effectively overcomes the "local distortion" and "boundary drift" problems that are prone to occur in traditional shape optimization algorithms, significantly improving the accuracy and stability of polygonal data in scenarios such as image compression, vector reconstruction, and optical image analysis.

[0056] In a specific embodiment of this application, the above steps are implemented as follows: In advanced photolithography mask design, chip layouts are typically composed of thousands of complex polygons with different sizes, shapes, and density distributions. Any minute boundary deviation can directly affect the accuracy of photolithography exposure, leading to chip manufacturing defects. To address this issue, this technical solution proposes a polygon contour processing method based on block features, local light intensity distribution, and global constraint optimization to improve the accuracy and consistency of the mask contour.

[0057] First, each polygonal contour is partitioned into multiple data levels, mapping the vertex coordinate sequence to a two-dimensional grid space, and generating a grid density distribution map through grid density analysis. The system employs an adaptive threshold algorithm to dynamically determine the boundaries of sub-regions based on local grid density, density change gradient, and statistical characteristics. This divides high-density, complex regions into finer sub-blocks, while low-density, smooth regions are divided into larger sub-blocks. This adaptive partitioning strategy ensures that local geometric details are fully preserved while avoiding computational redundancy caused by over-segmentation. Subsequently, a block feature descriptor is extracted for each sub-block, including local vertex distribution, edge direction, curvature changes, and spatial geometric features, providing fundamental information for light intensity calculation and subsequent optimization.

[0058] Next, the block feature descriptors are input into the edge smoothing module, which uses an edge smoothing filter to generate a smoothed vertex sequence and calculates the local intensity distribution gradient matrix based on the smoothed vertices. The local intensity distribution matrix not only reflects the brightness variation trend of each sub-region but also quantifies the edge intensity error and contour offset, providing the optimizer with accurate local constraint information.

[0059] In the global optimization phase, the local light intensity matrix is ​​combined with global constraints (such as shape smoothing constraints, prevention of boundary over-sharpening, topology preservation constraints, and continuity constraints of adjacent polygon boundaries) to form a multi-objective optimization function. The optimizer dynamically adjusts the coordinates of each vertex, boundary angle, and curvature through iterative solution algorithms (gradient descent, quasi-Newton method, or other heuristic optimization algorithms) to gradually reduce local light intensity errors and optimize overall geometric consistency. During the iteration process, the optimizer considers both local and global constraints, ensuring that each sub-region, while satisfying local light intensity characteristics, can coordinate with adjacent regions to achieve a smooth and continuous overall contour.

[0060] After generating intermediate optimization results, a boundary error correction mechanism is introduced for fine-tuning. This mechanism calculates the boundary error vector by comparing the offset difference between the boundary points of the intermediate optimization results and the edges of the original local intensity gradient, and then weights and adjusts it according to the error magnitude and local intensity direction. For boundary regions with large errors, the system strengthens the correction to eliminate obvious offsets; for regions with small or stable errors, smoothness is maintained to avoid over-correction that introduces new fluctuations. Ultimately, the boundary-corrected polygonal contour achieves an optimal balance between local detail and global shape.

[0061] As can be seen, after the entire process is completed, the generated optimized polygon data has the following characteristics: First, local edge details are accurately preserved, reflecting the changes in light intensity gradients of complex contours; second, the global shape is smooth and continuous, ensuring topological consistency between polygons; and third, boundary error correction significantly reduces boundary offset and local distortion. This method can significantly improve exposure accuracy and reduce pattern transfer errors in advanced photolithography mask design. Simultaneously, through block-parallel computing and dynamic load balancing, it achieves efficient processing of large-scale complex layouts, meeting the needs of rapid iteration in chip design.

[0062] The above scenarios are merely preferred embodiments of the present invention and are not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

[0063] Step S500: Based on the optimized polygon data, generate a compact polygon representation using a compression encoder and output it to the photomask design system.

[0064] Specifically, when the compression encoder generates a compact polygon representation based on the optimized polygon data, it includes: generating a sparse representation vector from the optimized polygon data using a sparse coding algorithm; quantizing the sparse representation vector to generate a quantized representation vector; and generating a compact polygon representation from the quantized representation vector using an entropy coding algorithm.

[0065] Specifically, when the sparse coding algorithm generates a sparse representation vector for the optimized polygon data, it includes: extracting features from the optimized polygon data based on a dictionary learning algorithm to generate a feature dictionary; matching the feature dictionary with the optimized polygon data to generate a sparse representation vector; and performing redundancy analysis on the sparse representation vector to generate a sparsity evaluation result.

[0066] Specifically, when the entropy coding algorithm generates a compact polygonal representation of the quantized representation vector, it includes: symbolizing the quantized representation vector based on the Huffman coding algorithm to generate a symbolic representation sequence; performing frequency statistics on the symbolic representation sequence to generate a frequency distribution table; and generating a compact polygonal representation based on the arithmetic coding algorithm and the frequency distribution table.

[0067] Understandably, the optimized polygon data is transformed into a compact representation for efficient storage, transmission, and retrieval in photomask design. Its core technical principles mainly consist of three parts: sparse coding, quantization processing, and entropy coding, as detailed below. First, in the sparse coding stage, a feature dictionary is constructed based on the optimized polygon data. This feature dictionary is generated using a dictionary learning algorithm. The principle behind this algorithm is to extract representative local geometric features and contour patterns from a large number of polygon data samples, forming a set of primitives (Dictionary Atoms). Each primitive can represent a certain type of geometric shape or local feature in the polygon data. Subsequently, the optimized polygon data is matched with this feature dictionary. By minimizing the reconstruction error, the minimum number of primitive combinations is determined to generate a sparse representation vector. Specifically, each dimension of the sparse representation vector corresponds to a primitive in the feature dictionary. Non-zero coefficients represent the weight of that primitive in the current polygon data, while zero coefficients indicate that the primitive was not used, thus achieving a sparsity representation. Simultaneously, redundancy analysis is performed on the generated sparse representation vector. By statistically analyzing the proportion of non-zero coefficients, coefficient distribution, and reconstruction error, the sparsity and information fidelity of the vector are evaluated to ensure a balance between coding efficiency and data integrity. Secondly, in the quantization stage, the continuous coefficients of the sparse representation vector are discretized into finite-precision values ​​to generate the quantized representation vector. The technical principle lies in mapping sparse coefficients to a fixed-precision integer range or symbol set, controlling the trade-off between precision and compression ratio through the quantization step size. A smaller quantization step size retains more detailed information but reduces the compression ratio; a larger quantization step size improves compression efficiency but may introduce slight distortion. The quantized representation vector reduces data storage requirements and facilitates subsequent entropy coding. Finally, in the entropy coding stage, a compact polygonal representation is further generated through Huffman coding and arithmetic coding. First, the quantized representation vector is symbolized, mapping each quantized value in the vector to a corresponding symbol sequence. Then, the frequency of occurrence of the symbol sequences is statistically analyzed to generate a frequency distribution table. Based on this, Huffman coding is used to assign short codewords to high-frequency symbols and long codewords to low-frequency symbols, achieving initial compression. Further, arithmetic coding is used to perform probabilistic interval coding on the symbol sequence, mapping the entire symbol sequence to a high-precision decimal interval, achieving an even higher compression ratio. Through this series of operations, the optimized polygon data is transformed into a compact and easily transmitted representation, ensuring efficient retrieval and storage in photomask design while maintaining the geometric accuracy and information integrity of the polygons.

[0068] In a specific embodiment of this application, the above steps are implemented as follows: In a photomask design system, to efficiently store and transmit polygon data, the system first performs sparse encoding on the optimized polygon contour data. Assuming a photomask region contains complex polygonal patterns, the system constructs a feature dictionary containing typical geometric units, such as line segments, curve segments, and common boundary shapes, using a dictionary learning algorithm. Then, each polygon in the photomask region is matched with the feature dictionary to reconstruct the polygon contour with the minimum number of primitive combinations. Through this matching process, a sparse representation vector is generated, where most dimensions are zero, and non-zero coefficients represent the weights of the selected primitives in the current polygon. This step not only achieves sparse representation of the data but also, through redundancy analysis, statistically analyzes the proportion of non-zero coefficients and reconstruction errors, ensuring that the encoded sparse vector is both compact and can completely express the geometric features of the polygon.

[0069] Next, the system quantizes the sparse representation vector. Assuming the non-zero coefficients of a sparse vector are floating-point numbers, the system maps them to a fixed-precision integer range, for example, discretizing continuous coefficients into 8-bit or 16-bit integers. Simultaneously, an adjustable quantization step size controls the balance between compression ratio and precision. In high-precision regions, the quantization step size is smaller to preserve contour details, while in smooth or repetitive regions, the step size is larger to improve compression efficiency. In this way, the quantized representation vector reduces storage space and facilitates subsequent entropy coding operations.

[0070] Finally, the system inputs the quantized representation vector into the entropy encoder to further generate a compact polygon representation. Specifically, the quantized values ​​are first mapped to a symbol sequence, and then the frequency of each symbol is counted to generate a frequency distribution table. Subsequently, Huffman coding is used to assign short codewords to high-frequency symbols and long codewords to low-frequency symbols, achieving initial compression. On this basis, arithmetic coding compresses the entire symbol sequence into a single high-precision value through probability interval mapping, achieving further compression. Ultimately, through sparse coding, quantization, and entropy coding, the original polygon data is transformed into a highly compressed, compact, and easily transmitted representation that can be directly output to the photomask design system, supporting rapid rendering, storage, and retrieval, while preserving the geometric accuracy and structural integrity of the original polygon outline.

[0071] The above scenarios are merely preferred embodiments of the present invention and are not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

[0072] In the above embodiments, a structured decomposition of reverse lithography computation tasks is achieved by constructing a polygon data processing framework based on hierarchical task decomposition. By dividing large-scale polygon data into multiple independent task units and introducing a dynamic load balancer, tasks can be adaptively allocated according to the real-time load of computing nodes, effectively avoiding computational congestion on some nodes and significantly improving the overall utilization of computing resources and parallel efficiency. This mechanism allows the system to be flexibly expanded in multi-core CPU or GPU clusters, thereby meeting the computational needs of photomask designs of different sizes. Secondly, a distributed storage and cache management mechanism is adopted during task execution, enabling polygon data to be efficiently transmitted and shared among multiple computing nodes, reducing data read / write bottlenecks and communication latency. This mechanism not only improves data access speed but also ensures the consistency and reliability of computational results among multiple nodes, fundamentally improving the stability and scalability of the reverse lithography process. Furthermore, at the polygon data processing level, this invention introduces a multi-level data partitioning module to process the contour information of complex polygons in blocks and generate feature descriptors, enabling accurate extraction of morphological and edge features at the local scale, providing more representative input data for subsequent optical simulations. By combining with an edge smoothing module, the system effectively suppresses jagged edges of polygons and optimizes contour continuity, thereby improving the imaging accuracy and consistency of the lithographic pattern during exposure. Simultaneously, through collaborative control based on the local intensity distribution matrix and a global optimizer, the geometric parameters of the polygon contour are adaptively adjusted, achieving a balance between local detail optimization and global optical consistency. This mechanism not only improves the accuracy of reverse lithography results but also reduces redundant overhead caused by repetitive calculations in traditional methods. Finally, by using a compression encoder to compactly encode the optimized polygon data, the amount of data storage and transmission is significantly reduced, enabling the mask design system to load and process layout data more efficiently.

[0073] In another preferred embodiment based on the above embodiments, such as Figure 3 As shown, this embodiment provides a parallel computing-based reverse lithography OPC polygon data processing system, including: The decomposition module is used to divide polygonal data into multiple independent task units; The dynamic load balancer controller is electrically connected to the decomposition module. The dynamic load balancer controller is used to generate dynamic load balancing strategies based on the computational load of the task units. The data partitioning module is electrically connected to the dynamic load balancer. The data partitioning module is used to divide the contour information of each polygon into blocks and generate block feature descriptors. The edge smoothing module is electrically connected to the data partitioning module. The edge smoothing module is used to generate a local light intensity distribution matrix based on the block feature descriptor. The global optimizer, electrically connected to the edge smoothing module, is used to adjust the geometric parameters of the polygon contour based on the local light intensity distribution matrix to generate optimized polygon data. The compression encoder, electrically connected to the global optimizer, is used to generate a compact polygon representation based on optimized polygon data.

[0074] It is understood that the parallel computing-based reverse lithography OPC polygon data processing method and system module in the above embodiments of the present invention have the same beneficial effects, and will not be described again.

[0075] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program goods. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program goods embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0076] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program goods according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0077] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0078] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0079] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and not to limit it. Although the present invention has been described in detail with reference to the above embodiments, those skilled in the art should understand that modifications or equivalent substitutions can still be made to the specific implementation of the present invention. Any modifications or equivalent substitutions that do not depart from the spirit and scope of the present invention should be covered within the scope of protection of the claims of the present invention.

Claims

1. A method for processing OPC polygon data in reverse lithography based on parallel computing, characterized in that, include: A polygon data processing framework based on hierarchical task decomposition is constructed, and a dynamic load balancer is designed to divide polygon data into multiple independent task units. Based on task units, computing resources are allocated on multi-core CPUs or GPUs, and a distributed storage mechanism is used to cache and manage polygon data. Based on the multi-level data partitioning module, the contour information of each polygon data is divided into blocks to generate block feature descriptors; Based on the combination of block feature descriptors and edge smoothing modules, a local light intensity distribution matrix is ​​generated. Based on the local light intensity distribution matrix and the global optimizer, the geometric parameters of the polygon contour are adjusted to generate optimized polygon data. Based on the optimized polygon data, a compact polygon representation is generated by a compression encoder and output to the mask design system.

2. The method for processing OPC polygon data based on parallel computing in reverse lithography as described in claim 1, characterized in that, When the dynamic load balancing controller generates a dynamic load balancing strategy based on task units, it includes: Based on real-time monitoring of the computational load of each polygon data processing task, a task load distribution map is generated. Adjust the allocation ratio of computing resources based on the task load distribution map and dynamic load balancer; The adjusted computing resource allocation ratio is mapped to the thread scheduler of a multi-core CPU or GPU to generate task scheduling instructions.

3. The method for processing OPC polygon data based on parallel computing in reverse lithography as described in claim 1, characterized in that, When the multi-level data partitioning module performs block processing on the contour information of each polygon, it includes: The vertex coordinate sequence of each polygon is divided into multiple sub-regions using a spatial partitioning algorithm; Feature extraction is performed on the vertex coordinate sequence of each sub-region to generate block feature descriptors; The block feature descriptor is matched with the feature descriptors of adjacent sub-regions to generate a consistency check result.

4. The method for processing reverse lithography OPC polygon data based on parallel computing as described in claim 3, characterized in that, The spatial partitioning algorithm, when dividing the vertex coordinate sequence of each polygon to generate multiple sub-regions, includes: The vertex coordinate sequence of each polygon is mapped to a two-dimensional grid space based on the grid partitioning algorithm; Perform density analysis on each grid cell in the two-dimensional grid space to generate a grid density distribution map; Based on the grid density distribution map, the boundary of each sub-region is determined using an adaptive threshold algorithm.

5. The method for processing OPC polygon data based on parallel computing in reverse lithography as described in claim 1, characterized in that, When the edge smoothing module generates the local light intensity distribution matrix based on the block feature descriptor, it includes: The block feature descriptor is input into the edge smoothing filter to generate a smoothed vertex coordinate sequence; The local light intensity distribution gradient is calculated based on the smoothed vertex coordinate sequence, and a local light intensity distribution matrix is ​​generated. The local light intensity distribution matrix is ​​combined with the constraints of the global optimizer to generate the optimization objective function.

6. The method for processing OPC polygon data based on parallel computing in reverse lithography as described in claim 5, characterized in that, When the global optimizer adjusts the geometric parameters of the polygon contour based on the local light intensity distribution matrix, it includes: The geometric parameters of each polygon are iteratively optimized based on the objective function to generate intermediate optimization results; Boundary error correction is applied to the intermediate optimization results to generate the final optimization results; The final optimization result is mapped to the vertex coordinate sequence of the polygon outline to generate optimized polygon data.

7. The method for processing OPC polygon data based on parallel computing in reverse lithography as described in claim 1, characterized in that, When the compression encoder generates a compact polygon representation based on the optimized polygon data, it includes: The optimized polygon data is used to generate a sparse representation vector through a sparse coding algorithm; The sparse representation vector is quantized to generate a quantized representation vector. The quantized representation vector is then used to generate a compact polygonal representation through an entropy coding algorithm.

8. The method for processing reverse lithography OPC polygon data based on parallel computing as described in claim 7, characterized in that, When generating sparse representation vectors from optimized polygonal data, sparse coding algorithms include: Feature dictionary is generated by extracting features from optimized polygon data based on dictionary learning algorithm. The feature dictionary is matched with the optimized polygon data to generate a sparse representation vector; Redundancy analysis is performed on the sparse representation vector to generate sparsity evaluation results.

9. The method for processing reverse lithography OPC polygon data based on parallel computing as described in claim 7, characterized in that, When the entropy coding algorithm generates a compact polygonal representation of the quantized representation vector, it includes: The quantized representation vector is symbolized using the Huffman coding algorithm to generate a symbolic representation sequence. Perform frequency statistics on the symbolic representation sequence to generate a frequency distribution table; A compact polygonal representation is generated based on an arithmetic coding algorithm and a frequency distribution table.

10. A parallel computing-based reverse lithography OPC polygon data processing system, applicable to the parallel computing-based reverse lithography OPC polygon data processing method according to any one of claims 1-9, characterized in that, include: The decomposition module is used to divide polygonal data into multiple independent task units; The dynamic load balancer controller is electrically connected to the decomposition module. The dynamic load balancer controller is used to generate dynamic load balancing strategies based on the computational load of the task units. The data partitioning module is electrically connected to the dynamic load balancer. The data partitioning module is used to divide the contour information of each polygon into blocks and generate block feature descriptors. The edge smoothing module is electrically connected to the data partitioning module. The edge smoothing module is used to generate a local light intensity distribution matrix based on the block feature descriptor. The global optimizer, electrically connected to the edge smoothing module, is used to adjust the geometric parameters of the polygon contour based on the local light intensity distribution matrix to generate optimized polygon data. The compression encoder, electrically connected to the global optimizer, is used to generate a compact polygon representation based on optimized polygon data.

Images