A method for dynamic power consumption analysis of integrated circuits with cross-tile boundary pre-synchronization

By pre-synchronizing cross-tile boundary mapping and parameters in integrated circuit dynamic power consumption analysis, the problems of cross-tile net connection relationships and power consumption parameter dispersion are solved, realizing efficient distributed power consumption analysis and ensuring the consistency of results and computational efficiency.

CN123116997APending Publication Date: 2026-11-17EMPYREAN TECH CO LTD
View PDF 1 Cites 0 Cited by

Patent Information

Application Number
CN202611417779.6
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-09-14
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

In dynamic power consumption analysis of distributed integrated circuits, the connection relationships and power consumption parameters across Tile nets are scattered across different computing processes, leading to frequent cross-process queries and repeated aggregation of power consumption results.

Method used

By using a pre-synchronization method, cross-tile boundary mapping is established. The main computing process merges local boundary mappings to generate a global boundary mapping and synchronizes the load capacitance and toggle rate to the relevant computing processes. Each computing process obtains the cross-tile connection relationship and parameters before dynamic power consumption calculation. A multi-process replica storage and result unique attribution method is adopted to reduce the frequency of cross-process query and the duplication of result collection.

Benefits of technology

It improves the computational efficiency of distributed power analysis, ensures the integrity of parameters across Tile nets and the consistency of results, reduces the data scale of a single computing process, and is suitable for dynamic power analysis of large-scale integrated circuits.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123116997A_ABST
    Figure CN123116997A_ABST
Patent Text Reader

Abstract

This invention discloses a method for dynamic power consumption analysis of integrated circuits with pre-synchronization across tile boundaries. The method divides the integrated circuit layout into multiple tiles and assigns them to multiple computing processes. Each computing process stores a copy of the cross-tile net boundary data and establishes a local boundary mapping. The main computing process aggregates the local boundary mappings, generates a global boundary mapping, and synchronizes it to each computing process, simultaneously synchronizing the load capacitance and toggle ratio across tile nets. Each computing process determines the cross-tile connection relationship based on its local coordinate database, performs dynamic power consumption calculations on instances within its assigned tile, and uniquely assigns the calculation results according to the tile to which the instance belongs. The main computing process merges the results from each computing process to obtain the full-chip dynamic power consumption analysis results.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the field of Electronic Design Automation (EDA) technology, specifically to a method for dynamic power consumption analysis of distributed integrated circuits with pre-synchronization of boundary parameters across Tile (physical block layout). Background Technology

[0002] As integrated circuit process nodes continue to shrink and chip integration scales increase, the number of standard cells and interconnects within a chip continues to rise, making power consumption a critical factor affecting chip performance, reliability, and system design. During integrated circuit design, it is typically necessary to analyze the power consumption of each cell within the chip, combining netlists, cell libraries, parasitic parameters, and signal activity information to obtain the overall and local power distribution of the chip, providing a basis for subsequent design verification and optimization. With the increase in chip size, the data size of the full-chip netlist, parasitic parameters, and power consumption models also increases, placing higher demands on the storage and computing capabilities required for power analysis.

[0003] For dynamic power consumption analysis, it is usually necessary to obtain the signal switching status of the relevant network in the circuit based on signal activity data such as Value Change Dump (VCD) files and TWF files. Among them, the TWF file is used to provide activity information of relevant signals in the circuit, and combined with parameters such as the load capacitance of the net, the dynamic power consumption associated with the corresponding unit instance is determined.

[0004] As chip size increases, the number of instances and networks involved in the analysis also increases, significantly increasing the workload of data loading, parameter querying, and power consumption calculation. If a single computing process is used to centrally store and process all the data on the chip, it is easily limited by the single machine's memory capacity and computing resources, and the analysis time also increases with the increase in chip size.

[0005] To improve the processing capabilities of large-scale integrated circuit analysis, the chip data to be analyzed can be partitioned in a certain way, and the data from different partitions can be processed in parallel by multiple computing resources. By adopting a partitioned processing approach, each computing process can store and process the data in its assigned region separately, thereby reducing the data volume handled by a single computing process and enabling the parallel execution of analysis tasks using multiple processors or computing nodes.

[0006] However, a net in an integrated circuit is not necessarily limited to a single physical partition; a net may simultaneously connect multiple instances located in different physical regions. After physically partitioning the entire chip's data, the connection relationships, load parameters, and signal activity parameters corresponding to nets crossing partition boundaries involve multiple computational processes. If each computational process only stores data within its own partition, it may need to further obtain connection information and related parameters from other partitions when calculating the power consumption of its local instance. Frequent cross-process data queries and interactions during the analysis process will increase inter-process communication overhead and impact the computational efficiency of distributed power analysis. Therefore, in distributed power analysis, it is necessary to balance the integrity of cross-partition information with the data interaction overhead between processes.

[0007] Furthermore, when providing cross-partition network-related data to multiple computing processes, it is also necessary to address the issues of organizing, identifying, and attributing boundary data. On the one hand, each computing process needs to obtain sufficient cross-partition connectivity relationships and related parameters to support local instance power consumption calculations; on the other hand, when cross-partition data is correlated across multiple computing processes, it is also necessary to ensure that the final power analysis results can be aggregated according to the defined computing objects to meet the requirements of data integrity and result consistency for full-chip power consumption analysis.

[0008] Existing technologies already possess solutions for improving the efficiency of integrated circuit network analysis by utilizing block partitioning and parallel computing. For example, invention patent application CN101908087A, entitled "Parallel Simulation Method for Integrated Circuit Power and Ground Networks Based on GPU," discloses a method that simplifies the integrated circuit power and ground network into a two-dimensional regular network. The central processing unit (CPU) divides this two-dimensional regular network into two or more blocks, transmits the information of each block to the graphics processing unit (GPU), and different thread groups of the GPU read the data of their respective blocks and perform parallel computations. The computation results are then output to the CPU. This solution provides an approach to organizing integrated circuit network data through block partitioning and utilizing parallel computing resources for simulation analysis. Summary of the Invention

[0009] The purpose of this invention is to provide a method for dynamic power consumption analysis of integrated circuits with pre-synchronization across tile boundaries, in order to solve the problems of the connection relationship and power consumption parameters of cross-tile nets being scattered in different computing processes during distributed dynamic power consumption analysis, resulting in frequent cross-process queries, and the easy duplication of power consumption results when cross-tile boundary data is stored in multiple computing processes.

[0010] To achieve the above objectives, the present invention adopts the following technical solution:

[0011] A method for dynamic power consumption analysis of integrated circuits with cross-tile boundary pre-synchronization includes:

[0012] Obtain the physical coordinates of the integrated circuit layout to be analyzed, divide the layout into multiple tiles; set up a main computing process and multiple computing processes for tile processing, assign each tile to the corresponding computing process, and have each computing process establish an instance information database and a net information database for the tile it is responsible for.

[0013] Identify cross-tile nets that connect instances in different tiles, save corresponding boundary data copies in each computation process involved in the cross-tile net, and establish local boundary mappings using the global name of the cross-tile net as an index; the boundary data includes at least net identifier, pin identifier, instance identifier, load capacitance, and toggle ratio.

[0014] The local boundary maps are aggregated to the main computing process, which removes the process local identifiers and merges the local boundary entries belonging to the same cross-Tile net according to the global name of the cross-Tile net to generate a global boundary map. The global boundary map records the instances connected across Tile nets, as well as the Tile identifier and computing process identifier corresponding to each instance.

[0015] The global boundary mapping is synchronized to each computing process, and the load capacitance and toggle rate corresponding to each cross-tile net are synchronized to the relevant computing processes. The local coordinate database of each computing process is updated according to the global boundary mapping, so that each computing process can obtain the cross-tile connection relationship and dynamic power analysis parameters corresponding to the instance within its jurisdiction before the dynamic power consumption calculation begins.

[0016] Each computing process uses the instance within its assigned tile as the power consumption calculation object, determines the corresponding cross-tile connection relationship based on the local coordinate database, and completes dynamic power consumption calculation using locally stored boundary data.

[0017] Each computing process generates dynamic power consumption calculation results only for the instance within its assigned tile, and assigns the dynamic power consumption calculation results uniquely according to the tile to which the instance belongs. The main computing process then merges the dynamic power consumption calculation results of each computing process to obtain the dynamic power consumption analysis results of the entire chip.

[0018] In this invention, boundary parameter pre-synchronization refers to synchronizing the cross-tile connection relationship and the load capacitance and toggle ratio required for dynamic power consumption calculation to the relevant calculation process before the start of dynamic power consumption calculation, so that they can be called by subsequent instance-level dynamic power consumption calculation.

[0019] Preferably, both the instance identifier and the net identifier adopt a 64-bit identifier structure; the first 16 bits of the 64-bit identifier structure are used to record the horizontal identifier of the Tile, the middle 16 bits are used to record the vertical identifier of the Tile, and the last 32 bits are used to record the local row number of the corresponding instance or net in the corresponding information database of the Tile, so as to determine the Tile to which the corresponding instance or net belongs and its position within the Tile through the 64-bit identifier.

[0020] Preferably, when dividing tiles, if the number of tiles set by the user is not obtained, tile boundaries are set at intervals of 0.1 mm along both the horizontal and vertical sides of the map; if the number of tiles set by the user is obtained, the map area is divided according to the number of tiles set by the user.

[0021] Preferably, for the same Tile net, corresponding boundary data copies are stored in different computing processes involved in the Tile net, and each boundary data copy includes at least a net identifier, a pin identifier, an instance identifier, a load capacitance, and a toggle rate; wherein the net identifier and the instance identifier carry the corresponding Tile information and the local identifier within the Tile.

[0022] Preferably, generating a global boundary map includes:

[0023] Each computation process serializes the local boundary mapping and sends it to the main computation process;

[0024] The main computing process receives and deserializes each local boundary mapping, removing the process local identifiers;

[0025] Based on the global name across Tile nets, multiple local boundary entries belonging to the same cross-Tile net are merged into corresponding global boundary entries, and the global boundary mapping is composed of multiple global boundary entries.

[0026] Preferably, each global boundary entry includes at least a set of instance names corresponding to the cross-Tile net connection, a set of Tile identifiers corresponding to each instance, and a set of computation process identifiers corresponding to each instance. The main computation process serializes the global boundary mapping and broadcasts it to each computation process. Each computation process deserializes the received global boundary mapping and updates its local coordinate database based on the deserialized global boundary mapping.

[0027] Preferably, the toggle rate is obtained from the VCD file or determined based on the pin attributes connected across the Tile net; when determining the toggle rate based on the pin attributes, the corresponding toggle rate attribute is determined based on whether the pin belongs to a data pin or a clock pin, and the toggle rate attribute is synchronized to each computation process involved across the Tile net.

[0028] Preferably, each computing process uses multi-threading to perform dynamic power consumption analysis; when calculating the toggle rate and load capacitance, the processing tasks are divided into threads according to net; when performing dynamic power consumption calculation, the processing tasks are divided into threads according to instance, so that different threads process different nets or instances.

[0029] Preferably, when parsing VCD files, TWF files, or SPEF files, each computing process loads the corresponding external file and queries the corresponding instance identifier or net identifier based on the instance name or net name; based on the tile horizontal identifier, tile vertical identifier, and local line number in the instance identifier or net identifier, the tile to which the corresponding instance or net belongs and its position within the tile are determined; for the toggle rate, load capacitance, or parasitic parameters corresponding to cross-tile nets, synchronization is performed among the computing processes involved in the cross-tile net.

[0030] Preferably, for the same cross-tile net where boundary data copies are stored in multiple computing processes, each computing process generates dynamic power consumption calculation results only for the instance in its own tile; the boundary data across tile nets is stored using multi-process copies, and the dynamic power consumption calculation results corresponding to the instance are uniquely assigned according to the tile to which the instance belongs, so that the storage range of the boundary data and the assignment range of the dynamic power consumption calculation results are independent of each other.

[0031] Compared with the prior art, the present invention has at least the following beneficial effects:

[0032] (1) This invention pre-establishes local boundary mappings across Tile nets, and the main computing process merges each local boundary entry according to the global name across Tile nets, forming a global boundary mapping that reflects the cross-Tile connection relationship before the start of dynamic power consumption calculation. After obtaining the global boundary mapping, each computing process can determine the connection relationship of non-Tile instances based on the local coordinate database, reducing the need for real-time cross-process query of remote connection relationships during dynamic power consumption calculation.

[0033] (2) The present invention saves boundary data copies in multiple computing processes involved across Tile nets, enabling each computing process to obtain the load capacitance, toggle ratio and cross-Tile connection information required for local instance dynamic power consumption calculation, which is beneficial to ensuring the integrity of cross-Tile net parameters under distributed processing conditions.

[0034] (3) The present invention adopts a processing method that combines multi-process replica storage of cross-Tile net boundary data with unique attribution of instance power consumption results. The correlation parameters across Tile nets can be used in multiple related computing processes, while the final dynamic power consumption result is only assigned according to the Tile to which the instance belongs, thus avoiding the duplicate collection of the same power consumption result due to the existence of boundary data replicas in multiple processes.

[0035] (4) By configuring the horizontal Tile identifier, vertical Tile identifier, and local row number within the Tile in the instance identifier and net identifier, the present invention enables the computing process to directly determine the Tile to which the corresponding object belongs and its location within the Tile based on the object identifier, which facilitates the location of instances and nets and the association of cross-Tile boundary data in a distributed environment.

[0036] (5) The present invention adopts different thread division granularity according to the data objects in different processing stages. In the toggling rate and load capacitance processing stages, tasks are divided according to net, and in the dynamic power consumption calculation stage, tasks are divided according to instance, so that the thread task granularity matches the corresponding processing object, which is conducive to improving the parallel processing efficiency within the process.

[0037] (6) This invention enables each computing process to mainly process the Tile data it is responsible for by means of Tile-level distributed data organization and in-process parallel computing. While ensuring the integrity of cross-Tile connection parameters, it reduces the chip data scale undertaken by a single computing process, and is suitable for dynamic power consumption analysis of large-scale integrated circuits. Attached Figure Description

[0038] Figure 1 This is a schematic diagram of the overall process of the integrated circuit dynamic power consumption analysis method for cross-tile boundary pre-synchronization according to the present invention;

[0039] Figure 2 This is a schematic diagram illustrating the construction and synchronization process of cross-Tile global boundary mapping in this invention;

[0040] Figure 3 This is a schematic diagram of the cross-tile boundary data pre-synchronization and instance-level dynamic power consumption calculation process of the present invention. Detailed Implementation

[0041] The technical solution of the present invention will be further described below with reference to the accompanying drawings and specific embodiments. It should be understood that the following embodiments are for illustrative purposes only and are not intended to limit the scope of protection of the present invention. Equivalent substitutions or conventional modifications made by those skilled in the art to the embodiments without departing from the concept of the present invention are all included within the scope of protection of the present invention.

[0042] Example 1

[0043] This embodiment provides a method for dynamic power consumption analysis of integrated circuits with cross-tile boundary pre-synchronization.

[0044] Taking an integrated circuit to be analyzed as an example, this integrated circuit includes approximately 50 million instances and approximately 60 million nets. According to user settings, the integrated circuit layout is divided into 8×8 tiles, forming a total of 64 tiles. A distributed computing process architecture is adopted, with one main computing process and multiple computing processes for tile processing. The main computing process is used for local boundary mapping aggregation, global boundary mapping generation, and power consumption result merging. Each computing process is responsible for data storage and dynamic power consumption calculation for one or more tiles; each computing process is configured with 8 threads.

[0045] Step 1: Tile partitioning and local database creation

[0046] The system acquires the physical coordinates of the integrated circuit layout to be analyzed, divides the layout area according to the number of tiles set by the user, and establishes the correspondence between tiles and the calculation process.

[0047] Each instance is assigned to a corresponding tile based on its physical coordinates. For a net, it is determined whether it is a cross-tile net based on the tile to which the connected instances belong.

[0048] When all instances connected by a net are located in the same tile, the net is considered an intra-tile net; when at least two instances connected by a net are located in different tiles, the net is identified as a cross-tile net.

[0049] Each computation process establishes its own instance information database and net information database. The instance information database stores the identifier, name, cell type, and pin connections of instances within the current tile; the net information database stores the identifier, connection relationships, and parameters required for dynamic power consumption analysis of networks within the current tile. Each computation process also loads the cell library and retrieves the corresponding cell power consumption parameters from the cell library based on the cell type of the instance, for use in subsequent dynamic power consumption calculations.

[0050] For cross-tile nets, corresponding copies of boundary data are stored in each computation process involved in the cross-tile net. Boundary data includes at least the net identifier (netId), pin identifier (pinId), instance identifier (instanceId), load capacitance (cap), and toggle rate (ToggleRate). Cross-tile nets use complete copies for storage in the relevant computation processes, rather than just storing indexes pointing to data in other processes.

[0051] Step 2: Constructing the instance and net identifiers

[0052] To facilitate the determination of the Tile location and intra-Tile location corresponding to an instance or net in a distributed environment, a 64-bit identifier is established for both instance and net.

[0053] In 64-bit identifiers:

[0054] The first 16 bits are used to record the horizontal identifier of the tile;

[0055] The middle 16 bits are used to record the vertical identifier of the tile;

[0056] The last 32 bits are used to record the local row number of the corresponding instance or net in the corresponding information database of the tile.

[0057] Therefore, after obtaining the instanceId or netId, the corresponding field can be parsed to determine the tile to which the object belongs, and further determine its data location within the tile.

[0058] For example, if an instance is located in a tile with a horizontal number of 3 and a vertical number of 5, and corresponds to row 1200 in the instance information database, then when generating the instanceId, the horizontal number, vertical number, and local row number will be written into the corresponding fields respectively.

[0059] netId uses the same field organization method.

[0060] Step 3: Establishing Local Boundary Mapping

[0061] After completing the local data loading, each computing process traverses the cross-tile nets involved in its process and establishes a local boundary entry for each cross-tile net.

[0062] Each local boundary entry is indexed by the global name across the tile net and is used to record the identifier of the corresponding tile net, related instance information, tile information, and boundary parameters required for dynamic power consumption analysis. The global name is a name identifier that remains consistent across different tiles for the same tile net and is used to associate local boundary entries generated by different computing processes for the same tile net.

[0063] The local boundary mapping of this computation process consists of multiple local boundary entries.

[0064] In one specific implementation, local boundary mapping is implemented using a mapping data structure, which can be named LocalDIndexMap, where the global name of net is used as the key.

[0065] After each computing process establishes a local boundary mapping, it calculates the size of the buffer required for serialization, serializes the local boundary mapping, packs it into a binary buffer, and then sends it to the main computing process.

[0066] Step 4: Constructing the Global Boundary Map

[0067] The main computing process receives local boundary maps sent by each computing process and performs unified processing on the received local boundary entries.

[0068] The main computation process first removes the process local identifiers from each local boundary mapping that are only used for addressing within the corresponding computation process. The process local identifier is an identifier that is only valid within the computation process that generated the local boundary mapping. During the cross-process merging process, the global name, Tile identifier, and computation process identifier used to associate the same cross-Tile net are retained.

[0069] Subsequently, the global name across Tile nets is validated; for multiple local boundary entries with the same global name, it is validated whether they correspond to the same Tile net, and exceptions are handled for local boundary entries that do not meet the correspondence.

[0070] Then, using the global name across Tile nets as the merging basis, local boundary entries that belong to the same cross-Tile net but come from different Tile nets are merged.

[0071] After the merge is complete, the corresponding global boundary entry is generated.

[0072] Each global boundary entry includes at least:

[0073] The set of instance names corresponding to each Tile net;

[0074] The set of tile identifiers corresponding to each instance;

[0075] The set of computation process identifiers corresponding to each instance.

[0076] Multiple global boundary entries together constitute the global boundary map.

[0077] In one specific implementation, global boundary mapping is implemented using a mapping data structure, which can be named GlobalDIndexMap.

[0078] Step 5: Global Boundary Mapping Synchronization

[0079] The main computing process serializes the generated global boundary mapping and sends it to each computing process via broadcast.

[0080] In one specific implementation, the MPI_Bcast function of the Message Passing Interface (MPI) can be called to send the global boundary mapping to each computing process.

[0081] Each computing process receives the global boundary mapping, deserializes it, and writes the restored global boundary mapping into its local coordinate database. In one implementation, the data object corresponding to the local coordinate database can be named coord_db.

[0082] After this process is completed, each computing process can query the complete connection relationship across Tile nets through the local coordinate database and obtain information on non-Tile instances connected to instances within this Tile.

[0083] For example, net_A connects simultaneously to instance U1 in Tile0, instance U2 in Tile1, and instance U3 in Tile2. Let the process number (rank) of the main computing process be rank0, and the process numbers of the three computing processes responsible for Tile0, Tile1, and Tile2 be rank1, rank2, and rank3, respectively.

[0084] rank1, rank2, and rank3 respectively identify net_A as a cross-tile net and generate corresponding local boundary entries; after receiving the three local boundary entries, the main computing process rank0 merges them into the global boundary entry corresponding to net_A. This global boundary entry may include the instance name set connected_inst_names=["U1","U2","U3"], the tile identifier set belong_tile_ids=[0,1,2], and the computing process identifier set belong_ranks=[1,2,3].

[0085] Subsequently, rank0 broadcasts the global boundary map containing the net_A global boundary entry to each computation process.

[0086] When rank1 processes U1 connected to net_A, it can directly query the local coordinate database to obtain the connection information corresponding to U2 and U3, without needing to query rank2 or rank3 in real time regarding the connection relationship of U2 and U3 during the dynamic power consumption calculation process.

[0087] Step Six: Synchronize Dynamic Power Consumption Parameters Across Tiles

[0088] In this embodiment, dynamic power consumption analysis uses VCD files to provide signal activity information.

[0089] Each computing process reads the VCD file and queries the corresponding instanceId or netId based on the instance name or net name within it.

[0090] Based on the horizontal tile identifier, vertical tile identifier, and local row number in the instanceId or netId, the tile containing the corresponding object and its position within the tile can be determined.

[0091] For the internal net of a Tile, the toggle rate and load capacitance obtained by this process can be used directly.

[0092] For cross-Tile nets, the corresponding toggle ratio, load capacitance, and cross-Tile parameters related to dynamic power consumption analysis are synchronized to each computation process involved in that cross-Tile net, enabling each computation process to obtain the complete boundary parameters required for dynamic power consumption calculation in the local instance.

[0093] In this embodiment, each computing process loads a VCD file, a TWF file, or a Standard Parasitic Exchange Format (SPEF) file, and queries the corresponding signal activity data or parasitic parameters according to the instance and net it is responsible for; for parameters involved across Tile nets, synchronization is performed between the relevant computing processes.

[0094] Step 7: In-process multithreading

[0095] Each computing process uses a multi-threaded approach to perform dynamic power consumption analysis.

[0096] During the toggle rate and load capacitance processing stages, the net is used as the granularity for thread task division, and the nets to be processed are divided into different threads according to their storage order.

[0097] In the final dynamic power consumption calculation stage, the instance is used as the granularity for thread task division, and the instances to be processed are divided into different threads according to their storage order.

[0098] For example, in this embodiment, a computing process is configured with 8 threads. When processing the toggle rate and load capacitance, multiple nets are divided among the 8 threads for parallel processing; when performing the final dynamic power consumption calculation, multiple instances are further divided among the 8 threads for parallel processing.

[0099] Different threads process different net or instance objects, and threads do not concurrently write to the same object.

[0100] Step 8: Instance-level dynamic power consumption calculation

[0101] After completing global boundary mapping and cross-Tile parameter synchronization, each computing process uses the instance in the Tile under its jurisdiction as the object of dynamic power consumption calculation.

[0102] For instances that are only connected to the internal net of a Tile, dynamic power consumption calculation is performed directly based on the toggle ratio, load capacitance, and related parameters stored in the local net information database.

[0103] For an instance that connects across a tile net, the system first determines the instances in other tiles connected across the tile net based on the global boundary mapping in the local coordinate database. Then, it reads the corresponding toggle ratio, load capacitance, and parameters related to dynamic power consumption calculation from the locally stored copy of the boundary data, and completes the dynamic power consumption calculation for the instance within this tile.

[0104] Dynamic power consumption can be calculated using an integrated circuit power consumption analysis model based on the switching rate, load capacitance, operating voltage, and corresponding cell parameters. For instances connected across tile nets, the load capacitance and switching rate involved in the dynamic power consumption calculation are obtained from locally stored boundary data, ensuring that the load and signal activity factors generated by the cross-tile connection participate in the dynamic power consumption calculation of the corresponding instance.

[0105] Step 9: Assignment and Merging of Dynamic Power Consumption Results

[0106] For the same spanning Tile net, its boundary data copies can be stored in multiple related computation processes simultaneously, but the final dynamic power consumption result is attributed according to the instance.

[0107] Each computing process generates the final dynamic power consumption result only for the instance in the Tile under its jurisdiction.

[0108] Taking net_A as an example again:

[0109] rank1 forms the dynamic power consumption result of U1 in Tile0;

[0110] rank2 forms the dynamic power consumption result of U2 in Tile1;

[0111] rank3 forms the dynamic power consumption result of U3 in Tile2.

[0112] Although rank1, rank2 and rank3 all store boundary data copies of net_A, they do not repeatedly aggregate net_A as an independent final power consumption result object.

[0113] Therefore, boundary data across Tile nets can be saved using a multi-process replica method, while the dynamic power consumption result corresponding to an instance is uniquely assigned according to the Tile to which the instance belongs.

[0114] After each computing process completes the dynamic power consumption calculation for all instances within its tile, it sends the dynamic power consumption results to the main computing process. The main computing process then merges the dynamic power consumption results for each instance corresponding to each tile to obtain the full-chip dynamic power consumption analysis results for the integrated circuit to be analyzed.

[0115] Through the above processing, each computing process can obtain the cross-tile connection relationship and boundary parameters required for local instance dynamic power consumption calculation, and the final power consumption result can be repeatedly collected due to the cross-tile net boundary data being stored in multiple computing processes.

[0116] Example 2

[0117] This embodiment provides another method for dynamic power consumption analysis of integrated circuits with cross-tile boundary pre-synchronization.

[0118] In this embodiment, the cross-Tile net identification, boundary data copy establishment, local boundary mapping construction, global boundary mapping generation and synchronization, instance-level dynamic power consumption calculation, and unique attribution of power consumption results are the same as in Embodiment 1. The difference lies in the Tile partitioning method and the flip-flop rate acquisition method.

[0119] Step 1: Divide the tiles according to the default physical dimensions

[0120] When the user does not set the number of tiles, the layout area is automatically divided according to the preset physical size.

[0121] In this embodiment, tile boundaries are set at intervals of 0.1 mm along both the horizontal and vertical sides of the layout, and multiple tiles are formed accordingly.

[0122] When the user sets the number of tiles, the tile division will be performed according to the number of tiles set by the user.

[0123] After the tiles are divided, the boundaries of each tile are maintained, and subsequent data processing is carried out according to the determined correspondence between tiles and calculation process.

[0124] Step 2: Determine the flip-flop rate based on pin attributes

[0125] For a net whose toggle rate is not obtained from the VCD file, the corresponding toggle rate is determined based on the pin attributes connected to the net.

[0126] Specifically, it identifies whether the corresponding pin is a data pin or a clock pin, and determines the corresponding toggle rate parameter based on the pre-configured data pin attributes or clock pin attributes.

[0127] For the inner net of the Tile, the determined toggle rate is directly used for the dynamic power consumption calculation of the corresponding instance.

[0128] For cross-tile nets, the determined flip rate attribute is synchronized to each computation process involved in that cross-tile net, so that each relevant computation process can obtain the same cross-tile net flip parameters.

[0129] For example, when a cross-tile net connects instances in two different tiles at the same time, and the corresponding pin is identified as a clock pin, the toggle rate of the net can be determined based on the toggle attribute of the clock pin, and then the toggle rate can be synchronized to the calculation process responsible for the two tiles.

[0130] Step 3: Perform cross-tile boundary parameter pre-synchronization and dynamic power consumption analysis

[0131] Following the method described in Example 1, local boundary mappings are established in each computing process and then aggregated into the main computing process, which generates the global boundary mapping.

[0132] The global boundary mapping is broadcast to each computing process, and the local coordinate database of each computing process is updated.

[0133] At the same time, the toggle rate determined based on the pin attributes and the corresponding load capacitance will be synchronized to each computation process involved across the Tile net.

[0134] Each computing process determines the cross-tile connection relationship corresponding to its Tile instance based on the global boundary mapping in the local coordinate database, obtains the toggle rate and load capacitance required for dynamic power consumption analysis based on the locally saved boundary data copy, and completes the dynamic power consumption calculation with the instance within its jurisdiction as the computing object.

[0135] For the same span of a tile net, its boundary data can still be stored separately in multiple computing processes, but each computing process only generates the dynamic power consumption result corresponding to the instance within the tile it governs.

[0136] Finally, the main computing process merges the instance dynamic power consumption results corresponding to each tile to obtain the full chip dynamic power consumption analysis results.

[0137] The above embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit the scope of protection of the present invention. Any equivalent substitutions or conventional modifications made by those skilled in the art based on the disclosure of the present invention should be subject to the scope of protection defined in the claims.

Claims

1. A method for dynamic power consumption analysis of integrated circuits with cross-tile boundary pre-synchronization, characterized in that, include: Obtain the physical coordinates of the integrated circuit layout to be analyzed, and divide the layout into multiple tiles; Set up a main computing process and multiple computing processes for Tile processing. Assign each Tile to the corresponding computing process, and have each computing process build the instance information database and net information database of the Tile under its jurisdiction. Identify cross-tile nets that connect instances in different tiles, save copies of boundary data in the relevant computation process, and establish local boundary mappings using the global name of the cross-tile net as an index. The boundary data includes at least net identifier, pin identifier, instance identifier, load capacitance, and toggle ratio. The local boundary mappings are aggregated to the main computing process, which removes the process local identifiers and merges the local boundary entries of the same cross-Tilenet according to the global name across the Tilenet, generating a global boundary mapping that records each instance, its Tile identifier, and the computing process identifier. The global boundary mapping is synchronized to each computing process, and the load capacitance and toggle rate of each cross-Tile net are synchronized to the relevant computing processes. Each computing process then updates its local coordinate database based on the global boundary mapping. Each computing process uses the instance within its assigned tile as the power consumption calculation object, determines the cross-tile connection relationship based on the local coordinate database, and completes dynamic power consumption calculation using local boundary data. Each computing process generates dynamic power consumption calculation results only for the instance within its assigned tile, and assigns the dynamic power consumption calculation results uniquely according to the tile to which the instance belongs. The main computing process then merges the dynamic power consumption calculation results of each computing process to obtain the dynamic power consumption analysis results of the entire chip.

2. The integrated circuit dynamic power consumption analysis method for cross-tile boundary pre-synchronization according to claim 1, characterized in that, Both the instance identifier and the net identifier are 64-bit identifiers; The first 16 bits of the 64-bit identifier are used to record the horizontal identifier of the Tile, the middle 16 bits are used to record the vertical identifier of the Tile, and the last 32 bits are used to record the local row number of the corresponding instance or net in the corresponding information database of the Tile, so as to determine the Tile to which the corresponding instance or net belongs and its position within the Tile based on the 64-bit identifier.

3. The integrated circuit dynamic power consumption analysis method for cross-tile boundary pre-synchronization according to claim 1, characterized in that, The division of the map into multiple tiles includes: Without obtaining the user-defined number of tiles, tile boundaries are set at 0.1 mm intervals along both the horizontal and vertical sides of the layout. When obtaining the number of tiles set by the user, the map area is divided according to the number of tiles.

4. The integrated circuit dynamic power consumption analysis method for cross-tile boundary pre-synchronization according to claim 1, characterized in that, For the same Tile net, complete copies of the corresponding boundary data are saved in different computation processes involved in the Tile net. Each boundary data copy includes at least a net identifier, a pin identifier, an instance identifier, a load capacitance, and a toggle rate, and the net identifier and instance identifier carry the corresponding tile information and a local identifier within the tile.

5. The integrated circuit dynamic power consumption analysis method for cross-tile boundary pre-synchronization according to claim 1, characterized in that, The generation of the global boundary mapping includes: Each computation process serializes the local boundary mapping and sends it to the main computation process; The main computing process receives and deserializes each local boundary mapping, removing the process local identifiers; Based on the global name across Tile nets, multiple local boundary entries belonging to the same cross-Tile net are merged into corresponding global boundary entries, and the global boundary mapping is composed of each global boundary entry.

6. The integrated circuit dynamic power consumption analysis method for cross-tile boundary pre-synchronization according to claim 5, characterized in that, Each of the global boundary entries includes at least the set of instance names connected across the Tile net, the set of Tile identifiers corresponding to each instance, and the set of computation process identifiers corresponding to each instance; The main computing process serializes the global boundary mapping and broadcasts it to each computing process. Each computing process deserializes the received global boundary mapping and updates its local coordinate database based on the deserialized global boundary mapping.

7. The integrated circuit dynamic power consumption analysis method for cross-tile boundary pre-synchronization according to claim 1, characterized in that, The toggle rate is obtained from the VCD file or determined based on the pin attributes connected across the Tile net; When determining the toggle rate based on the pin attributes, the corresponding toggle rate attribute is determined based on whether the pin belongs to a data pin or a clock pin, and the toggle rate attribute is synchronized to each computing process involved across the Tile net.

8. The integrated circuit dynamic power consumption analysis method for cross-tile boundary pre-synchronization according to claim 1, characterized in that, Each computing process employs multi-threading to perform dynamic power consumption analysis; When calculating the torsion rate and load capacitance, the processing tasks are divided into threads according to the net; When performing dynamic power consumption calculations, the processing tasks are divided into threads according to the instance, so that different threads can process different nets or instances.

9. The integrated circuit dynamic power consumption analysis method for cross-tile boundary pre-synchronization according to claim 2, characterized in that, When parsing VCD files, TWF files, or SPEF files, each computing process loads the corresponding external file and queries the corresponding instance identifier or net identifier based on the instance name or net name. Based on the horizontal tile identifier, vertical tile identifier, and local row number in the instance or net identifier, determine the tile to which the corresponding instance or net belongs and its position within the tile; For the toggle rate, load capacitance, or parasitic parameters corresponding to a cross-tile net, synchronization is performed between the computation processes involved in the cross-tile net.

10. The integrated circuit dynamic power consumption analysis method for cross-tile boundary pre-synchronization according to claim 1, characterized in that, For the same cross-Tile net where boundary data copies are stored in multiple computing processes, each computing process generates dynamic power consumption calculation results only for the instance in its own Tile. The boundary data across Tile nets is stored using multi-process replicas, and the dynamic power consumption calculation result corresponding to the instance is uniquely assigned according to the Tile to which the instance belongs.

Citation Information

Patent Citations

  • Parallel simulation method of integrated circuit power / ground network based on GPU

    CN101908087A