Independent emulation of individual parts of integrated circuit design

By dividing the integrated circuit design into independent partitions and simulated with asynchronous communication and independent clocks in different simulation systems, the problem of synchronization limiting simulation speed and resource waste in the existing technology is solved, and efficient simulation and debugging process is realized .

CN119026564APending Publication Date: 2024-11-26SYNOPSYS INC
View PDF 0 Cites 1 Cited by

Patent Information

Application Number
CN202410489507.1
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Priority Date
2023-10-24
Filing Date
2024-04-23
Publication Date
2024-11-26

AI Technical Summary

Technical Problem

Existing integrated circuit design simulation technologies have problems with inefficiency, including synchronization limiting simulation speed, resource waste and high costs, especially during debugging, the need to recompile the entire design and use a large number of simulation hardware resources.

Method used

Dividing the integrated circuit design into multiple independent partitions, each partition is independently compiled and simulated in different simulation systems, using asynchronous communication and independent simulation clocks, allowing each partition to run at its maximum speed and capture and The playback mechanism isolates the debugging process.

Benefits of technology

It reduces the cost of debugging and error isolation, reduces the need for simulation resources, improves simulation efficiency and speed, and can complete the simulation of integrated circuit design in a shorter time.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN119026564A_ABST
    Figure CN119026564A_ABST
Patent Text Reader

Abstract

The invention relates to independent simulation of individual parts of an integrated circuit design. A method includes receiving an integrated circuit design including a plurality of circuit modules; dividing the integrated circuit design into a plurality of partitions according to the plurality of circuit modules; assigning the plurality of partitions of the integrated circuit design to corresponding portions of a simulation system; inserting, by a processor, a plurality of emulation communication circuit structures into the plurality of circuit modules of the integrated circuit design, the corresponding portions of the emulation system configured to communicate via one or more emulation interconnects connected to the emulation communication circuit structures, the emulated communication circuit structure is represented by a representation level selected from a group comprising: a packet level; a transaction level; and a protocol level; and simulating operation of the integrated circuit design using the simulation system.
Need to check novelty before this filing date? Find Prior Art

Description

[0001] Related Applications

[0002] This application claims priority to and the rights of U.S. Provisional Patent Application No. 63 / 469,239, filed in the U.S. Patent and Trademark Office on May 26, 2023, "INDEPENDENT EMULATION OF SEPARATEPORTIONS OF INTEGRATED CIRCUIT DESIGNS," the entire contents of which are incorporated herein by reference. Technical Field

[0003] The present disclosure relates to simulation of integrated circuit designs. Specifically, the present disclosure relates to a system and method for partitioning an integrated circuit design and simulating the partitioned integrated circuit design on different components of a simulation environment. Background Art

[0004] The design of an integrated circuit, such as a system-on-chip (SoC) processor, may include multiple circuit portions (intellectual property blocks or IP blocks) that communicate via an on-chip interconnect (eg, an electrical bus or an on-chip network).

[0005] The simulation environment simulates the operation of the integrated circuit design to perform verification, such as testing that the integrated circuit design operates according to specifications and meets requirements.

[0006] The above information disclosed in this Background section is only for enhancement of understanding of the present disclosure and therefore it may contain information that does not form the prior art that is already known to a person of ordinary skill in the art. Summary of the invention

[0007] According to one embodiment of the present disclosure, a method includes: receiving an integrated circuit design including multiple circuit modules; dividing the integrated circuit design into multiple partitions according to the multiple circuit modules; assigning the multiple partitions of the integrated circuit design to corresponding parts of a simulation system; inserting multiple simulated communication circuit structures into the multiple circuit modules of the integrated circuit design through a processor, the corresponding part of the simulation system being configured to communicate via one or more simulated interconnects connected to the simulated communication circuit structures, the simulated communication circuit structures being represented at a representation level selected from the group including: packet level; transaction level; and protocol level; and simulating the operation of the integrated circuit design using the simulation system.

[0008] The portion of the emulation system may include one or more components selected from the group consisting of: a field programmable gate array; a board including a plurality of field programmable gate arrays; and a computer system connected to a plurality of field programmable gate array boards.

[0009] The emulated interconnect may include one or more interconnects selected from the group consisting of: a low voltage differential signaling interconnect; a multi-gigabit transceiver; a backplane of an emulated unit; and an Ethernet connection.

[0010] The method may further include separately supplying the plurality of circuit modules to a simulation compiler to generate a plurality of compiled circuit modules.

[0011] The simulation compiler may be configured to compile a simulated communication circuit structure into a circuit module of the plurality of circuit modules, the simulated communication circuit structure configured to communicate with another circuit module of the plurality of circuit modules via the one or more simulated interconnects.

[0012] The method may further include: during simulation of operation of a first partition of the plurality of partitions and a second partition of the plurality of partitions of the integrated circuit design, capturing stimulus transmitted from the first partition to the second partition through the one or more simulation interconnects; and storing the stimulus as a plurality of captured stimuli in a stimulus storage device, a captured stimulus of the captured stimuli including a simulation timestamp based on a simulation clock of the simulation of the second partition.

[0013] The method may further include configuring a portion of the simulation system to simulate the second partition; and supplying the captured stimulus from the stimulus storage device to the second partition during simulation of the operation of the second partition using the simulation system without simulating the first partition.

[0014] The operation of simulating the integrated circuit design using the simulation system may include: using a first part of the simulation system to simulate a first partition of the multiple partitions including a first circuit module of the multiple circuit modules according to a first simulation clock; and using a second part of the simulation system to simulate a second partition of the multiple partitions including a second circuit module of the multiple circuit modules according to a second simulation clock, wherein the second simulation clock is independent of the first simulation clock.

[0015] According to one embodiment of the present disclosure, a system includes: a first simulation system, which includes a first plurality of field programmable gate arrays (FPGAs); a second simulation system, which includes one or more second plurality of FPGAs; and a host system, which includes a processor and a memory storing instructions, wherein the instructions, when executed, cause the processor to: receive an integrated circuit design, wherein the integrated circuit design includes a plurality of circuit modules configured to communicate via a delay-tolerant interconnect; divide the integrated circuit design into a plurality of partitions according to the plurality of circuit modules; insert a first simulation communication circuit structure into a first FPGA of the first plurality of FPGAs, and insert a second simulation communication circuit structure into a second FPGA of the second plurality of FPGAs, wherein the first simulation communication circuit structure and the second simulation communication circuit structure are represented at a representation level selected from the group including: a packet level; a transaction level; and a protocol level; configure the first plurality of FPGAs of the first simulation system to simulate a first partition of the plurality of partitions of the integrated circuit design; configure the second plurality of FPGAs of the second simulation system to simulate a second partition of the plurality of partitions of the integrated circuit design; and simulate the operation of the integrated circuit design using the first simulation system and the second simulation system, wherein the first partition and the second partition are configured to communicate using the first simulation communication circuit structure and the second simulation communication circuit structure.

[0016] The memory may further store instructions that, when executed, cause the processor to control stimulus capture circuitry to capture stimulus for transmission from the first partition simulated by the first simulation system to the second partition simulated by the second simulation system.

[0017] The stimulus capture circuit may be connected to a simulation interconnect between the first simulation system and the second simulation system.

[0018] The stimulus capture circuit may be connected to the emulation communication circuit structure of the second emulation system.

[0019] The first simulation system may be configured to simulate the first partition at a first simulation clock rate, and the second simulation system may be configured to simulate the second partition at a second simulation clock rate that is independent of the first simulation clock rate.

[0020] According to one embodiment of the present disclosure, a non-transitory computer-readable medium includes stored instructions, which, when executed by a processor, cause the processor to: receive an integrated circuit design, the integrated circuit design including multiple circuit modules configured to communicate via a delay-tolerant interconnect; divide the integrated circuit design into multiple partitions according to the circuit modules; insert a first simulated communication circuit structure into a first circuit module of a first partition of the multiple partitions, the first simulated communication circuit structure being represented by a first representation level selected from the following groups: packet level; transaction level; and protocol level; compile the first circuit module to generate a first compiled circuit module including a first bit file to configure a first field programmable gate array (FPGA) to simulate a first part of the first circuit module; insert a second simulated communication circuit structure into a second circuit module of a second partition of the multiple partitions, the second simulated communication circuit structure being represented by a second representation level selected from the following groups: packet level; transaction level; and protocol level; and compile the second circuit module independently of the first circuit module to generate a second compiled circuit module including a second bit file to configure a second FPGA to simulate a second part of the second circuit module.

[0021] The first emulation communication circuit structure can be connected to an output pin of the first circuit module and is configured to send a data packet representing a signal at the output pin according to a protocol, and the second emulation communication circuit structure can be connected to an input pin of the second circuit module and is configured to receive the data packet according to the protocol and supply the signal represented in the data packet to the input pin.

[0022] The first simulated communication circuit structure and the second simulated communication circuit structure may be represented at the protocol level.

[0023] The first simulation communication circuit structure and the second simulation communication circuit structure may be represented at the transaction level.

[0024] The first simulated communication circuit structure and the second simulated communication circuit structure may be represented at the packet level.

[0025] The non-transitory computer-readable medium may further store instructions that, when executed, cause the processor to: receive an updated integrated circuit design, wherein the first circuit module in the updated integrated circuit design is replaced by an updated first circuit module, and wherein the second circuit module is unchanged from the second circuit module of the integrated circuit design; and compile the updated first circuit module to generate an updated first compiled circuit module including a first updated bitfile to configure the first FPGA to emulate a first portion of the updated first circuit module without recompiling the second circuit module.

[0026] The first compiled circuit module may be controlled by a first emulation clock, and the second compiled circuit module may be controlled by a second emulation clock independent of the first emulation clock. BRIEF DESCRIPTION OF THE DRAWINGS

[0027] The present disclosure will be more fully understood from the detailed description given below and the drawings of the embodiments of the present disclosure. The drawings are used to provide knowledge and understanding of the embodiments of the present disclosure and do not limit the scope of the present disclosure to these specific embodiments. In addition, the drawings are not necessarily drawn to scale.

[0028] Figure 1 is a block diagram depicting compilation of individual circuit modules or IP blocks by a simulation compiler according to one embodiment of the present disclosure.

[0029] Figure 2 is a flow chart of a method for simulating an integrated circuit design according to some embodiments of the present disclosure.

[0030] Figure 3A is a block diagram illustrating a stimulus capture and replay mechanism according to one embodiment of the present disclosure.

[0031] Figure 3B is a block diagram illustrating another stimulus capture and replay mechanism according to one embodiment of the present disclosure.

[0032] Figure 4 is a flow chart of a method for separately compiling partitions of an integrated circuit design and inserting simulated communication circuit structures according to one embodiment of the present disclosure.

[0033] Figure 5 Depicted is a hierarchical view of connections for simulation communication between two circuit modules or IP blocks according to one embodiment of the present disclosure, where three representation layers are used to implement the connections.

[0034] Figure 6 is a block diagram illustrating a transmitting circuit and a receiving circuit inserted by a simulation compiler according to one embodiment of the present disclosure.

[0035] Figure 7 is a flow chart of a method for running a partitioned simulation of an integrated circuit design according to one embodiment of the present disclosure.

[0036] Figure 8 is a flow chart of a method for simulating a subset of partitions of an integrated circuit design using replay of stimuli from other partitions according to one embodiment of the present disclosure.

[0037] Fig. 9 Flowcharts depicting various processes used during the design and fabrication of integrated circuits according to some embodiments of the present disclosure.

[0038] Fig.10 A diagram depicting an example simulation system in a simulation environment according to some embodiments of the present disclosure.

[0039] Fig.11 A diagram depicting an example computer system in which embodiments of the present disclosure may operate. DETAILED DESCRIPTION

[0040] Aspects of the present disclosure relate to independent simulation of separate portions of an integrated circuit design.

[0041] A simulation environment or integrated circuit simulator is a hardware system that is configured to simulate the operation of an integrated circuit design by implementing the components of the integrated circuit design using reconfigurable hardware, such as one or more field programmable gate arrays (FPGAs). (In contrast, a simulator for integrated software represents the components of a given integrated circuit design in the memory of a computer system, where one or more processors simulate the operation of the components represented in the memory by updating the electrical states of the connections between the components represented in the memory.)

[0042] The simulation system may include multiple field programmable gate array (FPGA) integrated circuits that are interconnected using technologies such as multi-gigabit transceivers (MGTs), low voltage differential signaling (LVDS), and the like (e.g., other high throughput interconnects). The connections between the FPGAs may be fixed, or they may be established by programmable switches, which allows for improved flexibility in communication between the FPGAs. In some examples of the simulation system, multiple FPGAs are mounted on a printed circuit board (PCB) and may communicate with each other through a simulation system interconnect (or simulation interconnect) that may include electrical traces on the PCB. The printed circuit board (or board) may be connected to a backplane (e.g., as an expansion card for a computer system), and may therefore communicate with FPGAs on other PCBs and / or a central processing unit (CPU) of a host computer system that controls the simulation system through other simulation system interconnects that may be implemented using an interconnect technology (e.g., peripheral component interconnect high speed or PCIe or the like). The simulation environment may include multiple simulation systems, each simulation system including one or more FPGAs mounted on one or more printed circuit boards, wherein the multiple simulation systems may communicate via external cables and in some cases via switches, routers, or hubs and using communication protocols such as Universal Serial Bus (USB), external PCI Express (ePCIe), Thunderbolt, and computer network protocols such as Ethernet. This hierarchical arrangement of FPGAs in the simulation environment means that communication between FPGAs may experience different amounts of latency (e.g., the delay between sending a message and receiving a message) and bandwidth (the amount of data that can be transmitted per unit time), depending on the relative locations of those communicating FPGAs, such as whether the FPGAs are on the same PCB, on different PCBs connected to the same backplane, connected to different backplanes, or in different computer systems corresponding to different simulation systems.

[0043] The integrated circuit design to be simulated by the simulation environment may include multiple circuit portions or circuit modules, which may be referred to as intellectual property blocks (IPs). Individual circuit portions or circuit modules may communicate through an on-chip interconnect (e.g., an on-chip network or NoC) using a communication protocol such as Universal Chiplet Interconnect Express (UCIe), PCIe, or a proprietary communication protocol dedicated to the integrated circuit design. The on-chip interconnect may be referred to as a delay-tolerant interconnect, and the communication may be referred to as delay-tolerant communication because the communication between the circuit portions may be performed asynchronously. Data may be exchanged between circuit portions or circuit modules in packets. In the case of an on-chip network, an on-chip router may perform packet switching to transmit data packets from a transmitting circuit portion to a receiving circuit portion through a NoC. In a physical implementation of the integrated circuit design, the communication between the circuit portions of the integrated circuit design will occur entirely within the same semiconductor die.

[0044] During the design and verification of such an integrated circuit design, the design may be compiled by a simulation compiler and simulated in a simulation environment. The simulation compiler converts a representation of the integrated circuit design (e.g., starting from a high-level representation in a hardware description language (HDL), a logic-level register transfer level or RTL description, or a gate-level description in the form of a netlist) into one or more bit files for configuring the FPGAs of the simulation environment and information for controlling communication between the FPGAs of the simulation environment (e.g., for generating simulation clock signals).

[0045] However, when compiling complex designs containing multiple circuit sections (multiple IPs) communicating over delay-tolerant interconnects, several inefficiencies can be observed. Some of these inefficiencies are related to runtime performance limitations. The maximum achievable performance is roughly inversely proportional to the design size because the simulation must be synchronized across all FPGAs, and this synchronization takes time. If a circuit section of the design (e.g., an IP block) needs to perform time-consuming operations (e.g., communicating with the computer system running the simulation software, e.g., Fig.10 ), then for all circuit portions of the entire integrated circuit design, the simulation clock is stopped, thereby preventing the simulation of the remaining portions of the integrated circuit design from being performed. The longest timing path of any circuit portion limits the simulation speed of the entire design, because the design must be simulated in a time-synchronous manner. Typically, the timing path between circuit portions becomes a key limiting factor in simulation speed, especially when the simulation interconnections between portions of the simulation hardware are implemented with high-latency interconnects such as multi-gigabit transceivers (MGTs), which may include simulation delays of about hundreds of nanoseconds along the timing path (bandwidth limitations on the communication bus connecting these different portions of the simulation environment may also introduce delays when signals are queued for transmission). Therefore, these simulation communications of the long timing paths of the integrated circuit design extending between portions of the simulation hardware limit the maximum simulation clock speed of any given circuit portion (or IP block), because the simulation must be performed in a time-synchronous manner. Sharing the simulation clock across all circuit portions of the integrated circuit design forces the simulation of other portions of the integrated circuit design to also operate at the clock rate imposed by the circuit portion or IP block with the slowest simulation clock rate. This applies even if the integrated circuit design specifies that different portions of the integrated circuit design operate in different clock domains (eg, controlled by different internal clocks or user clocks), because those different clock domains are ultimately controlled by the same simulation clock.

[0046] Additional inefficiencies may occur for the compilation of designs for simulation environments. During the course of the design process, simulation may reveal errors (bugs) in the design that cause the design to behave in a manner inconsistent with the specifications of the integrated circuit design. During debugging, one or more circuit portions (circuit modules or IP modules) of the design may be modified in an attempt to correct the bug, but the simulation compiler must recompile the entire design, including the circuit portions that have not been modified. This results in an increase in computing resources and potentially redundant long compilation times because they force recompiling the unchanged portions of the design. In addition, if several circuit portions (circuit modules or IPs) are the same, the compilation resources and time are proportional to the number of IPs instantiated in the design (e.g., each copy of the circuit portion is compiled separately), rather than reusing previously compiled portions. (For example, a single design of an integrated circuit may include multiple identical computing cores that communicate through delay-tolerant interconnects.)

[0047] Other inefficiencies may be related to the cost of ownership of simulation. Debugging a specific circuit module typically requires simulating a complete integrated circuit design, including circuit modules that are loosely connected to the circuit module of interest being debugged. This results in more simulation hardware resources (e.g., FPGA) being used to debug this single portion of the overall design, where those simulation hardware resources can be used (e.g., to simulate other users of other projects) to simulate other integrated circuit designs. This increases the total cost of having a simulation environment or integrated circuit simulator for an organization designing an integrated circuit. In order to simulate a large design, a user needs to obtain a corresponding large monolithic simulation environment. Several smaller simulation environments of overall equivalent capacity cannot easily accommodate this purpose.

[0048] Therefore, aspects of embodiments of the present disclosure relate to overcoming the limitations listed above. Some aspects of the present disclosure relate to segmenting (or dividing) a given integrated circuit design into several partitions or circuit parts, and compiling each partition or circuit part or circuit module into an independent design. These separate compiled designs are then loaded into different parts of a simulation system (e.g., a single board of multiple FPGAs is dedicated to one of the circuit modules) or a simulation environment comprising several independent simulation host systems (e.g., the circuit modules are distributed throughout multiple host computer systems, each such host computer system is directly connected to one or more FPGAs configured to simulate the corresponding parts of the compiled design), wherein one aspect of independence relates to each independent simulation system using a separate simulation clock. The parts of the simulation system or a single system are interconnected by communication channels such as LVDS or MGT. This link is used to establish asynchronous communication between simulation designs.

[0049] The technical advantages of the present disclosure include, but are not limited to, reducing the cost of ownership for debugging or isolating potential errors in a design by simulating a separate portion or IP block of an integrated circuit design using a separate simulation system. According to some embodiments of the present disclosure, this also provides the technical advantage of being able to isolate and debug a single IP block or module of an integrated circuit design containing multiple IP blocks by recording incoming stimuli from other IP blocks (during a previous simulation of the complete integrated circuit design) and replaying the incoming stimuli. When only a single IP block (or a subset of IP blocks) is debugged, simulating only a single IP block (or a subset of IP blocks) of an integrated circuit design is advantageous over simulating the entire integrated circuit design because fewer simulation resources (e.g., fewer FPGAs) are required to perform the simulation, thereby freeing up simulation resources for other integrated circuit designs (e.g., thereby reducing the cost of simulation during the process of developing an integrated circuit design), and also enabling the simulation of a single IP block to be performed without being hindered by synchronous simulation of other IP blocks that may need to be simulated at a lower speed due to the reasons discussed above (e.g., timing paths extending between FPGAs). In addition, in the case where each simulation system is able to run at its maximum possible speed, asynchronous communication between simulation systems allows the simulation of the integrated circuit design to be completed in a shorter amount of time.

[0050] For example, some aspects of the present disclosure relate to partitioning a complete integrated circuit design at boundaries where different circuit modules will communicate through delay-tolerant interconnects in the design, such that delay-tolerant communications between those circuit modules of the simulated design are performed through corresponding higher-delay simulation interconnects of the simulation environment. Thus, embodiments of the present disclosure relate to decoupling circuit portions of a complete design to be simulated on separate portions of a simulation environment, wherein the decoupling is performed based on an underlying decoupled design of the integrated circuit. Aspects of embodiments of the present disclosure further relate to interfaces between circuit modules that make up the overall design, and providing multi-level representations for these interfaces.

[0051] Figure 1 is a block diagram depicting compilation of individual circuit modules or IP blocks by a simulation compiler according to one embodiment of the present disclosure. Figure 1 , a given integrated circuit design 100 may include multiple circuit modules or IP blocks, labeled IP1 101, IP2 102, IP3 103, IP4 104, IP5 105, and IP6 106. The different circuit modules IP1 to IP6 communicate through an on-chip delay-tolerant interconnect 108 (e.g., an on-chip network or the like). For example, a circuit module may include a transmit buffer and a receive buffer (or first-in-first-out or FIFO memory) to store data packets to be transmitted to other circuit modules or data packets asynchronously received from other circuit modules.

[0052] Figure 2is a flow chart of a method 200 for simulating an integrated circuit design according to one embodiment of the present disclosure.

[0053] Some aspects of the embodiments relate to Figure 2 At 210, the integrated circuit design is divided into a plurality of partitions according to the communication boundaries of the circuit modules. As mentioned above, Figure 1 Different circuit modules IP1 to IP6 of the integrated circuit design 100 communicate through the on-chip delay-tolerant interconnect 108, and thus the entire integrated circuit design 100 can be partitioned so that the circuit modules that communicate through the on-chip delay-tolerant interconnect 108 are located in different partitions, and the parts of the integrated circuit design that communicate directly with each other (e.g., parts of circuits containing combinational elements connected by direct wiring rather than by buses or shared interconnects) are located in the same partition. These partitions can correspond to separate IP blocks or circuit modules of the integrated circuit design. For example, each partition can have exactly one or more IP blocks or circuit modules.

[0054] The digital representations 110 of the individual circuit modules or IP blocks (e.g., expressed in a hardware description language, a logic level register transfer level description, or a netlist), shown as 110A for circuit module IP1 101, 110B for circuit module IP2 102, and 110C for circuit module IP6 106, are then compiled by a simulation compiler 120 (shown as separate simulation compilers 120A, 120B, and 120C to indicate that the compilation process can be performed in parallel for the separate digital representations 110A, 110B, and 110C) into a plurality of bit files or other digital representations of the integrated circuit design for configuring a simulation system (e.g., for configuring one or more FPGAs of the simulation system). The compiled data may be stored in a persistent storage device 130 for later reuse (e.g., a simulation database or simulation DB), shown as separate simulation DBs 130A, 130B, and 130C to indicate that they may be stored in different databases or in the same database. The compiled data may then be retrieved from the simulation DB (or multiple simulation DBs) and assigned at 220 to configure one or more simulation systems or components of simulation systems (e.g., individual FPGAs, FPGA boards, groups of FPGA boards, entire host computer systems and all FPGAs therein, and the like) that make up the simulation environment 150, shown as separate simulation systems 150A, 150B, and 150C to indicate that they may be implemented in the same simulation system or in different simulation systems. The selection of components of the simulation system 150 for a particular circuit module or IP block may depend on the size of the circuit module. An FPGA may be characterized by the number of programmable logic blocks contained therein, which sets an upper limit on the number of circuit elements that may be simulated using one such FPGA. Some circuit modules or IP blocks may have too many circuit elements to be simulated using a single FPGA, and therefore multiple FPGAs of a simulation system may be used to simulate such circuit modules. Communication between FPGAs is performed through communication links 180 (e.g., multi-gigabit transceivers, low voltage differential signaling, PCIe, Ethernet, combinations thereof, and the like), which introduce latency between portions implemented in different FPGAs. Latency increases with the number of levels of hierarchical design of the simulation environment (e.g., latency increases when going from a single FPGA to other FPGAs on the same board, to other FPGAs in the same board group, to other FPGAs in different groups, or to FPGAs connected to different host simulation systems). Therefore, performance is improved by keeping the entire circuit module or IP block within the smallest component of the simulation system 150 that can simulate the entire circuit module or IP block.

[0055] like Figure 1, the designs 110A, 110B, and 110C of each circuit module or IP block are independently compiled by corresponding instances of simulation compilers 120A, 120B, and 120C. After configuring simulation system 150 and / or individual components of the simulation system (e.g., 150A, 150B, and 150C) to simulate different portions of integrated circuit design 100, simulation system 150 then simulates the operation of the integrated circuit blocks at 230. During simulation, various test input vectors may be supplied to the simulated integrated circuit design, and the output and operation of the simulated integrated circuit design may be captured and compared with expected results to verify whether the simulated integrated circuit design operates according to its specification.

[0056] In some embodiments, the simulation of each circuit module or IP block has an independent simulation clock frequency and an independent simulation clock stop. The independent simulation clock frequency allows the simulation of each circuit module by its corresponding simulation system (e.g., 150A, 150B and 150C) to run at its maximum possible speed without being limited by the simulation of other circuit modules. The independent simulation clock stop allows the user to stop only the local simulation of one of the circuit modules without affecting the simulation of other circuit modules. Independent compilation allows a single circuit module or IP block to be recompiled in the case of incremental changes (e.g., only changing circuit module IP6 106 without changing circuit module IP1 101 and circuit module IP2 102), thereby reducing computing resource consumption (e.g., avoiding recompiling the unchanged parts of the complete integrated circuit design 100).

[0057] Some aspects of embodiments of the present disclosure further relate to using a stimulus capture and replay mechanism at a single design level. In more detail, a stimulus capture and replay mechanism according to some embodiments captures inputs to and outputs from a given circuit module (or multiple circuit modules) during a simulation process. These inputs may be transmitted to the circuit module from other circuit modules, and outputs from the circuit module may be provided to other circuit modules. When debugging a portion of a circuit design (e.g., only a portion of a circuit design is executed), the simulation process may be repeated. Figure 1 When errors are associated with circuit modules IP3 and IP4 of the example complete design shown in FIG. 1 , it is not necessary to simulate the complete design because the errors previously detected from other parts of the integrated circuit design (e.g., Figure 1 Inputs captured by the example complete design IP1, IP2, IP5, and IP6 shown in FIG. 1 can be replayed or transferred to circuit modules IP3 and IP4. This allows debugging of IP3 and IP4 to be performed on a smaller simulation system (e.g., with fewer FPGAs), thereby freeing up resources for use by other users and thereby reducing the overall cost of operating sufficient simulation systems to support the engineering workload in an organization.

[0058] In order to enable simulated circuit modules or IP blocks of an integrated circuit design to communicate across different parts of a simulation system (e.g., across different boards, across different host computer systems, and the like), a simulation compiler inserts a simulated communication circuit structure into the compiled design, which, for example, configures an FPGA to connect portions of a circuit module or IP block to input and output pins of the FPGA, which pins in turn may be connected to router circuits to route messages between FPGAs (e.g., across FPGA boards and / or across host computer systems) through one or more simulated interconnects. The configuration of such inserted simulated communication circuit structures is highly dependent on how the compiled designs of different circuit modules or IP blocks are instantiated in the simulation system (e.g., which IP blocks are located where in the overall simulation system). Therefore, in some embodiments, the structure is configured as a parameterizable module that, when loaded into the simulation system, may be configured with parameters to configure connections between simulated circuit modules or IP blocks.

[0059] Figure 3A is a block diagram illustrating a stimulus capture and playback mechanism according to one embodiment of the present disclosure. Figure 3A In the example shown in FIG. 1 , the stimulus is transmitted via a communication link 315 (eg, corresponding to Figure 1 180) is transmitted between partitions simulated by different simulation systems 310 (or different parts of simulation systems), where one or more stimulus capture circuits 320 are connected to the communication link 315. Figure 3AIn the example of, the first simulation system 310A can be a complete computer system (for example, because this circuit module can be large) for simulating the first circuit module IP1. Similarly, the second simulation system 310B can be a complete computer system for simulating the second circuit module IP2. Because the first simulation system 310A and the second simulation system 320B are complete computer systems, they can communicate through communication links 315A and 315B respectively, and the communication links 315A and 315B are suitable for computer systems that communicate with external devices (such as Ethernet). The first stimulus capture circuit 320A can be connected to communication links 315A and 315B to automatically capture the stimulus transmitted to the first simulation system 310A and the second simulation system 310B from other simulation systems. Continuing communication links 315A and 315B are examples of Ethernet communication links (or other computer network links), and these stimuli can be included in the payload of network packets such as transmission control protocol / Internet protocol (TCP / IP) packets. The first stimulus capture circuit 320A may include a stimulus storage device (e.g., dynamic random access memory and / or a persistent memory such as a flash memory or a disk drive) to store the captured stimulus. In some embodiments, the captured stimulus is time stamped according to a simulation clock cycle in which the captured stimulus is presented to the receiving circuit module based on a simulation clock of the emulation system emulation receiving circuit module.

[0060] Similarly, if Figure 3A310C can be configured to simulate the third circuit module IP3 and the fourth circuit module IP4 of the entire integrated circuit design. Similarly, the fourth simulation system 310D can be configured to simulate the fifth circuit module IP5, and the fifth simulation system 310E can be configured to simulate the sixth circuit module IP6. The third, fourth, fifth and sixth circuit modules can be small enough so that they can all be simulated on the same computer system, wherein the corresponding simulation system can be, for example, a single PCB, and each PCB includes multiple FPGAs. For example, the third simulation system 310C can correspond to the first PCB, the fourth simulation system 310D can correspond to the second PCB, and the fifth simulation system 310E can correspond to the third PCB. The third simulation system 310C, the fourth simulation system 310D and the fifth simulation system 310E can communicate by corresponding communication links including the third communication link 315C, the fourth communication link 315D and the fifth communication link 315E, wherein these communication links can be implemented using a technology suitable for communication between the PCBs of a computer system such as PCIe. The second stimulus capture circuit 320B can be connected to the third communication link 315C, the fourth communication link 315D, and the fifth communication link 315E to capture stimulus transmitted to the third simulation system 310C, the fourth simulation system 310D, and the fifth simulation system 310E, respectively. The second stimulus capture circuit 320B can also be connected to the first stimulus capture circuit 310A through the sixth communication link 315F to allow stimulus exchange between the first simulation system 310A, the second simulation system 310B, the third simulation system 310C, the fourth simulation system 310D, and the fifth simulation system 310E. In some embodiments, the captured stimulus is time-stamped according to the simulation clock cycle, in which the captured stimulus is presented to the receiving circuit module based on the simulation clock of the simulation system simulation receiving circuit module.

[0061] Figure 3B is a block diagram illustrating another stimulus capture and playback mechanism according to one embodiment of the present disclosure. Figure 3BIn the embodiment shown in , the stimulus capture and replay mechanism is implemented at the level of the individual simulation systems so that the incoming stimulus to a given simulation system is captured by the corresponding stimulus capture circuit. For example, the first simulation system 350A includes a first stimulus capture circuit 351A configured to capture stimulus received from other simulation systems of other partitions of the simulated integrated circuit design through a first communication link 365A. Similarly, the second simulation system 350B includes a second stimulus capture circuit 351B configured to capture stimulus received through a second communication link 365B, and the third simulation system 350C includes a third stimulus capture circuit 351C configured to capture stimulus received through a third communication link 365C. The fourth simulation system 350D includes a fourth stimulus capture circuit 351D configured to capture stimulus received through a fourth communication link 365D, and the fifth simulation system 350E includes a fifth stimulus capture circuit 351E configured to capture stimulus received through a fifth communication link 365E. All of these simulation systems may communicate with each other via other communication links such as the sixth communication link 365F, which may include heterogeneous communication links (e.g., a mix of PCIe, LVDS, and Ethernet links), depending on the level at which the various simulation systems are implemented. Each of the stimulus capture circuits may include a stimulus storage device (e.g., a dynamic random access memory and / or a persistent memory such as a flash memory or a disk drive) to store captured stimuli. In some embodiments, the captured stimuli are time stamped in accordance with a simulation clock cycle in which the captured stimuli are presented to the receiving circuit module based on the simulation clock of the simulation system simulation receiving circuit module.

[0062] In some embodiments, the stimulus capture circuit is connected to or included in a router circuit that is configured to route messages between FPGAs, such as in Figure 3A In some embodiments, the stimulus capture circuit is connected to or included in the emulated communication circuit structure inserted into the partitioned circuit module by the compiler.

[0063] Figure 4 4 is a flow chart of a method 400 for separately compiling partitions of an integrated circuit design and inserting simulated communication circuit structures according to one embodiment of the present disclosure. For example, Figure 4 The method 400 shown in Figure 2 The method 200 shown in FIG. 1 is performed after partitioning the integrated circuit design into a plurality of partitions at 210 and before the operation of simulating the integrated circuit design at 230 (before or after assigning the plurality of partitions of the integrated circuit design to corresponding portions of the simulation system at 220). At 410, the computer system receives the partitioned integrated circuit design including the plurality of partitions. At 420, the computer system inserts simulated communication circuit structures into the partitions.

[0064] Some aspects of embodiments of the present disclosure relate to providing several representation levels for a user to define the communication between any two IP blocks or circuit modules of the entire integrated circuit design. In some embodiments, the representation provides a hierarchical model, from a more detailed representation level (e.g., a lower level model) to a less detailed representation level (e.g., a higher level model): packet level, transaction level, and protocol level.

[0065] In some embodiments, the more detailed representation level exposed to the user (e.g., an engineer designing an integrated circuit) is a packet level representation. Under the packet level representation, the user can create bit packets to be sent from one IP block of the integrated circuit design to another IP block. Because this level of representation is close to the underlying representation of the signal, this can be referred to as a lower-level model. According to some embodiments, a parameterizable simulated communication circuit structure (or simulated communication circuit portion) is provided to send data, and another is used to receive data. These simulated communication circuit portions are inserted and connected in the user design. These simulated communication circuit portions support a simple handshake protocol for sending and receiving packets. In some embodiments of this low-level representation, the user must also write (e.g., define) a controller circuit that can use the handshake protocol to send or receive data.

[0066] The following is an example of a parameterizable simulation communication circuit portion for communicating between simulators, as expressed in a hardware description language (HDL):

[0067] Table 1 - Portions of the emulated communication circuit used to send data to another emulator:

[0068] module zceiMessageOutPort(tx_rdy,rx_rdy,data);

[0069] parameter N = 32;

[0070] input tx_rdy;

[0071] output rx_rdy;

[0072] input[N-1:0]data;

[0073] endmodule

[0074] Table 2 - Portions of the emulated communication circuit used to receive data from another emulator:

[0075] module zceiMessageInPort(tx_rdy,rx_rdy,data);

[0076] parameter N = 32;

[0077] output tx_rdy;

[0078] input rx_rdy;

[0079] output[N-1:0]data;

[0080] endmodule

[0081] At 420, these structures may be added to, for example, an HDL representation of a partition of an integrated circuit design.

[0082] In some embodiments, the sending and receiving modules are paired so that both ends have the same data size. For sending (or receiving) data, the protocol is as follows: If tx_rdy (or rx_rdy) is 1 at the rising edge of the local simulator clock, then the data is valid and is considered to have been sent (or received). Because a local clock is used on each side, the communication is asynchronous. There are some delays between the sending IP block and the receiving IP block, but this delay does not directly limit the operating speed of either IP. In some embodiments, the IP blocks are simulated according to independent simulation clocks, as discussed above. Therefore, the embodiments of the present disclosure implement the simulation decoupling of two different IP blocks or circuit modules within the integrated circuit design through asynchronous communication, so that the speed at which one IP block is simulated does not limit the speed at which other IP blocks can be simulated.

[0083] Another representation level of communication between IP blocks is the transaction level or function level of communication. At the transaction level of representation, users can use function calls to implement communications associated with transactions between IP blocks. If a function call is performed in one IP block, where the function is defined in another IP block, the simulation compiler generates structures in the compiled design of the IP blocks (caller IP block and callee IP block) at 430 to implement asynchronous communication of function parameters (e.g., transmitted from the caller IP block) and its return value (transmitted from the callee IP block). In such an embodiment, the simulation compiler is configured to convert the function-based user code into a state machine using the packet level representation as described above at 430. Compared with the case where the user has directly used the packet level representation to implement the communication, the use of the transaction level representation eliminates the need for the user to implement low-level details (e.g., handshake protocols) because those low-level details are implemented by the simulation compiler (e.g., inserting code from a library to implement the handshake protocol), at the expense of reducing the user's control over how to implement those details. In some embodiments, the simulation compiler supports functions and tasks as defined by a hardware description language (e.g., Verilog functions and Verilog tasks as defined in the SystemVerilog Direct Programming Interface or DPI standard). Imported functions defined in one IP block correspond to exported functions in another IP block. Similarly, input parameters of a function in one IP block may correspond to output parameters in another IP.

[0084] For example, the first IP block may include code expressed in HDL to generate a corresponding simulated communication circuit structure:

[0085]

[0086] The second IP block may include the following code represented by HDL to generate a corresponding simulated communication circuit structure:

[0087]

[0088] Calling the import function transfer in the first IP block side will result in the execution of the exported function in the second IP block. Therefore, at 420, the simulation compiler can generate the following corresponding code based on the function call in the code defining the first IP block and the second IP block using the packet level interface.

[0089] In the first IP block represented by HDL, a corresponding simulation communication circuit structure is generated:

[0090]

[0091] In the second IP block represented by HDL, a corresponding simulation communication circuit structure is generated:

[0092]

[0093]

[0094] The third representation level according to some embodiments of the present disclosure relates to the protocol level of the representation. At the protocol level, an interface is provided to the user to design an IP block or circuit module into a bit-level interface according to a custom or standard protocol interface (e.g., a peripheral component interconnect express or PCIe interface). In some embodiments, at 430, the simulation compiler compiles the protocol level usage of the defined interface into a packet-level representation (e.g., implemented using previously defined DPI functions to transmit data to and receive data from other IP blocks).

[0095] As mentioned above about Figure 1 As mentioned, separate partitions of the integrated circuit design are separately or independently compiled into separate compiled data (e.g., separate bit files to configure an FPGA and corresponding routing logic) at 430. These different sets of compiled data for each partition are then used to configure separate simulation systems to simulate the operation of the separate partitions of the complete integrated circuit design. As mentioned above, separate or independent compilation of different circuit portions enables decoupling of different circuit portions of the integrated circuit design, such that changes limited to one partition of the integrated circuit design require only recompilation of that partition of the integrated circuit design, and do not require recompilation of other partitions of the integrated circuit design.

[0096] Figure 5 A hierarchical view of a connection for simulation communication between two circuit modules or IP blocks simulated by different simulation systems (or different parts of simulation systems) according to one embodiment of the present disclosure is depicted, wherein three representation layers are used to implement the connection. Figure 5 , a first simulation system (simulator 1) 510 simulates a first IP block 511 or a first circuit module of an integrated circuit design, and a second simulation system (simulator 2) 520 simulates a second IP block 521 or a second circuit module of an integrated circuit design. The simulation communication system of the first simulation system 510 includes three representation levels above an underlying simulation communication circuit structure 513. As described above, these representation layers include a packet level 515, a function level 517 (established on a packet level 515 representation), and a protocol level 519 (established on a function level 517 representation). Similarly, the simulation communication system of the second simulation system 520 includes three representation levels above an underlying simulation communication circuit structure 523. These representation layers include a packet level 525, a function level 527 (established on a packet level 525 representation), and a protocol level 529 (established on a function level 527 representation). Messages may then be exchanged between the simulated first IP block 511 and the simulated second IP block 521 through, for example, a protocol, function, and packet level presentation layer, wherein defined message packets are transmitted through a send circuit (e.g., send / receive circuit 513) of one IP block and received through a receive circuit (e.g., send / receive circuit 523) of another IP block. Depending on the level at which the user implements the message exchange, the protocol and / or function levels of the presentation layer may be omitted. For example, if the user implements message exchange between simulated systems only at the function level, then the circuit structures for implementing the protocol levels 519 and 529 may be omitted from the compiled design.

[0097] As mentioned above, the transmit / receive circuit of each IP block is instantiated in the FPGA of the simulation system, and the simulation environment for simulating the IP blocks or circuit modules of the integrated circuit design is parameterized (eg, configurable).

[0098] Figure 6 is a block diagram illustrating a transmitting circuit 610 and a receiving circuit 650 inserted by a simulation compiler according to one embodiment of the present disclosure. Figure 6 The embodiments shown in the present invention provide methods which can be used, for example, according to Figure 5A non-limiting example of a send / receive circuit of send / receive circuit 513 and send / receive circuit 523 shown in an embodiment of the present invention, for example, where send / receive circuit 513 and send / receive circuit 523 may each include a copy of send circuit 610 and a copy of receive circuit 650, so that each circuit can perform both send functionality and receive functionality. As mentioned above, the simulation compiler can insert send and receive circuits into the compiled data representing the circuit module, so that the FPGA configured to simulate the corresponding circuit module includes send and receive circuits for exchanging data with circuit modules simulated on other FPGAs in the simulation system. For example, Figure 6 An implementation of the zceiMessageOutPort module discussed above in Table 1 and the zceiMessageInPort module discussed above in Table 2 may be depicted. In some embodiments, the implementation of the actual data transfer between the sending and receiving circuits is invisible to the end user.

[0099] Figure 6 The examples shown in are implemented with a word length of 64 bits.

[0100] The packet in this example includes a 1-word (64-bit) header that includes a checksum (e.g., a cyclic redundancy check or CRC value), a packet type (e.g., idle or payload), a packet control value, and the size N (in words) of the payload (where N may be zero). Depending on the size specified in the packet's header, the optional payload may contain N words of data.

[0101] The send control interface (SND CTRL IF) 611 is an IP block or a circuit module (DUT) (e.g., Figure 5 613) and the transmitter buffer (SND FIFO) 613. As long as the transmitter buffer (SND FIFO) 613 is not full and the circuit module (DUT) is ready, the driver clock domain (driverClock) accepts messages (msg) from the circuit module (DUT). These messages encode the stimulus output by the IP block or circuit module, which is to be transmitted to another simulated IP block or circuit module of the integrated circuit design, where the other simulated IP block or circuit module is connected to the receiving circuit 650.

[0102] The transmitter buffer (SND FIFO) 613 allows the clock domain change between driverClock and multi-gigabit transceiver clock (mgt clock). Messages are written based on the driverClock domain, and on the MGT clock reading side, the data granularity is word (64 bits). The transmitter buffer (SND FIFO) 613 acts as a serializer.

[0103] The transmitter transmit controller (SND TX CTRL) 615 provides an interface between the transmitter buffer (SND FIFO), the transmitter receiver control (SND RX CTRL) 617 and the transmitter multi-gigabit transceiver (MGT) 619. The transmitter transmit controller 615 is configured to assemble packets to be sent to the multi-gigabit transceiver 619. When the SND RX CRTL signal rcv_rdy is 1 and the transmitter buffer (SND FIFO) 613 is not empty, then the CTRL WR reads data from the transmitter buffer (SND FIFO) 613 and sends the data packet to the MGT serializer. The transmit transmit controller 615 is also responsible for the synchronization of the link at the beginning of the simulation.

[0104] The transmitter receive controller (SND RX CTRL) 617 provides an interface between the multi-gigabit transceiver (MGT) 619 at the transmitter circuit 610 and the transmitter transmit controller (SND TX CTRL) 615 and is configured to decode packets from the receiver transmit controller (RCV TX CTRL) 657 .

[0105] The receiver receive controller (RCV RX CTRL) 655 is an interface between the receiver multi-gigabit transceiver (MGT) 659, the receiver transmit ready signal (RCV TX RDY), and the receiver buffer (RCV FIFO) 653 at the receiver circuit 650. When the receiver buffer (RCV FIFO) 653 is almost full (e.g., has room for exactly one more packet or more than K packets, where K may be set based on parameters such as the latency and bandwidth of the emulated interconnect so that the receiver buffer can store any additional packets that will be transmitted from the receiver before the transmitter circuit 610 receives a feedback signal or notification signal from the receiver circuit 650, discussed below), it signals the receiver transmit controller (RCV TX CTRL) 655 using the rcv_rdy signal (e.g., sets rcv_rdy to false, discussed in more detail below). The receiver receive controller (RCV RX CTRL) 655 also writes packets from the receiver multi-gigabit transceiver (MGT) 659 into the receiver buffer (RCV FIFO) 653 and ensures synchronization of the MGT 659.

[0106] The receiver buffer (RCV FIFO) 653 allows a clock domain change between the multi-gigabit transceiver (MGT) clock and the driverClock at the receiver circuit 650. This allows the receiver circuit 650 to accept messages on the receiver side until the transmitter receives notification that the message can no longer be read (e.g., because the receiver buffer 653 is full).

[0107] The receiver control interface (RCV CTRL IF) 651 provides an interface between the receiver buffer (RCV FIFO) 653, the receiver transmit controller (RCV TX CTRL) 657, and the serializer. The receiver control interface 651 also provides received data to the circuit module (or IP block) connected to the receiving circuit 650 in the form of a stimulus (msg) transmitted from the circuit module (or IP block) connected to the transmitting circuit 610.

[0108] In some embodiments, the size of the receive buffer is set based on the latency of the communication link between the transmitter and the receiver.

[0109] LS = packet delay from sending IP to receiving IP

[0110] LR = the delay time from receiving IP to sending IP of the header

[0111] RFS = RCV FIFO minimum size. RFS is equal to the number of packets that can be sent during LR+LS.

[0112] In some embodiments, when the receiver buffer (RCV FIFO) available space is almost full (e.g., where the available space is greater than RFS but within a threshold of RFS), the receiver communicates that it is no longer ready to receive data, e.g., the receiver ready signal (rcv_rdy) may be set to false (rcv_rdy == 0). The transmitter will continue to send packets until it receives a signal of rcv_rdy == 0. The receiver buffer (RCV FIFO) has enough free space to accept packets that will continue to arrive from the transmitter after de-assertion of rcv_rdy.

[0113] As discussed above, some aspects of embodiments of the present disclosure relate to independent simulation of different partitions of an integrated circuit design using different simulation systems or different portions of simulation systems, each using independent simulation clocks. The partitions of the integrated circuit design are performed at the level of different IP blocks that communicate through an on-chip delay-tolerant interconnect 108, such that different partitions simulated by different simulation systems or different portions of simulation systems tolerate delays in stimuli or messages exchanged through the simulation communication circuit structure discussed above.

[0114] Thus, one or more partitions simulated by a given simulation system or portion of a simulation system are independently simulated at a simulation clock rate that is not limited by the maximum simulation clock rate of other partitions simulated by other simulation systems (e.g., other computer systems) or other portions of the simulation system (e.g., other boards of the simulation system) running at different simulation clock rates. This allows individual partitions to be simulated at their highest clock rate, thereby enabling detection of potential problems or vulnerabilities (e.g., timing violations, logic errors, and the like) within a given time budget to verify the integrated circuit design.

[0115] Figure 7 7 is a flow chart of a method 700 for running a partitioned simulation of an integrated circuit design according to one embodiment of the present disclosure. At 710, a computer system managing a simulation of an integrated circuit design in a simulation environment controls a plurality of simulation systems (and / or portions of simulation systems, according to various embodiments of the present disclosure) to load compiled configuration data for different partitions of the integrated circuit design (e.g., based on the partitions in the simulation environment). Figure 2 The partition assignment of the simulation system is performed at 220). These compiled configuration data may be, for example, Figure 4 The data generated at 430 of method 400 shown in , such that the configuration data for a partition includes one or more bit files for configuring one or more FPGAs to simulate corresponding circuit portions (or IP blocks) of the partition of the integrated circuit design, and may also include information on how the multiple FPGAs communicate with each other during simulation (for example, for circuit paths extending between the FPGAs).

[0116] At 730, the computer system controls the simulation system (or a portion of the simulation system) to independently simulate the respective assigned partitions of the integrated circuit design. During these independent simulations, the partitions may exchange messages or transmit stimuli with each other to communicate with each other via delay-tolerant interconnects (e.g., Figure 1 The delay tolerant interconnect 108 shown in FIG. 1 is used to simulate the interaction between IP blocks. Figure 7 An example is shown including a first independent simulation 731 for simulating a first circuit portion or a first IP block 101, a first independent simulation 732 for simulating a second circuit portion or a second IP block 102, and so on, to a third independent simulation 733 for simulating an N-th circuit portion or an N-th IP block (e.g., a sixth circuit portion or a sixth IP block 106).

[0117] The computer system generates a report of the results of the independent simulations at 750. This report may include, for example, outputs computed by the circuit portions that were individually simulated, values ​​stored in memory or registers in the simulation partitions of the integrated circuit design during the simulation process, violations of timing conditions detected during the simulation of the integrated circuit design, differences between the output of the simulated integrated circuit design and the expected output, and the like.

[0118] Thus, aspects of embodiments of the present disclosure relate to independent simulation of different partitions of an integrated circuit design, thereby enabling the different partitions of the integrated circuit design to be simulated at different simulation clock rates, wherein at least one of the partitions of the integrated circuit design is simulated at a faster simulation clock rate (higher clock rate) than the partition could be simulated when a shared simulation clock is used to simulate the entire integrated circuit design.

[0119] Some aspects of embodiments of the present disclosure relate to simulating a single partition or a subset of partitions of an integrated circuit design by replaying stimuli provided to the partition or subset of partitions by a partition of the integrated circuit design that is not being simulated.

[0120] Figure 8 8 is a flow chart of a method 800 for simulating a subset of a partition of an integrated circuit design using replay of stimuli from other partitions according to one embodiment of the present disclosure. At 810, a computer system controlling a simulation environment controls one or more simulation systems to load configuration data to simulate a selected partition or a selected subset of partitions of an integrated circuit design. In a manner similar to that described above, this may include loading one or more bit files for configuring an FPGA to simulate one or more selected partitions of an integrated circuit design. At 830, the computer system loads captured stimuli transmitted from other (unselected) partitions to one or more selected partitions of the integrated circuit design. These captured stimuli may have been captured during a simulation run of the integrated circuit design in which the selected partition is simulated. As another example, these captured stimuli may have been captured during a simulation of the integrated circuit design. As yet a third example, these captured stimuli may be generated based on expected behavior or expected stimuli to be transmitted to one or more selected partitions.

[0121] At 830, the computer system controls the simulation environment to start the simulation of the selected partition of the integrated circuit design using the configured one or more simulation systems. At 850, the computer system supplies the captured stimulus to the selected partition of the simulation, for example, by supplying the captured stimulus to the simulated communication circuit structure of the simulated circuit. As mentioned above, in some embodiments, the captured stimulus is time-stamped according to the simulation clock cycle in which it is presented to the receiving circuit. Therefore, in some embodiments, each captured stimulus among the captured stimuli includes a receiving partition (e.g., a corresponding receiving simulation communication circuit structure) and a timestamp (e.g., a simulation cycle count) measured based on the independent simulation clock of the receiving partition. Therefore, when the independent simulation clock of the receiving partition matches the simulation timestamp specified in the stimulus, the computer system supplies the stimulus to the appropriate simulation communication circuit structure.

[0122] The computer system generates a report of the results of the simulation of the one or more selected partitions of the integrated circuit design at 870. This report may include, for example, outputs calculated by the selected circuit portions being simulated, values ​​stored in memory or registers in the selected simulated partitions of the integrated circuit design during the simulation process, violations of timing conditions detected during the simulation of the selected partitions of the integrated circuit design, differences between outputs of the simulated selected partitions of the integrated circuit design and expected outputs, and the like.

[0123] Thus, aspects of embodiments of the present disclosure relate to performing simulation of selected partitions or selected subsets of a complete integrated circuit design by replaying stimuli captured from unselected partitions (or unsimulated partitions of the integrated circuit design) to selected simulation partitions without simulating the complete integrated circuit design.

[0124] Fig. 9 An example set of processes 900 used during the design, verification, and manufacture of an article such as an integrated circuit to transform and verify design data and instructions representing the integrated circuit is described. Each of these processes can be structured and enabled as multiple modules or operations. The term 'EDA' represents the term 'electronic design automation'. These processes begin with creating a product concept 910 with information provided by a designer, which is transformed to create an article using a set of EDA processes 912. When the design is complete, the design is taped out 934, which is when the artwork (e.g., geometric pattern) of the integrated circuit is sent to a manufacturing facility to manufacture a mask set, which is then used to manufacture the integrated circuit. After tape-out, semiconductor die are manufactured 936, and packaging and assembly processes 938 are performed to produce finished integrated circuits 940.

[0125] The specification of a circuit or electronic structure can range from low-level transistor material layout to a high-level description language. The high-level representation can be used to design circuits and systems using a hardware description language ('HDL') such as VHDL, Verilog, SystemVerilog, SystemC, MyHDL or OpenVera. The HDL description can be converted to a logic level register transfer level ('RTL') description, a gate level description, a layout level description or a mask level description. Each lower level of representation as a more detailed description adds more useful details to the design description, for example, more details of the modules that contain the description. The lower level of representation as a more detailed description can be computer generated, derived from a design library, or created by another design automation process. An example of a lower-level specification language for specifying a more detailed description representation language is SPICE, which is used for detailed descriptions of circuits with many analog components. The description of each representation level is enabled to be used by the corresponding system of that layer (e.g., a formal verification system). The design process can use Fig. 9 The sequence depicted in . Fig. 9The described process may be enabled by an EDA product (or EDA system).

[0126] During system design 914, the functionality of the integrated circuit to be manufactured is specified. The design may be optimized for desired characteristics such as power consumption, performance, area (physical and / or lines of code), and cost reduction, etc. The design may be divided into different types of modules or components at this stage.

[0127] During logic design and functional verification 916, modules or components in the circuit are specified in one or more description languages ​​and checked for functional accuracy of the specifications. For example, the components of the circuit can be checked to generate outputs that match the specification requirements of the designed circuit or system. Functional verification can use simulators and other programs, such as test bench generators, static HDL checkers, and formal checkers. In some embodiments, special systems of components called 'simulators' or 'prototyping systems' are used to accelerate functional verification.

[0128] During synthesis and test design 918, the HDL code is converted into a netlist. In some embodiments, the netlist may be a graph structure where the edges of the graph structure represent components of the circuit and where the nodes of the graph structure represent how the components are interconnected. Both the HDL code and the netlist are hierarchical artifacts that can be used by EDA products to verify that the integrated circuit performs according to the specified design when manufactured. The netlist can be optimized for the target semiconductor manufacturing technology. In addition, the finished integrated circuit can be tested to verify that the integrated circuit meets the requirements of the specification.

[0129] During netlist verification 920, the netlist is checked for compliance with timing constraints and for correspondence with the HDL code. During design planning 922, an overall floor plan of the integrated circuit is constructed and analyzed for timing and top-level routing.

[0130] During layout or physical implementation 924, physical layout (positioning of circuit components such as transistors or capacitors) and routing (connecting circuit components through multiple conductors) are performed, and selection of cells from a library may be performed to implement a specific logic function. As used herein, the term 'cell' may specify a group of transistors, other components, and interconnections that provide a Boolean logic function (e.g., AND, OR, NOT, XOR) or a storage function (e.g., a flip-flop or latch). As used herein, a circuit 'block' may refer to two or more cells. Both cells and circuit blocks may be referred to as modules or components and may be enabled as both physical structures and simulations. Parameters such as size are specified for the selected cell (based on a 'standard cell') and made accessible in a database for use by an EDA product.

[0131] During analysis and extraction 926, circuit functionality is verified at the layout level, which allows refinement of the layout design. During physical verification 928, the layout design is checked to ensure that manufacturing constraints, such as DRC constraints, electrical constraints, lithography constraints are correct, and that the circuit functionality matches the HDL design specifications. During resolution enhancement 930, the geometry of the layout is transformed to improve the manufacturing of the circuit design.

[0132] During tape-out, data is created for use (after applying lithography enhancements if appropriate) in the production of lithography masks.During mask data preparation 932, the 'tape-out' data is used to produce lithography masks for use in producing finished integrated circuits.

[0133] Computer systems (e.g. Fig.11 Computer system 1100 or Fig.10 The storage subsystem of the host system 1007) may be used to store programs and data structures used by some or all of the EDA products described herein, as well as products for developing cells for the library and for physical and logical designs that use the library.

[0134] Fig.10 A diagram depicting an example simulation environment 1000. The simulation environment 1000 may be configured to verify functionality of a circuit design. The simulation environment 1000 may include a host system 1007 (e.g., a computer as part of an EDA system) and a simulation system 1002 (e.g., a set of programmable devices such as a field programmable gate array (FPGA) or a processor). The host system generates data and information to structure the simulation system to simulate the circuit design by using a compiler 1010. The circuit design to be simulated is also referred to as a design under test ('DUT'), where data and information from the simulation is used to verify functionality of the DUT.

[0135] The host system 1007 may include one or more processors. In embodiments where the host system includes multiple processors, the functions described herein as being performed by the host system may be distributed across the multiple processors. The host system 1007 may include a compiler 1010 to convert a specification written in a description language representing a DUT and generate data (e.g., binary data) and information for the structured simulation system 1002 to simulate the DUT. The compiler 1010 may convert, change, restructure the DUT, add new functionality to the DUT, and / or control the timing of the DUT.

[0136] The host system 1007 and the simulation system 1002 exchange data and information using signals carried by the simulation connection. The connection may be, but is not limited to, one or more cables, such as a cable having a pin structure compatible with the Recommended Standard 232 (RS232), Universal Serial Bus (USB), or Peripheral Component Interconnect Express (PCIe or PCI Express) protocol. The connection may be a wired communication medium or network, such as a local area network or a wide area network, such as the Internet. The connection may be a wireless communication medium or network with one or more access points using a wireless protocol such as Bluetooth or IEEE802.11. The host system 1007 and the simulation system 1002 may exchange data and information through a third device such as a network server.

[0137] The simulation system 1002 includes a plurality of FPGAs (or other modules), such as FPGAs 10041 and 10042 and additional FPGAs 10044 and 10045. N . Each FPGA may include one or more FPGA interfaces through which the FPGA is connected to other FPGAs (and potentially other simulation components) for the FPGAs to exchange signals. FPGA interfaces may be referred to as input / output pins or FPGA pads. Although an emulator may include an FPGA, embodiments of an emulator may include other types of logic blocks that are used in place of or in conjunction with the FPGA to simulate the DUT. For example, the simulation system 1002 may include a custom FPGA, a dedicated ASIC for simulation or prototyping, memory, and input / output devices.

[0138] A programmable device may include an array of programmable logic blocks and an interconnection hierarchy that enables the programmable logic blocks to be interconnected according to descriptions in HDL code. Each of the programmable logic blocks may enable complex combinational functions or enable logic gates, such as AND and XOR logic blocks. In some embodiments, the logic blocks may also include memory elements / devices, which may be simple latches, flip-flops, or other memory blocks. Depending on the length of the interconnections between different logic blocks, signals may arrive at the input terminals of the logic blocks at different times and may therefore be temporarily stored in the memory elements / devices.

[0139] FPGA 10041 to 1004 N Can be placed on one or more boards 10121 and 10122 and additional boards to 1012 M Multiple boards can be placed into the simulation unit 10141. The boards within the simulation unit can be connected using the backplane of the simulation unit or any other type of connection. In addition, multiple simulation units (e.g., 10141 and 10142 to 1014 K ) can be connected to each other by cables or any other components to form a multi-simulation unit system.

[0140] For the DUT to be simulated, the host system 1007 transmits one or more bit files to the simulation system 1002. The bit file may specify a description of the DUT, and may further specify the partitions of the DUT with the trace and injection logic created by the host system 1007, the mapping of the partitions to the FPGA of the simulator, and the design constraints. Using the bit file, the simulator structures the FPGA to perform the functions of the DUT. In some embodiments, one or more FPGAs of the simulator may build the trace and injection logic into the silicon of the FPGA. In such an embodiment, the FPGA may not be structured by the host system to simulate the trace and injection logic.

[0141] The host system 1007 receives a description of the DUT to be simulated. In some embodiments, the DUT description is in a description language (e.g., register transfer language (RTL)). In some embodiments, the DUT description is in a netlist-level file or a mixture of a netlist-level file and an HDL file. If part or all of the DUT description is in HDL, the host system can synthesize the DUT description to create a gate-level netlist using the DUT description. The host system can use the netlist of the DUT to divide the DUT into multiple partitions, one or more of which include tracking and injection logic. The tracking and injection logic tracks interface signals exchanged via the interface of the FPGA. In addition, the tracking and injection logic can inject the tracked interface signals into the logic of the FPGA. The host system maps each partition to the FPGA of the simulator. In some embodiments, the tracking and injection logic is included in the selected partition of the FPGA group. The tracking and injection logic can be built into one or more of the FPGAs of the simulator. The host system can synthesize a multiplexer to be mapped into the FPGA. The multiplexer can be used by the tracking and injection logic to inject the interface signal into the DUT logic.

[0142] The host system creates a bit file that describes each partition of the DUT and the mapping of the partitions to the FPGA. For partitions that contain trace and injection logic, the bit file also describes the logic contained. The bit file may contain place and route information and design constraints. The host system stores the bit file and information that describes which FPGAs are going to emulate each component of the DUT (e.g., which FPGA each component maps to).

[0143] Upon request, the host system transfers the bit file to the simulator. The host system signals the simulator to start simulation of the DUT. During simulation of the DUT or at the end of simulation, the host system receives simulation results from the simulator via the simulation connection. The simulation results are data and information generated by the simulator during simulation of the DUT, including interface signals and states of the interface signals that have been tracked by the trace and injection logic of each FPGA. The host system can store the simulation results and / or transmit the simulation results to another processing system.

[0144] After the simulation of the DUT, the circuit designer may request to debug the elements of the DUT. If such a request is made, the circuit designer may specify the time period of the simulation to be debugged. The host system uses the stored information to identify which FPGAs are simulating components. The host system retrieves the stored interface signals associated with the time period and tracked by the trace and injection logic of each identified FPGA. The host system signals the simulator to re-simulate the identified FPGA. The host system transmits the retrieved interface signals to the simulator to re-simulate the components within the specified time period. The trace and injection logic of each identified FPGA injects its corresponding interface signals received from the host system into the logic of the DUT mapped to the FPGA. In the case of multiple re-simulations of the FPGA, the merged results produce a complete debug view.

[0145] During the re-simulation of the component, the host system receives signals traced by the logic of the identified FPGA from the simulation system. The host system stores the signals received from the simulator. The signals traced during the re-simulation may have a higher sampling rate than the sampling rate during the initial simulation. For example, in the initial simulation, the traced signal may include the component state saved every X milliseconds. However, in the re-simulation, the traced signal may include the state saved every Y milliseconds, where Y is less than X. If the circuit designer requests to view the waveform of the signal traced during the re-simulation, the host system can retrieve the stored signal and display a chart of the signal. For example, the host system can generate a waveform of the signal. Afterwards, the circuit designer can request to re-simulate the same component in a different time period, or re-simulate another component.

[0146] The host system 1007 and / or the compiler 1010 may include subsystems such as, but not limited to, a design synthesizer subsystem, a mapping subsystem, a runtime subsystem, a result subsystem, a debug subsystem, a waveform subsystem, and a storage subsystem. The subsystems may be structured and enabled as individual or multiple modules, or two or more may be structured as one module. These subsystems together structure the simulator and monitor the simulation results.

[0147] The design synthesizer subsystem converts the HDL representing the DUT 1005 into gate-level logic. For a DUT to be simulated, the design synthesizer subsystem receives a description of the DUT. If the description of the DUT is in full or in part in HDL (e.g., RTL or other representation level), the design synthesizer subsystem synthesizes the HDL of the DUT to create a gate-level netlist in terms of the description of the DUT in terms of gate-level logic.

[0148] The mapping subsystem partitions the DUT and maps the partitions into the simulator FPGA. The mapping subsystem uses the netlist of the DUT to partition the DUT into multiple partitions at the gate level. For each partition, the mapping subsystem retrieves the gate-level description of the trace and injection logic and adds the logic to the partition. As described above, the trace and injection logic contained in the partition is used to track signals exchanged via the interface of the FPGA to which the partition is mapped (tracking interface signals). The trace and injection logic can be added to the DUT before partitioning. For example, the trace and injection logic can be added by the design synthesizer subsystem before or after synthesizing the HDL of the DUT.

[0149] In addition to including trace and injection logic, the mapping subsystem may also include additional trace logic in the partitions to track the states of certain DUT components that are not tracked by trace and injection. The mapping subsystem may include the additional trace logic in the DUT before partitioning or in the partitions after partitioning. The design synthesizer subsystem may include the additional trace logic in the HDL description of the DUT before synthesizing the HDL description.

[0150] The mapping subsystem maps each partition of the DUT to the FPGA of the simulator. For the partitioning and mapping, the mapping subsystem uses the design rules, design constraints (e.g., timing or logic constraints), and information about the simulator. For the components of the DUT, the mapping subsystem stores information in the storage subsystem that describes which FPGAs are to simulate each component.

[0151] Using partitioning and mapping, the mapping subsystem generates one or more bit files that describe the mapping of the created partitions and logic to each FPGA of the simulator. The bit files may contain additional information, such as constraints for the DUT and routing information for connections between FPGAs and connections within each FPGA. The mapping subsystem may generate a bit file for each partition of the DUT and store the bit files in the storage subsystem. Upon request from the circuit designer, the mapping subsystem transmits the bit file to the simulator, and the simulator may use the bit file to structure the FPGA to simulate the DUT.

[0152] If the emulator includes a dedicated ASIC containing trace and injection logic, the mapping subsystem can generate a specific structure that connects the dedicated ASIC to the DUT. In some embodiments, the mapping subsystem can save information of the traced / injected signals and the location where the information is stored on the dedicated ASIC.

[0153] The runtime subsystem controls the simulation performed by the simulator. The runtime subsystem can cause the simulator to start or stop performing the simulation. In addition, the runtime subsystem can provide input signals and data to the simulator. The input signal can be provided to the simulator directly through a connection or indirectly through other input signal devices. For example, the host system can control the input signal device to provide the input signal to the simulator. The input signal device can be, for example, a test board (directly or through a cable), a signal generator, another simulator, or another host system.

[0154] The result subsystem processes simulation results generated by the simulator. During simulation and / or after the simulation is completed, the result subsystem receives simulation results generated during simulation from the simulator. The simulation results include signals tracked during simulation. Specifically, the simulation results include interface signals tracked by the tracking and injection logic simulated by each FPGA, and may include signals tracked by additional logic included in the DUT. Each tracked signal may span multiple cycles of the simulation. The tracked signal includes multiple states, and each state is associated with the time of the simulation. The result subsystem stores the tracked signals in the storage subsystem. For each stored signal, the result subsystem may store information indicating which FPGA generated the tracked signal.

[0155] The debug subsystem allows the circuit designer to debug a DUT component. After the simulator has simulated the DUT and the results subsystem has received the interface signals traced by the trace and injection logic during simulation, the circuit designer can request to debug a component of the DUT by re-simulating the component for a specific time period. In the request to debug a component, the circuit designer identifies the component and indicates the time period of the simulation to be debugged. The circuit designer's request may include a sampling rate that indicates how often the logic that traces the signals should save the state of the debug component.

[0156] The debug subsystem uses information stored in the storage subsystem by the mapping subsystem to identify one or more FPGAs of the emulator that are emulating the component. For each identified FPGA, the debug subsystem retrieves from the storage subsystem interface signals tracked by the trace and injection logic of the FPGA during a time period indicated by the circuit designer. For example, the debug subsystem retrieves states associated with the time period tracked by the trace and injection logic.

[0157] The debug subsystem transmits the retrieved interface signals to the emulator. The debug subsystem instructs the debug subsystem to use the identified FPGAs and, for each identified FPGA's trace and injection logic, inject its corresponding traced signal into the FPGA's logic to re-emulate the component within the requested time period. The debug subsystem may further transmit a sampling rate provided by the circuit designer to the emulator so that the trace logic traces the state at appropriate time intervals.

[0158] To debug a component, the simulator can use the FPGA to which the component has been mapped. In addition, re-simulation of the component can be performed at any time point specified by the circuit designer.

[0159] For the identified FPGA, the debug subsystem can transmit instructions to the simulator to load multiple simulator FPGAs with the same configuration of the identified FPGA. The debug subsystem also signals the simulator to use multiple FPGAs in parallel. Each FPGA from the multiple FPGAs is used together with different time windows of the interface signal to generate a larger time window in a shorter amount of time. For example, the identified FPGA may take an hour or more to use a certain amount of cycles. However, if multiple FPGAs have the same data and structure of the identified FPGA, and each of these FPGAs runs a subset of the cycle, then the simulator may take several minutes for the FPGA to use all the cycles together.

[0160] The circuit designer can identify a hierarchy or list of DUT signals to be re-simulated. To accomplish this, the debug subsystem determines the FPGA required to simulate the hierarchy or list of signals, retrieves the necessary interface signals, and transmits the retrieved interface signals to the simulator for re-simulation. Thus, the circuit designer can identify any element (e.g., component, device, or signal) of the DUT for debugging / re-simulation.

[0161] The waveform subsystem generates waveforms using the traced signals. If the circuit designer requests to view the waveform of a signal traced during a simulation run, the host system retrieves the signal from the storage subsystem. The waveform subsystem displays a graph of the signal. For one or more signals, the waveform subsystem can automatically generate a graph of the signal when the signal is received from the simulator.

[0162] Fig.11 An example machine of computer system 1100 is illustrated within which a set of instructions may be executed for the machine to perform any one or more of the methodologies discussed herein. In alternative embodiments, the machine may be connected (e.g., using a network) to other machines in a LAN, an intranet, an extranet, and / or the Internet. The machine may operate in the capacity of a server or a client machine in a client-server network environment, as a peer machine in a peer-to-peer (or distributed) network environment, or as a server or a client machine in a cloud computing infrastructure or environment.

[0163] The machine may be a personal computer (PC), a tablet PC, a set-top box (STB), a personal digital assistant (PDA), a cellular phone, a network appliance, a server, a network router, a switch or a bridge, or any machine capable of executing (sequentially or otherwise) a set of instructions that specify actions to be taken by the machine. Further, while a single machine is described, the term "machine" shall also be taken to include any collection of machines that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methodologies discussed herein.

[0164] The example computer system 1100 includes a processing device 1102, a main memory 1104 (e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM) (e.g., synchronous DRAM (SDRAM)), a static memory 1106 (e.g., flash memory, static random access memory (SRAM)), etc.), and a data storage device 1118, which communicate with each other via a bus 1130.

[0165] The processing device 1102 represents one or more processors, such as a microprocessor, a central processing unit, or the like. More specifically, the processing device may be a complex instruction set computing (CISC) microprocessor, a reduced instruction set computing (RISC) microprocessor, a very long instruction word (VLIW) microprocessor, or a processor that implements other instruction sets or multiple processors that implement a combination of instruction sets. The processing device 1102 may also be one or more special-purpose processing devices, such as an application-specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), a network processor, or the like. The processing device 1102 may be configured to execute instructions 1126 for performing the operations and steps described herein.

[0166] The computer system 1100 may further include a network interface device 1108 to communicate over a network 1120. The computer system 1100 may also include a video display unit 1110 (e.g., a liquid crystal display (LCD) or a cathode ray tube (CRT)), an alphanumeric input device 1112 (e.g., a keyboard), a cursor control device 1114 (e.g., a mouse), a graphics processing unit 1122, a signal generating device 1116 (e.g., a speaker), a graphics processing unit 1122, a video processing unit 1128, and an audio processing unit 1132.

[0167] The data storage device 1118 may include a machine-readable storage medium 1124 (also referred to as a non-transitory computer-readable medium) on which is stored one or more sets of instructions 1126 or software embodying any one or more of the methodologies or functions described herein. During execution of the instructions 1126 by the computer system 1100, the instructions 1126 may also reside completely or at least partially within the main memory 1104 and / or within the processing device 1102, which also constitute machine-readable storage media.

[0168] In some embodiments, the instructions 1126 include instructions that implement functionality corresponding to the present disclosure. Although the machine-readable storage medium 1124 is shown as a single medium in the example embodiments, the term "machine-readable storage medium" should be considered to include a single medium or multiple media (e.g., a centralized or distributed database, and / or associated caches and servers) that store one or more sets of instructions. The term "machine-readable storage medium" should also be considered to include any medium that can store or encode a set of instructions for machine execution and cause the machine and processing device 1102 to perform any one or more of the methods of the present disclosure. Therefore, the term "machine-readable storage medium" should be considered to include, but not limited to, solid-state memory, optical media, and magnetic media.

[0169] Some portions of the foregoing detailed description have been presented in terms of algorithms and symbolic representations of operations on data bits in a computer memory. These algorithmic descriptions and representations are the means by which those skilled in the art of data processing technology most effectively convey the substance of their work to others skilled in the art. An algorithm may be a sequence of operations leading to a desired result. The operations are those requiring physical manipulation of physical quantities. These quantities may take the form of electrical or magnetic signals capable of being stored, combined, compared, and otherwise manipulated. Such signals may be referred to as bits, values, elements, symbols, characters, terms, numbers, or the like.

[0170] It should be kept in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless otherwise clearly apparent from this disclosure, it should be understood that throughout the description certain terms refer to the actions and processes of a computer system or similar electronic computing device to manipulate and transform data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system's memories or registers or other such information storage devices.

[0171] The present disclosure also relates to an apparatus for performing the operations described herein. This apparatus may be specially constructed for the intended purpose, or it may include a computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a computer-readable storage medium, such as, but not limited to, any type of disk including a floppy disk, an optical disk, a CD-ROM, and a magneto-optical disk, a read-only memory (ROM), a random access memory (RAM), an EPROM, an EEPROM, a magnetic or optical card, or any type of medium suitable for storing electronic instructions, each of which is coupled to a computer system bus.

[0172] The algorithms and displays presented herein are not inherently related to any particular computer or other device. Various other systems may be used together with the programs taught herein, or it may prove convenient to construct more specialized equipment to perform the methods. In addition, the present disclosure is not described with reference to any particular programming language. It will be appreciated that the teachings of the present disclosure as described herein may be implemented using various programming languages.

[0173] The present disclosure may be provided as a computer program product or software, which may include a machine-readable medium having instructions stored thereon, which instructions may be used to program a computer system (or other electronic device) to perform a process according to the present disclosure. A machine-readable medium includes any mechanism for storing information in a form that can be read by a machine (e.g., a computer). For example, a machine-readable (e.g., computer-readable) medium includes a machine (e.g., computer) readable storage medium, such as a read-only memory ("ROM"), a random access memory ("RAM"), a magnetic disk storage medium, an optical storage medium, a flash memory device, etc.

[0174] In the foregoing disclosure, embodiments of the present disclosure have been described with reference to specific example embodiments of the present disclosure. Obviously, various modifications may be made thereto without departing from the broader spirit and scope of implementation of the present disclosure as set forth in the following claims. Where the present disclosure relates to some elements of a singular number, more than one element may be described in the figures, and the same elements may be marked with the same numerals. Therefore, the present disclosure and the accompanying drawings should be regarded as illustrative rather than restrictive.

Claims

1. A method comprising: receiving an integrated circuit design including a plurality of circuit modules; dividing the integrated circuit design into a plurality of partitions according to the plurality of circuit modules; assigning the plurality of partitions of the integrated circuit design to corresponding portions of a simulation system; inserting, by a processor, a plurality of emulated communication circuit structures into the plurality of circuit modules of the integrated circuit design, the corresponding portion of the emulation system being configured to communicate via one or more emulated interconnects connected to the emulated communication circuit structures, the emulated communication circuit structures being represented at a level of representation selected from the group consisting of: a packet level; a transaction level; and a protocol level; and Operation of the integrated circuit design is simulated using the simulation system.

2. The method of claim 1 , wherein the portion of the simulation system comprises one or more components selected from the group consisting of: Field Programmable Gate Array; a board including a plurality of field programmable gate arrays; and A computer system connected to a plurality of field programmable gate array boards.

3. The method of claim 2, wherein the simulated interconnect comprises one or more interconnects selected from the group consisting of: Low Voltage Differential Signaling interconnects; Multi-gigabit transceivers; the back panel of the emulation unit; and Ethernet connection. 4 . The method of claim 1 , further comprising individually supplying the plurality of circuit modules to a simulation compiler to generate a plurality of compiled circuit modules.

5. The method of claim 4 , wherein the simulation compiler is configured to compile a simulation communication circuit structure into a circuit module among the plurality of circuit modules, the simulation communication circuit structure being configured to communicate with another circuit module among the plurality of circuit modules via the one or more simulation interconnects.

6. The method according to claim 1, further comprising: during simulation of operation of a first partition of the plurality of partitions and a second partition of the plurality of partitions of the integrated circuit design, capturing a stimulus transmitted from the first partition to the second partition through the one or more simulated interconnects; and The stimuli are stored as a plurality of captured stimuli in a stimulus storage device, captured stimuli of the captured stimuli comprising a simulation timestamp based on a simulation clock of the simulation of the second partition.

7. The method according to claim 6, further comprising: configuring a portion of the simulation system to simulate the second partition; and During simulation of the operation of the second partition using the simulation system without simulating the first partition, the captured stimulus is supplied from the stimulus storage device to the second partition.

8. The method of claim 1, wherein said operation of simulating said integrated circuit design using said simulation system comprises: simulating, using a first portion of the simulation system, a first partition of the plurality of partitions including a first circuit module of the plurality of circuit modules according to a first simulation clock; and A second partition of the plurality of partitions including a second circuit module of the plurality of circuit modules is simulated using a second portion of the simulation system according to a second simulation clock that is independent of the first simulation clock.

9. A system comprising: a first simulation system comprising a first plurality of field programmable gate arrays (FPGAs); a second simulation system comprising one or more second plurality of FPGAs; and A host system comprising a processor and a memory storing instructions which, when executed, cause the processor to: receiving an integrated circuit design comprising a plurality of circuit modules configured to communicate via a delay tolerant interconnect; dividing the integrated circuit design into a plurality of partitions according to the plurality of circuit modules; inserting a first emulated communication circuit structure into a first FPGA of the first plurality of FPGAs and inserting a second emulated communication circuit structure into a second FPGA of the second plurality of FPGAs, the first emulated communication circuit structure and the second emulated communication circuit structure being represented at a representation level selected from the group consisting of: a packet level; Transaction level; and protocol level; configuring the first plurality of FPGAs of the first simulation system to simulate a first partition of the plurality of partitions of the integrated circuit design; configuring the second plurality of FPGAs of the second simulation system to simulate a second partition of the plurality of partitions of the integrated circuit design; and Operation of the integrated circuit design is simulated using the first simulation system and the second simulation system, the first partition and the second partition being configured to communicate using the first simulated communication circuit structure and the second simulated communication circuit structure.

10. The system of claim 9, wherein the memory further stores instructions that, when executed, cause the processor to control stimulus capture circuitry to capture stimulus for transmission from the first partition simulated by the first simulation system to the second partition simulated by the second simulation system.

11. The system of claim 10, wherein the stimulus capture circuit is connected to a simulation interconnect between the first simulation system and the second simulation system.

12. The system of claim 10, wherein the stimulus capture circuit is connected to an emulated communication circuit structure of the second emulation system.

13. The system of claim 9, wherein the first simulation system is configured to simulate the first partition at a first simulation clock rate, and The second simulation system is configured to simulate the second partition at a second simulation clock rate that is independent of the first simulation clock rate.

14. A non-transitory computer readable medium comprising stored instructions that, when executed by a processor, cause the processor to: receiving an integrated circuit design comprising a plurality of circuit modules configured to communicate via a delay tolerant interconnect; dividing the integrated circuit design into a plurality of partitions according to the circuit modules; inserting a first emulated communication circuit structure into a first circuit module of a first partition of the plurality of partitions, the first emulated communication circuit structure being represented at a first representation level selected from the group consisting of: a packet level; Transaction level; and protocol level; compiling the first circuit module to generate a first compiled circuit module including a first bit file to configure a first field programmable gate array (FPGA) to emulate a first portion of the first circuit module; inserting a second emulated communication circuit structure into a second circuit module of a second partition of the plurality of partitions, the second emulated communication circuit structure being represented at a second representation level selected from the group consisting of: a packet level; Transaction level; and protocol level; and The second circuit module is compiled independently of the first circuit module to generate a second compiled circuit module including a second bit file to configure a second FPGA to emulate a second portion of the second circuit module.

15. The non-transitory computer-readable medium of claim 14, wherein the first emulated communication circuit structure is connected to an output pin of the first circuit module and is configured to send a data packet representing a signal at the output pin according to a protocol, and The second emulation communication circuit structure is connected to an input pin of the second circuit module and is configured to receive the data packet according to the protocol and supply the signal represented in the data packet to the input pin.

16. The non-transitory computer-readable medium of claim 14, wherein the first emulated communication circuit structure and the second emulated communication circuit structure are represented at the protocol level.

17. The non-transitory computer-readable medium of claim 14, wherein the first emulated communication circuit structure and the second emulated communication circuit structure are represented at the transaction level.

18. The non-transitory computer-readable medium of claim 14, wherein the first emulated communication circuit structure and the second emulated communication circuit structure are represented at the packet level.

19. The non-transitory computer readable medium of claim 14, further storing instructions that, when executed, cause the processor to: receiving an updated integrated circuit design, wherein the first circuit module in the updated integrated circuit design is replaced by an updated first circuit module, and wherein the second circuit module is unchanged from the second circuit module of the integrated circuit design; and The updated first circuit module is compiled to generate an updated first compiled circuit module including a first updated bitfile to configure the first FPGA to emulate a first portion of the updated first circuit module without recompiling the second circuit module.

20. The non-transitory computer readable medium of claim 14, wherein the first compiled circuit module is controlled by a first simulation clock, and The second compiled circuit module is controlled by a second simulation clock independent of the first simulation clock.

Citation Information

Cited By

  • Distributed networking verification method and system

    CN122021496A