Netlist parsing method, computer device, program product and storage medium
By splitting the netlist file into independent atomic parsing partitions for parallel parsing, combining a bitmap compression state machine and a dynamic symbol table, and using an incremental LALR(1) and GLL hybrid parser, the problems of low netlist parsing efficiency and long error repair time are solved, and efficient netlist parsing and error repair are achieved.
Patent Information
- Application Number
- CN202510803720.X
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2025-06-17
- Publication Date
- 2025-09-05
- Estimated Expiration
- 2045-06-17
AI Technical Summary
In existing technologies, the time complexity of netlist parsing is O(n²), which causes throughput to decline as the netlist size grows, leading to system performance bottlenecks. In addition, syntax errors require the entire file to be re-parsed, resulting in a high error repair time cost.
A lock-free ring queue and DAG task scheduler are used to split the netlist file into independent atomic parsing partitions. Parallel parsing is performed through a bitmap compression state machine and a dynamic symbol table. An incremental LALR(1) and GLL hybrid parser is used to locally repair syntax errors when they are detected, skipping the error interval and rebuilding the syntax stack state. A limited lookahead repair algorithm is used to reduce error repair time.
It achieves efficient parsing of complex and large-scale netlists, reduces parsing time after syntax errors are fixed, and improves the physical and temporal performance of large-scale netlists in EDA systems.
Smart Images
Figure CN120335820B_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the technical field of electronic design automation, and in particular to a netlist parsing method, computer equipment, program product and storage medium. Background Art
[0002] In the field of electronic design automation (EDA), netlist parsing is the core preprocessing step for physical design and simulation verification. It is used to convert circuit topology, device models, and simulation control statements into structured data that can be processed by computers through netlist descriptions.
[0003] Existing netlist parsing typically constructs a syntax tree using recursive descent parsing. However, the time complexity of constructing a syntax tree using this method reaches O(n²). This causes the parsing throughput to plummet as the netlist size grows, easily leading to system performance bottlenecks. Furthermore, when a single syntax error (such as a missing port definition) is detected during parsing, the entire file parsing process is terminated. Fixing the error requires re-parsing the entire file, resulting in a high risk of interruption and high parsing time. Therefore, there is an urgent need for a graph parsing solution that can effectively improve the parsing efficiency of complex, large-scale netlists and significantly reduce the parsing time after the error is fixed when syntax errors are triggered during parsing. Summary of the Invention
[0004] The purpose of the present invention is to provide a netlist parsing method, computer equipment, program product and storage medium to achieve efficient parsing of complex and large-scale netlists, and to greatly reduce the parsing time after error repair when syntax errors are triggered during the parsing process, thereby effectively improving the physical and time performance of large-scale netlist parsing in EDA systems.
[0005] The technical solutions provided by the present invention are as follows:
[0006] In a first aspect, the present invention provides a netlist parsing method for simulation design of a very large scale integrated circuit, comprising the steps of:
[0007] Obtaining a netlist file generated during the simulation design process of the ultra-large-scale integrated circuit;
[0008] Splitting the netlist file into a plurality of independent atomic parsing partitions according to syntax, and performing parallel task scheduling of each of the independent atomic parsing partitions through a lock-free circular queue, wherein each of the independent atomic parsing partitions contains at least one complete sub-circuit module;
[0009] Performing lexical classification on each of the independent atomic parsing partitions through a bitmap compression state machine and a dynamic symbol table, and outputting a classified token stream, wherein the token stream includes basic tokens and context-related tokens, wherein the basic tokens correspond to basic data structures in the netlist file, and the context-related tokens correspond to data structures context-related to the basic data structures;
[0010] Parsing each of the independent atomic parsing partitions in parallel according to the token stream to generate a local syntax tree corresponding to each of the independent atomic parsing partitions;
[0011] When a syntax error is detected during parsing, the current syntax stack state and symbol table are saved to the database;
[0012] Determine an error interval according to the token stream, and skip the error interval to rebuild the grammar stack for subsequent parsing;
[0013] After the user fixes the error, reparse the error interval, restore context data based on the current syntax stack state, and update the corresponding local syntax tree;
[0014] The local syntax trees are merged according to the dependency relationship of each of the independent atomic parsing partitions to generate a complete syntax tree.
[0015] In some embodiments, the step of grammatically splitting the netlist file into a plurality of independent atomic parsing partitions includes:
[0016] Splitting the netlist file into a plurality of independent atomic parsing partitions based on regular expression matching grammatical boundaries,
[0017] Establishing a dependency graph according to the dependency relationships of the independent atomic parsing partitions;
[0018] The parallel task scheduling of each of the independent atomic parsing partitions through the lock-free circular queue further includes:
[0019] A topological sorting sequence is generated according to the dependency graph, the independent atomic resolution partitions with dependencies are sequentially scheduled using the topological sorting sequence, and the independent atomic resolution partitions without dependencies are pushed to the lock-free circular queue for parallel task scheduling.
[0020] In some embodiments, performing lexical grading on each of the independent atomic parsing partitions through a bitmap compression state machine and a dynamic symbol table and outputting a classified token stream includes:
[0021] The state transition table of each independent atomic parsing partition is compressed into a bitmap code by the bitmap compression state machine, and the bitmap code is subjected to lexical analysis to perform lexical classification.
[0022] In some embodiments, the lexical classification of each of the independent atomic parsing partitions by using a bitmap compression state machine and a dynamic symbol table and outputting a classified token stream further includes:
[0023] The basic data structures of each independent atomic parsing partition are matched through a single instruction-multiple data instruction, and the data structure related to the current basic data structure context is cached through a dynamic symbol table to establish an association relationship between the basic token and the context-related token.
[0024] In some embodiments, the step of performing parallel parsing on each of the independent atomic parsing partitions according to the token stream to generate a local syntax tree includes:
[0025] Performing hybrid parsing on the independent atomic parsing partitions by using an incremental LALR(1) parser and a GLL parser to generate the local syntax tree;
[0026] When a syntax error is detected during the parsing process, the erroneous interval is skipped for subsequent parsing using a limited lookahead repair algorithm.
[0027] In some implementations, determining the error interval based on the token stream includes:
[0028] According to the tokens of the currently executed task and the token stream when the syntax error is detected, a preset number of tokens are scanned forward by the limited look-ahead repair algorithm to determine the repair boundary, and then determine the error interval.
[0029] In some implementations, the netlist file is split into a plurality of independent atomic parsing partitions according to syntax units by a directed acyclic graph scheduler, and a topological sorting sequence is generated by the directed acyclic graph scheduler and the dependency graph.
[0030] In a second aspect, the present application provides a computer device comprising a memory, a processor, and a computer program stored in the memory, wherein the processor executes the computer program to implement the steps of the netlist parsing method described in the first aspect.
[0031] In a third aspect, the present application provides a computer storage medium having a computer program or instructions stored thereon, which, when executed by a processor, implements the steps of the netlist parsing method described in the first aspect.
[0032] In a fourth aspect, the present application provides a computer program product, comprising a computer program or instructions, which, when executed by a processor, implement the steps of the netlist parsing method described in the first aspect.
[0033] According to the netlist parsing method, computer equipment, program product and storage medium provided by the present invention, efficient parsing of complex and large-scale netlists can be achieved, and when syntax errors are triggered during the parsing process, the parsing time after the error is repaired can be greatly reduced, thereby effectively improving the physical and time performance of large-scale netlist parsing in EDA systems. BRIEF DESCRIPTION OF THE DRAWINGS
[0034] The preferred implementation scheme will be described below in a clear and understandable manner with reference to the accompanying drawings to further illustrate the above-mentioned characteristics, technical features, advantages and implementation methods of this solution.
[0035] Figure 1 This is a schematic diagram of the overall process of an embodiment of the present invention;
[0036] Figure 2 It is a flow chart of an embodiment of the present invention;
[0037] Figure 3 It is a schematic diagram of the parsing process of an embodiment of the present invention. DETAILED DESCRIPTION
[0038] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the specific embodiments of the present invention will be described below with reference to the accompanying drawings. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings and other embodiments can be obtained based on these drawings without inventive work.
[0039] To simplify the drawings, only the parts relevant to the present invention are schematically shown in each figure. They do not represent the actual structure of the product. Furthermore, to simplify the drawings and facilitate understanding, in some figures, only one of the components with the same structure or function is schematically depicted or labeled. As used herein, "one" not only means "only one" but also "more than one."
[0040] In the field of electronic design automation (EDA), netlist parsing is the core preprocessing step for physical design and simulation verification. It is used to convert circuit topology, device models, and simulation control statements into structured data that can be processed by computers through netlist descriptions.
[0041] Existing netlist parsing typically constructs a syntax tree using recursive descent parsing. However, the time complexity of constructing a syntax tree using this method reaches O(n²). This causes the parsing throughput to plummet as the netlist size grows, easily leading to system performance bottlenecks. Furthermore, when a single syntax error (such as a missing port definition) is detected during parsing, the entire file parsing process is terminated. Fixing the error requires re-parsing the entire file, resulting in a high risk of interruption and high parsing time. Therefore, there is an urgent need for a graph parsing solution that can effectively improve the parsing efficiency of complex, large-scale netlists and significantly reduce the parsing time after the error is fixed when syntax errors are triggered during parsing.
[0042] This solution improves the effective hit rate of lexical syntax through BCSM (bitmap compression state machine), multi-level FSA tokens, and a dynamic symbol table cache mechanism. It can reduce the number of backtracking times for parameter patterns, thereby reducing the time complexity to O(nlogn), and significantly reducing the impact of parsing efficiency as the netlist size increases. At the same time, it adopts an improved incremental LALR(1) and GLL hybrid parsing mode. When a syntax error is detected, a limited lookahead repair algorithm (Lookahead-Limited Repair) is used to localize the error based on the context snapshot mechanism, skipping the error interval and rebuilding the syntax stack state to continue parsing subsequent content, reducing the risk of interruption. After the syntax error is repaired, only the error interval is re-parsed, making full use of historical parsing nodes and improving the effective parsing reuse rate. In addition, the DAG (Directed Acyclic Graph)-based task scheduler breaks down netlist files into independent atomic parsing partitions based on grammatical units, distributes threads by partition, and achieves zero-conflict parallel parsing through a lock-free circular queue and shared symbol table lock mechanism. This enables the use of multi-core performance with a finer-grained parallel strategy, improving parsing efficiency and effectively enhancing the physical and time performance of large-scale netlist parsing in EDA systems. This solution is described in detail below with reference to the accompanying figures:
[0043] In one embodiment, the reference Figure 1 To the attached Figure 3 The present invention provides a netlist parsing method for the simulation design of ultra-large-scale integrated circuits, comprising the steps of:
[0044] S100. Obtain a netlist file generated during the simulation design process of a very large-scale integrated circuit; the netlist file includes multi-layer sub-circuit nesting, parameterized device macro definitions, simulation control statements, etc., and is usually stored in a SPICE format.
[0045] S200 , splitting the netlist file into several independent atomic parsing partitions according to the syntax, and performing parallel task scheduling of each independent atomic parsing partition through a lock-free circular queue, wherein each independent atomic parsing partition contains at least one complete sub-circuit module.
[0046] This solution uses a Directed Acyclic Graph Scheduler (DAG) to break down netlist files into several independent Atomic Parsing Units (APUs) based on syntax units (such as `.SUBCKT`, `.MODEL`, and `.PARAM`). Each APU contains a complete subcircuit definition or a block of model parameters. A DAG is a graph consisting of a finite number of vertices and directed edges. A key property of DAGs is that they can be topologically sorted. Topological sorting arranges all DAG vertices into a linear sequence such that for every directed edge u→v in the graph, vertex u precedes vertex v. Topological sorting can be used to solve problems such as task scheduling and dependency resolution. Furthermore, in a DAG, the path from one vertex to another is unique; there cannot be multiple paths. The absence of cycles in a DAG makes it suitable for representing systems with hierarchies or dependencies. The DAG task scheduler is used to decompose netlist files into independent atomic parsing partitions according to grammatical units, and threads are distributed according to partitions. Zero-conflict parallel parsing is achieved through a lock-free circular queue and shared symbol table lock mechanism, which can increase thread processing efficiency several times when parsing netlists above GB level.
[0047] S300. Perform lexical grading on each independent atomic parsing partition through a bitmap compression state machine and a dynamic symbol table, and output a classified token stream. The token stream includes basic tokens and context-related tokens. The basic tokens correspond to the basic data structure in the netlist file, and the context-related tokens correspond to data structures that are context-related to the basic data structure.
[0048] This solution uses a multi-level FSA token classifier to classify tokens into basic tokens (such as node name `N1` and device value `R=1k`) and context-dependent tokens (such as subcircuit instantiation call `X1 N1 N2 SUB_MOD`). This is then processed using a hierarchical state machine. Using a BCSM (bitmap compression state machine), multi-level FSA tokens, and a dynamic symbol table cache mechanism, this improves the effective hit rate of the lexical syntax, reduces the number of parameter pattern backtracking times, and reduces the time complexity to O(nlogn). This significantly reduces the impact of parsing performance on increasing netlist size.
[0049] S400: Perform parallel parsing on each independent atomic parsing partition according to the token stream to generate a local syntax tree.
[0050] Specifically, the incremental LALR(1) parser (Look-Ahead Left-to-Right Reduced) supports dynamic grammar stack snapshots (StateBack), and the GLL parser (Generalized Left-to-right Leftmos) can be used to process non-deterministic grammatical structures (such as the ambiguity of parameterized macros). This scheme uses the incremental LALR(1) parser and the GLL parser to perform mixed parsing on independent atomic parse partitions, performs LALR(1) reduction on the token stream of each independent atomic parse partition, and generates a local grammar tree.
[0051] S500: When a syntax error is detected during the parsing process, the current syntax stack state (StateBack) and the current symbol table are saved to a database.
[0052] S600: Determine the error interval according to the token stream, skip the error interval, and rebuild the grammar stack for subsequent parsing.
[0053] When a syntax error is detected during parsing, the limited lookahead repair algorithm is used to skip the error interval for subsequent parsing. Specifically, when this solution detects a syntax error (such as missing subcircuit port definition), the following actions are triggered:
[0054] Context snapshot: save the current syntax stack state (StateBack) and symbol table to the database (DB);
[0055] Error interval isolation: skip error intervals (such as those marked as `<ERROR_BLOCK> `), rebuild the grammar stack and continue parsing the subsequent content.
[0056] S700: After the user fixes the error, reparse the error interval, restore the context data based on the current syntax stack state, and update the corresponding local syntax tree.
[0057] In this solution, after the user fixes the error, the system only reparses<ERROR_BLOCK> `interval, and based on StateBack recovery context, avoid full re-parsing, so that the error recovery time is reduced from the full level of traditional LR(1) to the incremental level, the local repair efficiency is improved, and the interruption risk is reduced.
[0058] S800: Merge local syntax trees according to the dependency relationship of each independent atomic parsing partition to generate a complete syntax tree.
[0059] This solution can achieve efficient parsing of complex and large-scale netlists, and can greatly reduce the parsing time after error repair when syntax errors are triggered during the parsing process, effectively improving the physical and time performance of large-scale netlist parsing in EDA systems.
[0060] In one embodiment, based on the above embodiment, the netlist file is grammatically split into several independent atomic parsing partitions, including:
[0061] Based on the regular expression matching syntax boundary, the netlist file is split into several independent atomic parsing partitions, and a dependency graph is established according to the dependency relationship of each independent atomic parsing partition.
[0062] Based on regular expression matching syntax boundaries (for example, `.ENDS` marks the end of a subcircuit), the netlist file is divided into multiple APUs. The dependency graph between APUs (such as the subcircuit calling relationship) is established through symbol table scanning, which can ensure that the called modules are parsed first during parallel parsing.
[0063] Parallel task scheduling of each independent atomic resolution partition is performed through a lock-free circular queue, which also includes: generating a topological sorting sequence according to the dependency graph, sequentially scheduling the independent atomic resolution partitions with dependencies using the topological sorting sequence, and pushing the independent atomic resolution partitions without dependencies to the lock-free circular queue for parallel task scheduling.
[0064] The DAG scheduler generates a topologically sorted sequence based on APU dependencies and pushes independent APUs to a ring queue, which are then pulled by worker threads on demand.
[0065] This solution employs a shared symbol table locking mechanism and fine-grained read-write locks (RW-Locks) to ensure data consistency when multiple threads concurrently access the symbol table. Worker threads retrieve APUs from a circular queue and independently perform lexical and syntactic parsing to generate local syntax trees. A copy-on-write strategy is used for the global symbol table (such as subcircuit definitions), generating copies when threads modify them to avoid lock contention. The assembly engine recursively merges local syntax trees based on APU dependencies to generate complete netlist structured data. This solution avoids thread blocking and large-grained single-thread issues caused by module coupling in traditional serial parsing. It reduces the time required to split a GB-level netlist, reduces APU granularity, and achieves task load balancing.
[0066] In one embodiment, based on the above embodiment, each independent atomic parsing partition is lexically graded by a bitmap compression state machine and a dynamic symbol table, and a classified token stream is output, including:
[0067] The state transition table of each independent atomic parsing partition is compressed into a bitmap code through a bitmap compression state machine, and the bitmap code is lexically analyzed to perform lexical classification.
[0068] Lexical grading of each independent atomic parsing partition is performed through a bitmap compression state machine and a dynamic symbol table, and the output is a classified token stream, which also includes:
[0069] The basic data structures of each independent atomic parsing partition are matched through single instruction-multiple data instructions, and the data structure of the current basic data structure context is cached through the dynamic symbol table to establish the association relationship between the basic token and the context-related token.
[0070] BCSM (Bitmask-Compressed State Machine) compresses the state transition table of a traditional FSA (Finite State Automaton) into a bitmap encoding, reducing memory usage by over 50%. A multi-level FSA token classifier classifies tokens into basic tokens (such as node name `N1` and device value `R=1k`) and context-sensitive tokens (such as subcircuit instantiation call `X1 N1 N2 SUB_MOD`), using a hierarchical state machine for processing.
[0071] When generating a token stream, it includes: basic token matching, directly matching fixed patterns (such as the resistance value `R[0-9]+`) through BCSM, using SIMD instructions (such as AVX-512) to compare multiple characters in parallel, and completing multi-byte matching in a single cycle; context token processing, the dynamic symbol table caches the subcircuit / macro definition name of the current parsing context, and quickly retrieves token association relationships through hash indexes; token stream generation, encapsulating the classified tokens into a token stream (Token Stream) according to the APU partition, and appending grammatical context metadata (such as the current subcircuit level).
[0072] In one embodiment, based on the above embodiment, determining the error interval according to the token flow includes:
[0073] According to the tokens and token streams of the currently executed task when the syntax error is detected, a preset number of tokens are scanned forward through a limited look-ahead repair algorithm to determine the repair boundary, and then determine the error interval.
[0074] The limited lookahead repair algorithm is an algorithm used to optimize decision-making and problem-solving in specific domains. Its core concept is to simplify the solution process of complex problems by looking ahead to a limited depth of future states and actions. Limited lookahead repair algorithms are typically applied to problems with large state spaces where a complete solution would be computationally intensive. They are implemented through the following steps: Limited lookahead: Starting from the current state, possible future actions and observation sequences are simulated, but only for a limited number of steps (the lookahead depth). This approach avoids an exhaustive search of the entire state space, thereby reducing the computational effort; a pruning strategy: During the lookahead process, unlikely observations or states are pruned, retaining more likely scenarios to further optimize computing resources; and a dynamic update: Based on the lookahead results, the current strategy or repair solution is dynamically adjusted, and the observations after the action is executed are used as input for the next step of the lookahead process.
[0075] This solution uses an improved incremental LALR(1) and GLL hybrid parsing mode. When a syntax error is detected, a limited lookahead repair algorithm is used to localize the error based on the context snapshot mechanism. The error interval is skipped and the syntax stack state is rebuilt to continue parsing the subsequent content, reducing the risk of interruption. The parsed content is saved to a database structure. When the syntax error is fixed, only the error interval is reparsed, making full use of historical parsing nodes and improving the effective parsing reuse rate.
[0076] In one embodiment, based on the aforementioned embodiment, the netlist parsing method provided by the present invention further includes: splitting the netlist file into several independent atomic parsing partitions according to grammatical units through a directed acyclic graph scheduler, and generating a topological sorting sequence through the directed acyclic graph scheduler and the dependency graph.
[0077] This application provides an efficient algorithm flow and fault-tolerant processing for very large scale integrated circuit (VLSI) netlist parsing. On the one hand, the atomic splitting of the netlist enables it to have more concurrent multi-core processing conditions. At the same time, the use of tokens selects atomic partitions with higher reusability, and the replacement of high-frequency parameter patterns by SIMD further reduces invalid state jumps and backtracking. On the other hand, the incremental parsing of LALR(1) and GLL saves valid context snapshots and only resets the error interval when a syntax error is triggered, greatly reducing the parsing time after repair. In addition, for the divided atomic partitions, the DAG task scheduler can exert the performance of multi-core with finer-grained concurrency, improve the parsing efficiency, and effectively improve the physical and time performance of large-scale netlist parsing in EDA systems.
[0078] In one embodiment, based on the above embodiments, the present application provides a computer device, including a memory, a processor, and a computer program stored in the memory, and the processor executes the computer program to implement the steps of the netlist parsing method of the above embodiments.
[0079] In one embodiment, based on the aforementioned embodiment, the present application provides a computer storage medium having a computer program or instructions stored thereon, which implements the steps of the netlist parsing method of the aforementioned embodiment when the computer program or instructions are executed by a processor.
[0080] In one embodiment, based on the aforementioned embodiments, the present application provides a computer program product, including a computer program or instructions, which implements the steps of the netlist parsing method of the aforementioned embodiments when the computer program or instructions are executed by a processor.
[0081] It should be noted that the above embodiments can be freely combined as needed. The above description is only a preferred embodiment of the present invention. It should be pointed out that those skilled in the art can make several improvements and modifications without departing from the principles of the present invention, and such improvements and modifications should also be considered within the scope of protection of the present invention.
Claims
1. A netlist parsing method, characterized in that: The simulation design for ultra-large-scale integrated circuits includes the following steps: Obtaining a netlist file generated during the simulation design process of the ultra-large-scale integrated circuit; Splitting the netlist file into a plurality of independent atomic parsing partitions according to syntax, and performing parallel task scheduling of each of the independent atomic parsing partitions through a lock-free circular queue, wherein each of the independent atomic parsing partitions contains at least one complete sub-circuit module; Performing lexical classification on each of the independent atomic parsing partitions by compressing a state transition table of each of the independent atomic parsing partitions into a bitmap encoding state machine and a dynamic symbol table, and outputting a classified token stream, the token stream comprising basic tokens and context-related tokens, the basic tokens corresponding to basic data structures in the netlist file, and the context-related tokens corresponding to data structures context-related to the basic data structures; Parsing each of the independent atomic parsing partitions in parallel according to the token stream to generate a local syntax tree corresponding to each of the independent atomic parsing partitions; When a syntax error is detected during parsing, the current syntax stack state and the current symbol table are saved to the database; Determine an error interval according to the token stream, and skip the error interval to rebuild the grammar stack for subsequent parsing; After the user fixes the error, reparse the error interval, restore context data based on the current syntax stack state, and update the corresponding local syntax tree; The local syntax trees are merged according to the dependency relationship of each of the independent atomic parsing partitions to generate a complete syntax tree.
2. The netlist parsing method according to claim 1, wherein: The process of splitting the netlist file into a plurality of independent atomic parsing partitions according to the syntax includes: Splitting the netlist file into a plurality of independent atomic parsing partitions based on regular expression matching grammatical boundaries, Establishing a dependency graph according to the dependency relationships of the independent atomic parsing partitions; The parallel task scheduling of each of the independent atomic parsing partitions through the lock-free circular queue further includes: A topological sorting sequence is generated according to the dependency graph, the independent atomic resolution partitions with dependencies are sequentially scheduled using the topological sorting sequence, and the independent atomic resolution partitions without dependencies are pushed to the lock-free circular queue for parallel task scheduling.
3. The netlist parsing method according to claim 1, wherein: The method of performing lexical classification on each of the independent atomic parsing partitions by compressing the state transition table of each of the independent atomic parsing partitions into a bitmap-coded state machine and a dynamic symbol table, and outputting a classified token stream, comprises: The state transition table of each independent atomic parsing partition is compressed into a bitmap code by the state machine, and the bitmap code is lexically analyzed to perform lexical classification.
4. The netlist parsing method according to claim 3, wherein: The method of performing lexical classification on each of the independent atomic parsing partitions by compressing the state transition table of each of the independent atomic parsing partitions into a bitmap encoding state machine and a dynamic symbol table, and outputting a classification token stream, further includes: The basic data structures of each independent atomic parsing partition are matched through a single instruction-multiple data instruction, and the data structure related to the current basic data structure context is cached through a dynamic symbol table to establish an association relationship between the basic token and the context-related token.
5. The netlist parsing method according to claim 1, wherein: The step of performing parallel parsing on each of the independent atomic parsing partitions according to the token stream to generate a local syntax tree includes: Performing hybrid parsing on the independent atomic parsing partitions by using an incremental LALR(1) parser and a GLL parser to generate the local syntax tree; When a syntax error is detected during the parsing process, the erroneous interval is skipped for subsequent parsing using a limited lookahead repair algorithm.
6. The netlist parsing method according to claim 5, wherein: The determining of the error interval according to the token flow includes: According to the tokens of the currently executed task and the token stream when the syntax error is detected, a preset number of tokens are scanned forward by the limited look-ahead repair algorithm to determine the repair boundary, and then determine the error interval.
7. The netlist parsing method according to claim 2, wherein: The netlist file is split into a plurality of independent atomic parsing partitions according to syntax units by a directed acyclic graph scheduler, and a topological sorting sequence is generated by the directed acyclic graph scheduler and the dependency graph.
8. A computer device comprising a memory, a processor, and a computer program stored in the memory, wherein: The processor executes the computer program to implement the steps of the netlist parsing method according to any one of claims 1 to 7.
9. A computer storage medium having a computer program or instruction stored thereon, characterized in that: When the computer program or instruction is executed by a processor, the steps of the netlist parsing method according to any one of claims 1 to 7 are implemented.
10. A computer program product comprising a computer program or instructions, characterized in that When the computer program or instruction is executed by a processor, the steps of the netlist parsing method according to any one of claims 1 to 7 are implemented.
Citation Information
Patent Citations
Sliding window technology based hardware XML (Extensive Markup Language) parser
CN104267998A
Method and device for grammar analysis of PL / SQL language
CN113468873A