Clock optimization method, device and equipment and computer readable storage medium

By generating an instance tree and performing reverse and forward tracing of clock network paths, redundant clocks are identified and processed, solving the problems of resource waste and timing risks in cross-chip partitioning systems and achieving optimized resource utilization.

CN121072418APending Publication Date: 2025-12-05SHANDONG BOSUAN ZHIXIN INFORMATION TECHNOLOGY CO LTD
View PDF 0 Cites 4 Cited by

Patent Information

Application Number
CN202511194716.4
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2025-08-25
Publication Date
2025-12-05

AI Technical Summary

Technical Problem

In chip systems with cross-chip partitioning, redundant clocks lead to resource waste and timing risks. Existing technologies struggle to effectively identify and handle isolated redundant clocks and equivalent redundant clocks.

Method used

By reading the netlists of each shard, an instance tree is generated. Reverse tracing and forward tracing are performed to determine the clock network path. Redundant clocks, including isolated redundant clocks and equivalent redundant clocks, are identified and processed according to the path. Isolated redundant clocks are removed, equivalent redundant clocks are merged, and the master clock is planned in the global clock network.

Benefits of technology

It enables automatic identification and processing of redundant clocks, reducing resource waste, lowering chip power consumption and area overhead, improving resource utilization, and enhancing timing convergence.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN121072418A_ABST
    Figure CN121072418A_ABST
Patent Text Reader

Abstract

The invention discloses a clock optimization method, device and equipment and a computer readable storage medium, which are applied to the field of integrated circuits, and comprise the following steps: reading a netlist of each fragment, and traversing each netlist to generate an instance tree corresponding to each fragment; performing reverse tracing and forward tracing on each clock signal based on each instance tree to obtain a clock network path corresponding to each clock signal; determining a redundant clock according to each clock network path, and performing corresponding processing on the redundant clock; the redundant clock comprises an isolated redundant clock and an equivalent redundant clock. According to the method, the instance tree is generated by traversing the netlist, and the complete clock network path is obtained by combining reverse tracing and forward tracing, so that isolated redundant clocks and equivalent redundant clocks can be comprehensively captured, and automatic tracking of the clock network path and accurate identification of the redundant clocks are realized; the redundant clock is correspondingly processed, so that unnecessary clock generation logic and wiring resource occupation can be reduced, the chip power consumption and the area overhead are reduced, and the resource utilization rate is improved.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the field of integrated circuits, and in particular to a clock optimization method, apparatus, device, and computer-readable storage medium. Background Technology

[0002] In chip systems involving cross-chip partitioning, two types of clock redundancy issues are prone to occur: First, when the load module is assigned to another chip, the original chip's clock generation logic is not deleted, or the debugging clock remains due to the removal of the load, forming an isolated clock with no practical use, wasting resources and increasing power consumption; Second, when multiple chips need to share the same clock domain, if a global clock network is not enabled or a synchronizer is deployed, each chip will independently generate the same clock and build a clock tree, causing redundancy. This not only occupies resources but may also cause timing risks in cross-chip data interaction due to clock deviation.

[0003] Therefore, how to automatically and accurately identify redundant clocks, effectively process them, and reduce resource waste is a pressing technical problem that needs to be solved. Summary of the Invention

[0004] In view of this, the purpose of the present invention is to provide a clock optimization method, apparatus, device and computer-readable storage medium, which solves the problem of resource waste caused by the inability to effectively identify and process redundant clocks in the prior art.

[0005] To address the aforementioned technical problems, this invention provides a clock optimization method, comprising:

[0006] Read the netlist of each shard and traverse each netlist to generate the instance tree corresponding to each shard;

[0007] Based on each instance tree, reverse tracing and forward tracing are performed on each clock signal to obtain the clock network path corresponding to each clock signal;

[0008] Redundant clocks are determined based on the clock network paths described above, and the redundant clocks are processed accordingly; the redundant clocks include isolated redundant clocks and equivalent redundant clocks.

[0009] On the one hand, based on each instance tree, reverse tracing and forward tracing are performed on each clock signal to obtain the clock network path corresponding to each clock signal, including:

[0010] Based on the tree-like hierarchical structure of the instance tree, the clock signal node is located;

[0011] Initialize the stack and push the clock signal node onto the stack. Repeat the second step until the stack is empty to obtain the reverse tracing drive path.

[0012] The second step includes: popping the top node of the stack, recording the position of the top node of the stack in the driving path, checking the driving source of the top node of the stack, and pushing unvisited driving source nodes onto the stack;

[0013] Initialize the second queue and push the clock signal node into the second queue. Repeat the third step until the second queue is empty to obtain the load path for forward tracing.

[0014] The third step includes: popping the head node of the queue, recording the position of the head node of the queue in the load path, checking the load of the head node of the queue, and pushing unvisited load nodes into the second queue.

[0015] The clock network path corresponding to the clock signal is obtained based on the driving path and the load path.

[0016] On the one hand, the netlists of each shard are read, and each netlist is traversed to generate the instance tree corresponding to each shard, including:

[0017] Obtain the netlist files corresponding to each segment after segmentation, parse each netlist file, and extract the top-level module;

[0018] Each of the top-level modules is taken as the root node of each of the instance trees. Starting from the root node, the module instances are traversed in a queue manner to obtain each of the instance trees that reflects the module hierarchy and signal connections.

[0019] On the one hand, each of the top-level modules is taken as the root node of each of the instance trees. Starting from the root node, the module instances are traversed in a queue manner to obtain each of the instance trees reflecting the module hierarchy and signal connections, including:

[0020] The top-level module is used as the root node of the instance tree. The root node is placed in the first queue and used as the starting point of the first queue to start traversal. The first step is executed repeatedly until the first queue is empty, thus generating the instance tree.

[0021] The first step includes: popping the current first node, generating an instance identifier for the current first node, recording the attributes of the current first node, and putting the child nodes of the current first node into the first queue.

[0022] On the one hand, determining redundant clocks based on each of the aforementioned clock network paths includes:

[0023] Based on each of the clock network paths, a load node query is performed for a single-chip single-clock. If the query fails, the single-chip single-clock is the isolated redundant clock.

[0024] Based on each clock network path, a similarity comparison is performed between multiple clocks across chips. If the comparison result meets the preset conditions, then the multiple clocks across chips are the equivalent redundant clocks.

[0025] On the one hand, the redundant clock is processed accordingly, including:

[0026] Remove the isolated redundant clock;

[0027] A master clock is selected from the equivalent redundant clocks according to the clock merging priority, and the master clock is planned to the global clock network. A buffer and clock synchronizer are added to the target partition; the target partition is the partition where the other clocks besides the master clock are located in the equivalent redundant clocks.

[0028] On the one hand, after processing the redundant clock accordingly, the method also includes:

[0029] Locate the modification area and perform timing verification using incremental engineering change orders based on the modification area;

[0030] After the timing verification is passed, the signal mapping table is updated according to the adjustment information, and the ports are adapted synchronously. The optimized and verified netlists of each segment are then output.

[0031] This invention provides a clock optimization device, comprising:

[0032] The instance tree construction module is used to read the netlist of each shard and traverse each netlist to generate the instance tree corresponding to each shard.

[0033] The path acquisition module is used to perform reverse tracing and forward tracing of each clock signal based on each instance tree to obtain the clock network path corresponding to each clock signal.

[0034] A redundant clock processing module is used to determine redundant clocks according to the clock network paths and to process the redundant clocks accordingly; the redundant clocks include isolated redundant clocks and equivalent redundant clocks.

[0035] This invention provides a clock optimization device, comprising:

[0036] Memory, used to store computer programs;

[0037] A processor for implementing the clock optimization method described above when executing the computer program.

[0038] The present invention also provides a computer-readable storage medium storing computer-executable instructions, which, when loaded and executed by a processor, implement the clock optimization method described above.

[0039] The present invention also provides a computer program product, including a computer program / instructions that, when executed by a processor, implement the steps of the clock optimization method described above.

[0040] As can be seen from the above technical solution, this invention reads the netlists of each slice and traverses each netlist to generate an instance tree corresponding to each slice; based on each instance tree, it performs reverse tracing and forward tracing on each clock signal to obtain the clock network path corresponding to each clock signal; it determines redundant clocks according to each clock network path and processes the redundant clocks accordingly; the redundant clocks include isolated redundant clocks and equivalent redundant clocks. The beneficial effects of this invention are: by traversing the netlist to generate an instance tree, and combining reverse tracing and forward tracing to obtain a complete clock network path, this invention can comprehensively capture isolated redundant clocks and equivalent redundant clocks, realizing automatic tracking of clock network paths and accurate identification of redundant clocks; by processing the redundant clocks accordingly, unnecessary clock generation logic and wiring resource occupation can be reduced, chip power consumption and area overhead can be reduced, and resource utilization can be improved.

[0041] In addition, the present invention also provides a clock optimization device, apparatus, and computer-readable storage medium, which also have the above-mentioned beneficial effects. Attached Figure Description

[0042] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.

[0043] Figure 1 A flowchart of a clock optimization method provided in an embodiment of the present invention;

[0044] Figure 2 An example diagram of an FPGA engineering hierarchy structure provided in an embodiment of the present invention;

[0045] Figure 3 A flowchart illustrating a reverse trace clock-driven logic process provided in an embodiment of the present invention;

[0046] Figure 4 This is an example diagram of a clock network structure with clock signal nodes pointing upwards, provided by an embodiment of the present invention.

[0047] Figure 5 A flowchart illustrating a clock optimization method provided in an embodiment of the present invention;

[0048] Figure 6 This is a schematic diagram of the structure of a clock optimization device provided in an embodiment of the present invention;

[0049] Figure 7 This is a schematic diagram of a clock optimization device provided in an embodiment of the present invention. Detailed Implementation

[0050] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0051] First, let me explain some of the terms used in this application:

[0052] FPGA: Field Programmable Gate Array, is a product of further development based on traditional programmable devices. It emerged as a semi-custom circuit in the field of Application-Specific Integrated Circuits (ASICs), solving the shortcomings of custom circuits and overcoming the limitation of the limited number of gate circuits in traditional programmable devices.

[0053] ASIC: Application Specific Integrated Circuit, refers to an integrated circuit designed and manufactured to meet the specific requirements of a user and the needs of a specific electronic system.

[0054] SOC: System on Chip, also known as a system-on-a-chip, refers to a product, an integrated circuit with a specific purpose, containing a complete system and all embedded software.

[0055] FPGA prototype verification: This is an ASIC verification method based on FPGA. It is generally performed after the front-end RTL design and RTL simulation stages are completed and before the ASIC is fabricated. It verifies as many functions of the ASIC as possible on the FPGA prototype.

[0056] Hardware simulation acceleration platform: Similar to FPGA prototyping platform, this is also a hardware platform that can perform chip verification before chip tape-out. Compared to FPGA prototyping platform, its main advantage lies in its unique, ultra-large-scale hardware architecture, which ensures the integrity of the RTL design as much as possible. From a hardware implementation perspective, it generally has two architectures: FPGA-based and CPU-based.

[0057] Hardware emulation acceleration platform prototyping is currently the mainstream and mature chip verification method. It verifies the functionality of the chip design's RTL circuit by porting it to a hardware emulation acceleration platform. After the basic functionality of the chip design's RTL circuit is verified, chip firmware and low-level driver development can begin, continuing until the chip is fabricated and returned to the real chip. Once the chip is returned to the real chip, the application can be easily adapted based on the firmware and drivers developed on the hardware emulation acceleration platform, allowing it to be applied directly to the actual chip.

[0058] RTL: Register Transfer Level, in integrated circuit design, is an abstract description of the operation of synchronous digital circuits.

[0059] In chip systems involving cross-chip partitioning, two types of clock redundancy issues are prone to occur: First, when the load module is assigned to another chip, the original chip's clock generation logic is not deleted, or the debugging clock remains due to the removal of the load, forming an isolated clock with no practical use, wasting resources and increasing power consumption; Second, when multiple chips need to share the same clock domain, if a global clock network is not enabled or a synchronizer is deployed, each chip will independently generate the same clock and build a clock tree, causing redundancy. This not only occupies resources but may also cause timing risks in cross-chip data interaction due to clock deviation.

[0060] Among them, the chip system with cross-chip partitioning can be an FPGA, ASIC, SoC, or other chip system with cross-chip partitioning. For example, the technical issues are illustrated below using an FPGA partitioning scenario. With the continuous development and iteration of integrated circuit technology, the functions and structures of chips have become increasingly complex. Traditional front-end verification methods can no longer fully guarantee the effectiveness of ASIC designs and meet the needs of collaborative development of corresponding driver software. Against this backdrop, the emergence of FPGA prototyping platforms provides a solution to the above problems. This platform aims to equivalently simulate the hardware environment of ASIC designs, helping ASIC designers improve design stability and providing software developers with a real physical platform to accelerate chip time-to-market. Currently, ASIC designs are becoming increasingly large-scale and complex, and a single FPGA can no longer meet the resource requirements for prototyping verification. Therefore, a typical representative product serving multi-FPGA verification platform technology (i.e., the HAPS prototyping platform) has emerged. It can provide ASIC / SoC designers with a high-performance, high-capacity FPGA-based prototyping platform, offering designers more convenience and improving development efficiency. When ASIC designs are large-scale and partitioned across multiple FPGAs, some clock signals whose original load modules are assigned to different FPGAs may remain even after proper pruning of their original clock generation logic (such as PLLs and MMCMs). Alternatively, some debug or test clocks (such as JTAG-TAP) may be retained after partitioning, but lose their load due to module removal, resulting in redundant isolated clocks remaining on the FPGA. Furthermore, when multiple FPGAs require the same clock domain, the partitioning tool may not enable a global clock network, causing each FPGA to generate the same clock independently. Additionally, the lack of clock synchronizers between FPGAs may force the partitioning tool to build a separate clock tree for each FPGA, leading to redundant equivalent clocks between FPGAs. Therefore, for FPGA partitioning scenarios, a method is urgently needed to properly handle isolated or equivalent redundant clocks that may exist on a single FPGA after partitioning during ASIC-to-FPGA porting and implementation on a prototype verification platform. This method should include marking, merging, or removing redundant clocks to improve the partitioning scheme, optimize clock resource allocation, and enhance timing convergence.

[0061] Currently, the following methods are used to handle redundant clocks formed after the FPGA prototype version is segmented: (1) Manual inspection and trimming: Manually check the clock signal connection relationship through schematic diagram or netlist, verify whether the clock signal is actually used through functional simulation, manually write TCL script to delete no-load clocks or comment or delete redundant clock constraints in XDC (Xilinx DesignConstraints, a text file used to define timing constraints, physical constraints and configuration constraints) file. (2) Physical level manual removal: Check the clock resource usage through tool reports, and manually remove redundant BUFG / BUFH after placement and routing. (3) Manual constraint-driven optimization: Define clock groups in constraints to avoid redundancy optimization, use "CLOCK BUFFER_TYPE BUFG" to force critical clocks to use global buffers, and use "PBLOCK CLK_REDUNDANT_PBLOCK" to limit the placement range of redundant clocks. (4) Identify inefficient clocks through synthesis tools (such as Synopsys DC).

[0062] The above traditional methods have the following problems: (1) Low efficiency, strong reliance on manual labor, insufficient tool coordination, inconsistent clock optimization strategies among synthesis and placement / routing tools, requiring multiple iterations. Moreover, they may face the risk of timing violations. (2) Limited coverage, unable to detect dynamically configured loads, leading to the accidental deletion of valid clocks; cross-clock domain clocks are a blind spot, making it impossible to quickly and accurately identify equivalent clocks in asynchronous clock domains. (3) The placement and routing of clock networks directly affect timing margins. If I / O pins are not allocated reasonably or global clock resources (such as BUFG) are not selected, redundant clocks may have insufficient margins due to routing delays, or even cause timing violations.

[0063] Therefore, for large-scale ASIC designs involving multiple FPGAs in partitioning scenarios, an optimization method is proposed to address the potential presence of isolated or equivalent redundant clocks in the netlist of a single partitioned FPGA. This method reads the partitioned netlist, traces and tracks the clock network, marks redundant clocks, and handles them according to their specific cases. This clock optimization method can handle any integrated circuit / chip system with cross-chip partitioning scenarios. For example, in a chip prototyping platform scenario involving multiple FPGAs in partitioning, this method can handle isolated redundant clocks remaining in a single FPGA due to the clock generation logic not being properly pruned following the partitioning strategy, as well as equivalent redundant clocks formed between FPGA chips due to the lack of a global clock network.

[0064] Please refer to the details. Figure 1 , Figure 1 A flowchart illustrating a clock optimization method provided in an embodiment of the present invention. The method may include:

[0065] S101: Read the netlist of each shard and traverse each netlist to generate the instance tree corresponding to each shard.

[0066] The execution subject in this embodiment is a terminal. This embodiment does not limit the type of terminal, as long as it can perform the clock optimization method.

[0067] It's important to note that a netlist is structured data describing the connections between circuit components in integrated circuit (IC) or electronic system design. Its core function is to define which components are connected via which signal lines, serving as a crucial bridge between logic design and physical implementation. Its content can include: components, signal lines, ports, hierarchical relationships, link relationships, and optional attributes and constraints. For example, using an FPGA partitioning scenario, the netlist describes the physical implementation of FPGA slices, recording the connection relationships of all signals (including clock signals), instantiation information of logic units (such as registers and buffers), etc.

[0068] In this embodiment, each segment can be understood as the individual FPGAs after being divided from multiple FPGAs, or as the individual SOCs after being divided from multiple SOCs. The netlist of each segment is read, the data content in the netlist is traversed, and an instance tree corresponding to each segment is generated. This instance tree reflects the module hierarchy and signal connection relationships. This embodiment does not limit the specific method of constructing the instance tree. For example, it can be done using a queue, or it can be done by directly processing the root node and recursively processing the child nodes to complete the traversal.

[0069] Furthermore, the netlists of each shard are read, and the instance tree corresponding to each shard is generated by traversing each netlist. Specifically, this may include the following steps:

[0070] Step 11: Obtain the netlist files corresponding to each segment after splitting, parse each netlist file, and extract the top-level module;

[0071] Step 12: Take each top-level module as the root node of each instance tree. Starting from the root node, traverse the module instances in a queue to obtain each instance tree that reflects the module hierarchy and signal connections.

[0072] This embodiment leverages the advantages of queues to ensure processing in a hierarchical order. The resulting tree structure (i.e., instance tree) strictly reflects the hierarchical relationship of modules, facilitating subsequent analysis of how many modules are in each layer and how signals are transmitted across layers.

[0073] Specifically, in this embodiment, the segmented netlist files are imported and parsed using EDA (Electronic Design Automation) tools. The top-level module in each segment netlist file is extracted and used as the root node of each instance tree. Starting from the root node, the module instances are traversed using a queue to obtain the instance tree corresponding to each segment.

[0074] Furthermore, each top-level module is used as the root node of each instance tree. Starting from the root node, the module instances are traversed using a queue to obtain each instance tree that reflects the module hierarchy and signal connections. Specifically, this may include the following steps:

[0075] The top-level module is used as the root node of the instance tree. The root node is placed in the first queue and used as the starting point of the first queue to start traversal. The first step is executed repeatedly until the first queue is empty, thus generating the instance tree. The first step includes: popping the current first node, generating the instance identifier of the current first node, recording the attributes of the current first node, and putting the child nodes of the current first node into the first queue.

[0076] Specifically, the search begins from the root node and proceeds downwards, traversing the module instances. A queue is created, the root node is added to the queue, and then a loop checks if the queue is not empty. If so, the current node is popped, an instance identifier (UUID) is generated, and the node's attributes are recorded. After recording, its child nodes are added to the queue. This process continues downwards, layer by layer, until the queue is empty, indicating that the current child node has no more child nodes. The traversal is complete, generating a tree-like hierarchical structure. Assume an FPGA project has the following structure... Figure 2 The hierarchical structure shown is illustrated in Table 1, which demonstrates the process of traversing to generate the instance tree. The attributes can include a parent node, a list of child nodes, an input / output port mapping table, stored signal line connection information, and stored cross-module net connection relationships. For example, the identifier can be FPGA number_layer_serial number.

[0077] Table 1. Demonstration process of traversing and generating the instance tree.

[0078]

[0079] S102: Based on each instance tree, perform reverse tracing and forward tracing of each clock signal to obtain the clock network path corresponding to each clock signal.

[0080] It's important to note that the core of the reverse clock tracing logic is to completely trace the source of each clock signal, making it suitable for depth-first search implemented using a stack. The core of the forward clock tracing logic is to comprehensively cover all downstream nodes, making it suitable for breadth-first search implemented using a queue. The choice of these two data structures essentially matches the different tracing targets' requirements for traversal order.

[0081] Furthermore, based on each instance tree, each clock signal is traced backwards and forwards to obtain the clock network path corresponding to each clock signal. This can specifically include the following steps:

[0082] Step 21: Based on the hierarchical tree structure of the instance tree, locate the clock signal node.

[0083] Specifically, this step is the clock signal node location process. The clock signal node is located based on the generated tree hierarchy (i.e., the instance tree).

[0084] Furthermore, the above-mentioned tree-like hierarchical structure based on instance trees, used to locate clock signal nodes, may include the following steps:

[0085] Step 211: Traverse the hierarchical structure of the instance tree, visiting each instance tree node level by level;

[0086] Step 212: Extract the attribute information of each instance tree node. The attribute information includes node type, signal name, port type, and associated module identifier.

[0087] Step 213: Match the attribute information with the preset clock feature library, and mark the successfully matched instance tree nodes as clock signal nodes; the clock feature library contains the feature identifiers of clock signals.

[0088] Specifically, by traversing the hierarchical structure of the instance tree, the attribute information of each node (such as signal name, port type, associated module, etc.) is extracted and matched with a preset clock feature library (including keywords such as clk and clock, clock input port type, PLL / MMCM association identifier, etc.). Nodes that successfully match are marked as clock signal nodes. Based on the matching rules of the feature library, clock signal nodes can be quickly located from complex instance trees, avoiding omissions or misjudgments caused by manual identification, improving positioning efficiency, and achieving accuracy and efficiency. Furthermore, through an expandable feature library (such as flexibly adding clock-related keywords or module identifiers), it can adapt to clock signal naming and association methods under different design specifications, be compatible with diverse circuit design scenarios, and complete the identification and marking of clock signal nodes without manual intervention, providing reliable automated input for subsequent clock network tracing, redundant clock processing, and other processes, reducing the design cycle.

[0089] Step 22: Initialize the stack and push the clock signal node onto the stack. Repeat the second step until the stack is empty to obtain the reverse-tracing drive path. The second step includes: popping the top node from the stack, recording the position of the top node in the drive path, checking the drive source of the top node, and pushing unvisited drive source nodes onto the stack.

[0090] Specifically, this step involves the reverse tracing of the clock signal's driving logic. The reverse tracing process is as follows: Figure 3 As shown, the process is as follows: Initialize the stack, push clock signal nodes, then loop through and pop the current node (i.e., the top node of the stack), record the path, check the driver source, and continue pushing unvisited driver source nodes until the stack is empty, i.e., until the master clock source is found. Assuming the current clock signal node is in FF_a, its upward (reverse tracing) clock network structure is as follows: Figure 4 As shown, the backtracking process is presented in Table 2.

[0091] Table 2. Demonstration of the backtracking clock-driven logic process

[0092]

[0093] Step 23: Initialize the second queue and push the clock signal node into the second queue. Repeat the third step until the second queue is empty to obtain the forward-traced load path. The third step includes: popping the head node, recording the position of the head node in the load path, checking the load of the head node, and pushing unvisited load nodes into the second queue.

[0094] Specifically, this step is the load process of forward tracking the clock signal. The process is as follows: initialize the queue, push clock signal nodes, enter a loop to judge, continuously pop the current node (i.e., the head node of the queue), record the path, and push unvisited load nodes until the queue is empty.

[0095] Step 24: Obtain the clock network path corresponding to the clock signal based on the drive path and load path.

[0096] Understandably, to improve efficiency, steps 22 and 23 can be executed simultaneously. Together, they form a complete clock network path.

[0097] S103: Determine redundant clocks based on each clock network path and process them accordingly; redundant clocks include isolated redundant clocks and equivalent redundant clocks.

[0098] This embodiment can determine isolated redundant clocks and equivalent redundant clocks based on the clock network path, and performs differentiated processing for different types of redundant clocks, aiming to eliminate the resource waste caused by redundant clocks. Taking an FPGA partitioning scenario as an example, isolated redundant clocks and equivalent redundant clocks are explained. An isolated redundant clock refers to a clock signal that exists within the FPGA without any logic load driving it (i.e., the clock is not connected to the clock input of any flip-flop, register, or module), but the logic (such as a PLL (phase-locked loop) or MMCM (mixed-mode clock manager) that generates the clock or the physical resources (such as the wiring network) are still retained. An equivalent redundant clock refers to multiple FPGAs independently generating identical clock signals (the frequency and phase should theoretically be consistent) for the same clock domain, but not sharing them through a global synchronization mechanism. This results in each FPGA having a complete set of clock generation and allocation logic, causing resource redundancy and potential synchronization risks.

[0099] Furthermore, the determination of redundant clocks based on each clock network path can specifically include the following steps:

[0100] Step 31: Based on each clock network path, perform a load node query for a single-chip single-clock. If the query fails, the single-chip single-clock is an isolated redundant clock.

[0101] Step 32: Based on each clock network path, perform a similarity comparison of multiple clocks across chips. If the comparison results meet the preset conditions, then the multiple clocks across chips are equivalent redundant clocks.

[0102] To improve search efficiency and accuracy, step 31 can be executed first, followed by step 32. Specifically, based on the obtained clock network path, a single-chip single-clock determination is first performed. If no load node information is found for the clock, it is marked as an isolated redundant clock; otherwise, it is marked as a valid clock. Then, a cross-chip multi-clock comparison is performed. The similarity comparison can be based on frequency offset and load similarity. Load similarity can be calculated by comparing the recorded clock information with the load module type, quantity, fan-out, and register quantity, and weighting the load similarity accordingly. The weights of each indicator can be dynamically adjusted according to the design. The process of determining cross-chip multi-clocks can include: based on the information recorded in the instance tree, clocks with inter-chip cross-references and / or cross-clock domain signals are marked as cross-chip multi-clocks. This embodiment does not limit the preset conditions. For example, based on the clock structure complexity of the RTL design and past experience, if the frequency offset is less than 0.1% and the load similarity is greater than 95%, it is marked as an equivalent redundant clock; otherwise, it is marked as a valid clock.

[0103] Furthermore, the aforementioned redundant clocks are processed accordingly, which may specifically include the following steps:

[0104] Step 41: Remove isolated redundant clocks;

[0105] Step 42: Select the master clock from the equivalent redundant clocks according to the clock merging priority, and plan the master clock to the global clock network. Add a buffer and clock synchronizer to the target partition; the target partition is the partition where the other clocks besides the master clock are located in the equivalent redundant clocks.

[0106] Specifically, for isolated redundant clocks, TCL instructions are used to modify the corresponding netlist and remove the clock signal line, thus removing the isolated redundant clock. For equivalent redundant clocks, a clock merging priority is first established. The purpose of merging priority is to select clocks with strong driving capability, short paths, and low jitter. Based on the clock merging priority, suitable equivalent redundant clocks in a certain chip are screened out as the master clock. The master clock is responsible for driving the core logic of the chip (such as data paths and control units), and its stability directly affects the functional correctness and performance limit of the entire circuit. Therefore, it is planned into the Global Clock Network (a low-latency, low-skew, and high-stability routing structure specifically designed for high-fan-out, high-priority clock signals in the chip). For other clocks in the equivalent redundant clocks besides the master clock, IBUFG / IBUFDS buffers are inserted into their respective segments, and clock synchronizers (such as Xilinx's IDELAYCTRL+BUFR combination) are added. These are used to compensate for transmission delay, stabilize clock phase, and ensure the stability of the clock signal at the receiving end. Furthermore, the secondary clock can be deactivated. It should be explained that deactivation is not a complete disablement, but rather a reduction in its activity state (such as stopping the core logic from being driven or disconnecting the main path), while retaining its potential to be reactivated. The purpose is to ensure the system's fault tolerance, flexibility, and debugging needs.

[0107] For example, FPGA_A has clock CLK1, and FPGA_B has clock CLK2, both marked as equivalent redundant clocks. Since CLK1 in FPGA_A originates from the global clock network, it has stronger driving capability and better signal quality, therefore CLK1 in FPGA_A is chosen as the master clock. The original clock path in FPGA_B then needs to be adjusted. A PORT→IBUFG→BUFG→MMCM cascade structure is inserted at the top level of FPGA_B to maintain clock tree balance. An IDELAYCTRL+BUFR combination is added to compensate for board-level transmission delay, and the original driving source of clock CLK2 in FPGA_B is disconnected.

[0108] Furthermore, after processing the redundant clocks accordingly, the above may also include the following steps:

[0109] Step 51: Locate the modification area and perform timing verification using incremental engineering change orders based on the modification area;

[0110] Step 52: After the timing verification is passed, update the signal mapping table according to the adjustment information, and simultaneously perform adaptation processing on the ports, outputting the optimized and verified netlists for each segment.

[0111] Specifically, the modification area is located, and timing verification is performed using incremental ECO (Engineering Change Order). This can be done through static timing analysis, comparing clock skew changes before and after optimization; or dynamic simulation verification can be initiated for more accurate results. After successful timing verification, the signal mapping table is updated based on the adjustment information, and port adaptation is performed, including unifying cross-chip port naming, verifying and aligning bit widths, updating interconnect information, etc. Finally, the segmented netlist is reconstructed, and the updated netlist is output. The modification area refers to the specific scope or module in the chip design's netlist, physical layout, or timing constraints that requires adjustment, deletion, merging, or reconstruction. For example, the modifications mentioned above regarding redundant clock handling.

[0112] The clock optimization method provided in this invention involves reading the netlists of each slice and traversing each netlist to generate an instance tree corresponding to each slice. Based on each instance tree, the clock signals are traced backward and forward to obtain the clock network path corresponding to each clock signal. Redundant clocks are determined according to each clock network path, and corresponding processing is performed on the redundant clocks. Redundant clocks include isolated redundant clocks and equivalent redundant clocks. It is evident that this method can optimize and process redundant isolated clocks remaining due to the clock generation logic not being properly pruned according to the segmentation strategy, as well as redundant equivalent clocks formed between slices due to the lack of a global clock network. By traversing the netlist to generate an instance tree, and using reverse clock-driven logic and forward clock signal loads, a complete clock network path closed loop is formed. This comprehensively captures isolated redundant clocks and equivalent redundant clocks, achieving automatic clock network path tracing without relying on manual searching. It also achieves automatic identification and classification of redundant clocks, and can dynamically adjust according to different designs, improving the identifiability of paths with timing risks. Furthermore, it enables automatic processing of redundant clock classification, modifying, removing, or merging them locally based on different types, reducing dependence on segmentation tools. Appropriate processing of redundant clocks reduces unnecessary clock generation logic and routing resource consumption, lowers chip power consumption and area overhead, and improves resource utilization. When this method is specifically applied to redundant clock optimization based on a prototype verification platform, it can trace and track the origin of the clock network, mark and process redundant clocks after segmentation, further improve the segmentation scheme, optimize clock resource allocation, and enhance timing convergence.

[0113] For a clearer understanding of this invention, please refer to the following details. Figure 5, Figure 5 This is a flowchart illustrating a clock optimization method provided in an embodiment of the present invention. Taking an FPGA-partitioned scene as an example, it may specifically include:

[0114] The first step is to read the segmented FPGA netlist. Import the netlist corresponding to each FPGA obtained from the segmentation, and use EDA tools to parse it to obtain the FPGA project netlist file.

[0115] The second step is to traverse and generate an instance tree. Extract the top-level module of each FPGA netlist as the root node and traverse the FPGA module instances. Start searching from the root node, iterating through the queue. If the queue is not empty, pop the current node, generate an instance UUID (FPGA number_layer_serial number), record the node's attributes (parent node, child node list, and input / output port mapping table), and store signal line connection information and cross-module net connection relationships. After recording, enqueue the child nodes. Continue this process layer by layer downwards until the queue is empty, indicating that there are no more child nodes under the current child node. The traversal is then complete, generating a tree-like hierarchical structure.

[0116] The third step is cross-FPGA correlation. Based on the information recorded during traversal, signals with cross-references are filtered out, and clock domains across chips are marked to determine the equivalent redundant clock.

[0117] The fourth step is clock network tracing and tracking. The clock signal node is located in the generated tree structure, and the clock driving logic is traced backwards. This clock signal node is pushed onto the stack, which is then initialized. A loop is then entered, popping nodes, recording the path, and continuously pushing unvisited driving source nodes onto the stack until the master clock source is found, thus tracing back the entire clock path. Simultaneously, the clock signal load is traced forwards, similar to the traversal process in the second step. A queue is initialized, the clock signal node is pushed onto the stack, and a loop is entered to check for unvisited load nodes, continuously popping the current node, recording the path, and pushing unvisited load nodes onto the stack until the queue is empty. Combining these two steps forms the complete clock network path.

[0118] Step 5: Redundant Clock Marking. Based on the acquired clock network path, first determine the single clock for a single FPGA. If no load node information is found, mark it as an isolated redundant clock; otherwise, mark it as a valid clock. Then, perform multi-FPGA multi-clock comparison and calculate the frequency offset. Simultaneously, based on the clock information recorded in Step 4, compare its load module type, quantity, fan-out, and register quantity, and calculate the load similarity using weighted averages. The weights of each indicator can be dynamically adjusted according to the design. Based on the clock structure complexity of the RTL design and past experience, if Δf / f < 0.1% and the load similarity is greater than 95%, mark it as an equivalent redundant clock; otherwise, mark it as a valid clock.

[0119] Step 6: Redundant Clock Handling. For isolated redundant clocks, a TCL instruction is used to remove the clock signal line. For equivalent redundant clocks, a clock merging priority is first established, prioritizing clocks with strong drive capability, short paths, and low jitter as the master clock. For clocks transmitted across the FPGA (i.e., equivalent redundant clocks other than the master clock), an IBUFG / IBUDS buffer is inserted at the top level of the FPGA to maintain clock tree balance, and a clock synchronizer combination is added to compensate for board-level transmission delay. The secondary clock is then activated.

[0120] Step 7: Timing Verification. Locate the modified area and perform timing verification using incremental ECO (Engineering Change Order), such as static timing analysis, comparing the clock skew changes before and after optimization; dynamic simulation verification can also be initiated to obtain more accurate verification results.

[0121] Step 8: Update interconnection relationships. Based on the above adjustments, update the signal mapping table, adapt the ports, unify cross-FPGA port naming, verify and align bit widths, and update interconnection information.

[0122] Step 9: Output the FPGA netlist.

[0123] As can be seen, this method can handle redundant isolated clocks remaining when multiple FPGAs are involved in the partitioning process on a chip prototyping platform. This is because the FPGA's clock generation logic fails to trim the clocks in a timely and accurate manner according to the partitioning results. It also addresses redundant equivalent clocks caused by the repeated mapping of different clock domains due to the lack of a global clock network or imperfect inter-chip synchronization. By releasing unnecessary clocks in the redundant clock network, the occupation of global clock resources within the FPGA can be reduced, freeing up more clock management units (CMT / MMCM) for critical path timing optimization. Redundant clocks typically require additional clock constraints and dedicated routing resources; releasing them reduces the processing pressure on placement tools, shortens routing time, and avoids placement failures due to exceeding regional clock resource limits. Optimizing redundant clocks allows for the early identification and avoidance of clock paths with timing risks, improving the timing convergence of the FPGA, reducing the number of later iterations, and shortening version creation time.

[0124] The clock optimization device provided in the embodiments of the present invention will be described below. The clock optimization device described below and the clock optimization method described above can be referred to in correspondence.

[0125] Please refer to the details. Figure 6 , Figure 6 A schematic diagram of a clock optimization device provided in an embodiment of the present invention may include:

[0126] The instance tree construction module 100 is used to read the netlist of each shard and traverse each netlist to generate the instance tree corresponding to each shard.

[0127] The path acquisition module 200 is used to perform reverse tracing and forward tracing of each clock signal based on each instance tree to obtain the clock network path corresponding to each clock signal.

[0128] The redundant clock processing module 300 is used to determine redundant clocks according to the clock network paths and to process the redundant clocks accordingly; the redundant clocks include isolated redundant clocks and equivalent redundant clocks.

[0129] Based on the above embodiments, the path acquisition module 200 may include:

[0130] A clock signal node positioning unit is used to locate clock signal nodes based on the tree-like hierarchical structure of the instance tree.

[0131] The drive path acquisition unit is used to initialize the stack and push the clock signal node onto the stack, and repeatedly execute the second step until the stack is empty to obtain the reverse-traced drive path; the second step includes: popping the top node of the stack, recording the position of the top node of the stack in the drive path, checking the drive source of the top node of the stack, and pushing the unvisited drive source node onto the stack.

[0132] The load path acquisition unit is used to initialize the second queue and push the clock signal node into the second queue, and repeatedly execute the third step until the second queue is empty to obtain a forward-tracking load path; the third step includes: popping the head node of the queue, recording the position of the head node of the queue in the load path, checking the load of the head node of the queue, and pushing unvisited load nodes into the second queue.

[0133] A clock network path acquisition unit is used to obtain the clock network path corresponding to the clock signal based on the driving path and the load path.

[0134] Based on the above embodiments, the instance tree construction module 100 may include:

[0135] The top-level module acquisition unit is used to acquire the netlist files corresponding to each segment after segmentation, parse each netlist file, and extract the top-level module.

[0136] The instance tree construction unit is used to take each of the top-level modules as the root node of each instance tree, and traverse the module instances in a queue manner starting from the root node to obtain each instance tree that reflects the module hierarchy and signal connections.

[0137] Based on the above embodiments, the instance tree construction unit may include:

[0138] An instance tree generation subunit is used to take the top-level module as the root node of the instance tree, put the root node into a first queue, and start traversal as the starting point of the first queue, repeatedly executing the first step until the first queue is empty, thereby generating the instance tree; the first step includes: popping the current first node, generating an instance identifier of the current first node, recording the attributes of the current first node, and putting the child nodes of the current first node into the first queue.

[0139] Based on the above embodiments, the redundant clock processing module 300 may include:

[0140] An isolated redundant clock determination unit is used to query the load node of a single-chip single clock based on each of the clock network paths. If the query fails, the single-chip single clock is the isolated redundant clock.

[0141] An equivalent redundant clock determination unit is used to perform a similarity comparison of multiple clocks across chips based on each of the clock network paths. If the comparison result meets a preset condition, the multiple clocks across chips are the equivalent redundant clocks.

[0142] Based on any of the above embodiments, the redundant clock processing module 300 may include:

[0143] The first processing unit is used to remove the isolated redundant clock;

[0144] The second processing unit is used to select a master clock from the equivalent redundant clocks according to the clock merging priority, and plan the master clock to the global clock network, and add a buffer and clock synchronizer to the target partition; the target partition is the partition where the other clocks besides the master clock are located in the equivalent redundant clocks.

[0145] Based on the above embodiments, the clock optimization device may further include:

[0146] The timing verification module is used to locate the modified area after processing the redundant clock, and to perform timing verification based on the modified area using incremental engineering change orders.

[0147] The netlist update module is used to update the signal mapping table according to the adjustment information after the timing verification is passed, and to simultaneously perform port adaptation processing, and output the optimized and verified netlists for each segment.

[0148] It should be noted that the order of the modules and units in the aforementioned clock optimization device can be changed without affecting the logic.

[0149] The clock optimization device provided in this embodiment of the invention uses an instance tree construction module 100 to read the netlists of each slice and traverse each netlist to generate an instance tree corresponding to each slice; a path acquisition module 200 to perform reverse tracing and forward tracing on each clock signal based on each instance tree to obtain the clock network path corresponding to each clock signal; and a redundant clock processing module 300 to determine redundant clocks according to the clock network paths and process the redundant clocks accordingly. The redundant clocks include isolated redundant clocks and equivalent redundant clocks. Therefore, this device can optimize and process redundant isolated clocks remaining due to the clock generation logic not being properly pruned following the segmentation strategy, as well as redundant equivalent clocks formed between slices due to the lack of a global clock network. By traversing the netlist to generate an instance tree, and using reverse clock-driven logic and forward clock signal loads, a complete clock network path closed loop is formed. This comprehensively captures isolated redundant clocks and equivalent redundant clocks, achieving automatic clock network path tracing without relying on manual searching. It also achieves automatic identification and classification of redundant clocks, and can dynamically adjust according to different designs, improving the identifiability of paths with timing risks. Furthermore, it enables automatic processing of redundant clock classification, modifying, removing, or merging them locally based on different types, reducing dependence on segmentation tools. Appropriate processing of redundant clocks reduces unnecessary clock generation logic and routing resource consumption, lowers chip power consumption and area overhead, and improves resource utilization. When this method is specifically applied to redundant clock optimization based on a prototype verification platform, it can trace and track the origin of the clock network, mark and process redundant clocks after segmentation, further improve the segmentation scheme, optimize clock resource allocation, and enhance timing convergence.

[0150] Figure 7 This is a schematic diagram of the structure of a clock optimization device provided in an embodiment of the present invention, as shown below. Figure 7 As shown, the clock optimization device includes:

[0151] Memory 60 is used to store computer programs;

[0152] The processor 61 is used to implement the steps of the clock optimization method as described in the above embodiments when executing a computer program.

[0153] The clock optimization device provided in this embodiment may include, but is not limited to, smartphones, tablets, laptops, or desktop computers.

[0154] The processor 61 may include one or more processing cores, such as a quad-core processor or an octa-core processor. The processor 61 may be implemented using at least one hardware form selected from Digital Signal Processing (DSP), Field-Programmable Gate Array (FPGA), and Programmable Logic Array (PLA). The processor 61 may also include a main processor and a coprocessor. The main processor, also known as the Central Processing Unit (CPU), is used to process data in the wake-up state; the coprocessor is a low-power processor used to process data in the standby state. In some embodiments, the processor 61 may integrate a Graphics Processing Unit (GPU), which is responsible for rendering and drawing the content to be displayed on the screen. In some embodiments, the processor 61 may also include an Artificial Intelligence (AI) processor, which handles computational operations related to machine learning.

[0155] The memory 60 may include one or more computer-readable storage media, which may be non-transitory. The memory 60 may also include high-speed random access memory and non-volatile memory, such as one or more disk storage devices or flash memory devices. In this embodiment, the memory 60 is used to store at least the following computer program 601, which, after being loaded and executed by the processor 61, is capable of implementing the relevant steps of the clock optimization method disclosed in any of the foregoing embodiments. In addition, the resources stored in the memory 60 may also include an operating system 602 and data 603, and the storage method may be temporary or permanent storage. The operating system 602 may include Windows, Unix, Linux, etc. The data 603 may include, but is not limited to, data related to the clock optimization method.

[0156] In some embodiments, the clock optimization device may further include a display screen 62, an input / output interface 63, a communication interface 64, a power supply 65, and a communication bus 66.

[0157] Those skilled in the art will understand that Figure 7 The structure shown does not constitute a limitation on the clock optimization device and may include more or fewer components than illustrated.

[0158] It is understood that if the clock optimization method in the above embodiments is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, in essence, or the part that contributes to the current technology, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and executes all or part of the steps of the methods in the various embodiments of the present invention. The aforementioned storage medium includes: USB flash drive, mobile hard drive, read-only memory (ROM), random access memory (RAM), electrically erasable programmable ROM, register, hard disk, removable disk, CD-ROM, magnetic disk, or optical disk, and other media capable of storing program code.

[0159] Based on this, embodiments of the present invention also provide a computer-readable storage medium storing a computer program, which, when executed by a processor, implements the steps of the clock optimization method described above.

[0160] The following describes a computer program product provided by an embodiment of this application. The computer program product described below can be referred to in conjunction with other embodiments described herein.

[0161] A computer program product includes a computer program / instructions that, when executed by a processor, implement the steps of the aforementioned disclosed clock optimization method.

[0162] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. For the apparatus disclosed in the embodiments, since it corresponds to the method disclosed in the embodiments, the description is relatively simple; relevant parts can be referred to in the method section.

[0163] Those skilled in the art will further recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of this invention.

[0164] Finally, it should be noted that in this document, relationships such as "first" and "second" are used merely to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such process, method, article, or apparatus.

[0165] The present invention provides a detailed description of a clock optimization method, apparatus, device, and computer-readable storage medium. Specific examples have been used to illustrate the principles and implementation methods of the present invention. The descriptions of the above embodiments are only for the purpose of helping to understand the method and core ideas of the present invention. At the same time, those skilled in the art will recognize that, based on the ideas of the present invention, there will be changes in the specific implementation methods and application scope. Therefore, the content of this specification should not be construed as a limitation of the present invention.

Claims

1. A clock optimization method, characterized in that, include: Read the netlist of each shard and traverse each netlist to generate the instance tree corresponding to each shard; Based on each instance tree, reverse tracing and forward tracing are performed on each clock signal to obtain the clock network path corresponding to each clock signal; Redundant clocks are determined based on each of the aforementioned clock network paths, and the redundant clocks are processed accordingly. The redundant clocks include isolated redundant clocks and equivalent redundant clocks.

2. The clock optimization method according to claim 1, characterized in that, Based on each instance tree, reverse tracing and forward tracing are performed on each clock signal to obtain the clock network path corresponding to each clock signal, including: Based on the tree-like hierarchical structure of the instance tree, the clock signal node is located; Initialize the stack and push the clock signal node onto the stack. Repeat the second step until the stack is empty to obtain the reverse tracing drive path. The second step includes: popping the top node of the stack, recording the position of the top node of the stack in the driving path, checking the driving source of the top node of the stack, and pushing unvisited driving source nodes onto the stack; Initialize the second queue and push the clock signal node into the second queue. Repeat the third step until the second queue is empty to obtain the load path for forward tracing. The third step includes: popping the head node of the queue, recording the position of the head node of the queue in the load path, checking the load of the head node of the queue, and pushing unvisited load nodes into the second queue. The clock network path corresponding to the clock signal is obtained based on the driving path and the load path.

3. The clock optimization method according to claim 1, characterized in that, Read the netlists of each shard, traverse each netlist to generate the instance tree corresponding to each shard, including: Obtain the netlist files corresponding to each segment after segmentation, parse each netlist file, and extract the top-level module; Each of the top-level modules is taken as the root node of each of the instance trees. Starting from the root node, the module instances are traversed in a queue manner to obtain each of the instance trees that reflects the module hierarchy and signal connections.

4. The clock optimization method according to claim 3, characterized in that, Each of the top-level modules is taken as the root node of each of the instance trees. Starting from the root node, the module instances are traversed in a queue manner to obtain each of the instance trees reflecting the module hierarchy and signal connections, including: The top-level module is used as the root node of the instance tree. The root node is placed in the first queue and used as the starting point of the first queue to start traversal. The first step is executed repeatedly until the first queue is empty, thus generating the instance tree. The first step includes: popping the current first node, generating an instance identifier for the current first node, recording the attributes of the current first node, and putting the child nodes of the current first node into the first queue.

5. The clock optimization method according to claim 1, characterized in that, Determining redundant clocks based on each of the aforementioned clock network paths includes: Based on each of the clock network paths, a load node query is performed for a single-chip single-clock. If the query fails, the single-chip single-clock is the isolated redundant clock. Based on each clock network path, a similarity comparison is performed between multiple clocks across chips. If the comparison result meets the preset conditions, then the multiple clocks across chips are the equivalent redundant clocks.

6. The clock optimization method according to any one of claims 1 to 5, characterized in that, The redundant clock is processed accordingly, including: Remove the isolated redundant clock; A master clock is selected from the equivalent redundant clocks according to the clock merging priority, and the master clock is planned to the global clock network. A buffer and clock synchronizer are added to the target partition; the target partition is the partition where the other clocks besides the master clock are located in the equivalent redundant clocks.

7. The clock optimization method according to claim 1, characterized in that, After processing the redundant clock accordingly, the process also includes: Locate the modification area and perform timing verification using incremental engineering change orders based on the modification area; After the timing verification is passed, the signal mapping table is updated according to the adjustment information, and the ports are adapted synchronously. The optimized and verified netlists of each segment are then output.

8. A clock optimization device, characterized in that, include: The instance tree construction module is used to read the netlist of each shard and traverse each netlist to generate the instance tree corresponding to each shard. The path acquisition module is used to perform reverse tracing and forward tracing of each clock signal based on each instance tree to obtain the clock network path corresponding to each clock signal. A redundant clock processing module is used to determine redundant clocks according to the clock network paths and to process the redundant clocks accordingly; the redundant clocks include isolated redundant clocks and equivalent redundant clocks.

9. A clock optimization device, characterized in that, include: Memory, used to store computer programs; A processor for implementing the clock optimization method as described in any one of claims 1 to 7 when executing the computer program.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions, which, when loaded and executed by a processor, implement the clock optimization method as described in any one of claims 1 to 7.

Citation Information

Cited By

  • Chip simulation method and device, equipment and storage medium

    CN121902726A

  • Chip simulation method, device, equipment and storage medium

    CN121902726B

  • A method, system, device and storage medium for adding automatic register connection optimization

    CN122471984A

  • A method, system, device and storage medium for adding automatic register connection optimization

    CN122471984B