Patent Application
20070179772
1. Field of the Invention
Embodiments of the present invention generally relate to a simulation acceleration technique or an emulation engine used in emulating a system composed of logic gates, and more particularly, to a method and apparatus for improving the efficiency of system emulation.
2. Description of the Related Art
Hardware emulators are programmable devices used in the verification of hardware designs. A common method of hardware design verification is to use a processor-based hardware emulator to emulate the design. These processor-based emulators sequentially evaluate combinatorial logic levels, starting at the inputs and proceeding to the outputs of a circuit. Each pass through the entire set of logic levels is known as a cycle; the evaluation of each individual logic level is known as an emulation step.
An exemplary hardware emulator is described in commonly assigned U.S. Pat. No. 6,618,698 titled “Clustered Processors In An Emulation Engine”, which is hereby incorporated by reference in its entirety. Hardware emulators allow engineers and hardware designers to test and verify the operation of an integrated circuit, an entire board of integrated circuits, or an entire system without having to first physically fabricate the hardware.
The complexity and number of logic gates present on an integrated circuit has increased significantly in the past several years. Moore's Law predicts the number of transistors or gates present in an integrated circuit will double every two years. Hardware emulators need to improve in efficiency to keep pace with the increased complexity of integrated circuits.
A hardware emulator is comprised of multiple processors. The processors are arranged into groups of processors known as clusters, and the clusters of processors collectively comprise the emulation engine. Each processor is capable of emulating one or more logic gates, mimicking the function of logic gates in an integrated circuit. The processors are arranged to compute results in parallel, in the same way logic gates present in an integrated circuit compute many results in parallel.
The output of a processor or input to the emulator is stored in a memory known as a data array such that the output can be used by the processor, another processor or some other device. The data array has a single read/write port. The output from a read port of the data array provides a single bit of input to a processor. A typical processor has, for example, four inputs. Processors are generally grouped together into clusters and share a data array. Each of the processors produces one output per instruction during each emulation step. A data array coupled to N processors (where N is an integer and each processor has four inputs) must write N bits (1-bit output from each of the N processors) and have 4×N 1-bit read ports to supply four input bits to each of the N processors. Since conventional memory devices do not have multiple ports, a plurality of memory devices (each having one read/write port) are arranged in parallel to have the same N-bit data written to each device during the write cycle and during the read cycle a single bit is provided to one of the processor's inputs. The data stored in each of the memory devices in the cluster is identical and the emulator selectively accesses the data that is to be coupled to each processor. Thus, any one processor in the cluster can access any of the data available to any other processor in the cluster. Unfortunately, as the number of instructions processed per emulation cycle increases, the amount of processor output increases and the corresponding size of the data array must also increase. Each additional instruction within an emulation cycle requires an additional N-bit word to be stored in each memory device. Thus, in an emulator using N four input processors, each additional instruction within an emulation cycle requires 4×N additional bits of storage in the data array. The cost of adding extra data array memory is a significant factor that affects the overall cost of a hardware emulator.
Therefore, there is a need in the art for a method and apparatus that improves the number of instructions a processor can execute per cycle without the significant cost increase attributed to adding data array memory.
The present invention generally relates to an improved processor-based emulation engine. The emulation engine is composed of a plurality of processors, each processor capable of emulating one or more logic gates. The processors are arranged into groups of processors known as clusters. Each processor in a duster has access to the output of all the other processors in the cluster, and a cluster has access to the output of all the other clusters within the emulation engine. Data within the cluster is stored in at least one data array, where the at least one data array comprises a plurality of sub-arrays. The present invention improves upon previous emulation engines by including sub-arrays within a data array that are not of uniform size (e.g., the size of each sub-array is determined by the probability that a particular sub-array will be accessed by a processor during a future emulation step). In one embodiment of the invention, at least one first sub-array is equal in depth to instruction memory within a processor (i.e., equal to the number of instructions in an emulation cycle), and the remaining sub-arrays are a fractional depth of the first sub-array.
So that the manner in which the above recited features of the present invention can be understood in detail, a more particular description of the invention, briefly summarized above, may be had by reference to embodiments, some of which are illustrated in the appended drawings. It is to be noted, however, that the appended drawings illustrate only typical embodiments of this invention and are therefore not to be considered limiting of its scope, for the invention may admit to other equally effective embodiments.
The present invention is an improved method and apparatus for increasing the efficiency of an emulation engine. An exemplary emulation engine is disclosed in U.S. Pat. No. 6,618,698 “Clustered Processors In An Emulation Engine” and U.S. Pat. No. 5,551,013 “Multiprocessor For Hardware Emulation” which are hereby incorporated by reference in their entirety.
In response to the programming received from the emulation support facilities 110, the emulation engine 120 emulates a portion 125 of the target system 130. The portion 125 of the target system 130 may be an integrated circuit, a memory, a processor, or any object or device that can be emulated in a Hardware Description Language (HDL). Popular emulation languages include Verilog and VHDL.
An emulation engine 120 contains multiple processor modules 230n. All processor modules 230n within the emulation engine are identical. In one embodiment of the invention, a processor module 230n emulates either a four input logic function, or a memory array access according to an emulation program provided by the emulation support facilities (110 in
The embodiment of the invention depicted in
In one embodiment of the invention, the first sub-array 3301 has a depth of Y words, where each word comprises 1-bit of output data from each of N processors, i.e., an N-bit word. The remaining sub-arrays 3302, 3303, . . . 330n are of a fractional depth of Y words. Each sub-array 3301 to 330n has a respective depth of Y, Y/a, Y/b or Y/c, where Y is equal to the number of steps the emulation engine is capable of emulating per cycle and a, b, and c are integer values. The values of a, b, and c may be different or equal. In one embodiment of the invention, the depth Y is equal to the depth of the control store array logic 305. The control store array logic 305 contains a sequence of instructions that control all functions performed by the various elements inside the processor cluster. Output data from the processor 230 is written sequentially using an address supplied from the control logic 305 to a unique location within the data array 320. The same data is simultaneously written to each sub-array 3301, 3302, 3303 . . . 330n. After Y steps, the first sub-array 3301 with a depth of Y words is full and new output data cannot be written to the first data sub-array 3301 without overwriting previously stored data. The remaining sub-arrays 3302, 3303, . . . 330n that have a fractional depth of Y words will become full before the completion of one emulation cycle. The history prior to the Y/a, Y/b or Y/c steps respectively will be lost.
The integers that define the depth of the sub-arrays 3302, 3303, . . . 330n are determined using a probabilistic analysis of the operation of a data array. The probabilistic analysis considers the probability of processed data stored in the data array 320 being requested by the processor 230 after a certain number of steps in an emulation cycle. This analysis may be based upon review of empirical data as well as review of the emulation process data requirements. The processors 230 generally evaluate gates in a sequential manner similar to the actual function performed by an integrated circuit where the logic gates are arranged in a tree format such that an output from one gate is coupled to another gate. A processor evaluates one gate in the tree on a particular step and, on the next step, another processor (or possibly the same processor) evaluates the next logic gate in the tree. The output of one processor generally feeds the input of another processor (or the same processor) in a sequential manner. When performing sequential evaluation of logic trees, a processor's input data is more likely to be recently generated than having been generated by a step from earlier in a cycle.
For example, if an emulation cycle has 512 steps, and the probability of processed data stored in the data array 320 being requested by the processor 230 after 256 steps of the emulation cycle is low, one or more of the sub-arrays 3302, 3303, . . . 330n can have a depth of, for example, 256 words. The processor 230 can request processed data from the sub-arrays 3302, 3303, . . . 330n for any of the prior 256 steps in the emulation cycle. Processed data generated by the first 256 steps of the emulation cycle is obtainable from the first sub-array 3301 and the processed data generated in the next 256 steps in the cycle are available from all the sub-arrays. Thus, the processed data from the most recent 256 steps in the emulation cycle is available to any of the processors 230 directly from a related sub-array 330. However, if, in the unlikely event, the processor 2302, 2303, . . . 230n requires data from a step earlier than the last 256 steps, the processor must retrieve the data from the first sub-array 330, rather than sub-arrays 3302, 3303, . . . 330n.
In one embodiment of the invention, a data array comprises one sub-array of depth Y words, and three additional sub-arrays of the depth Y/2 words. The sub-arrays are coupled to a processor comprising a control store word stack of a depth Y words. The combined depth of the sub-arrays is approximately 37.5% smaller than if all of the data arrays coupled to the processor were all of a depth Y words. In an embodiment where two sub-arrays store Y steps of data and two sub-arrays store Y/2 steps of data, the storage area savings is 25% compared to storing Y steps of data in all four sub-arrays. Thus, depending upon the embodiment, an emulation cycle can be increased by 37.5% or 25% more instructions without increasing the data array size.
In another embodiment of the invention using, for example, four processors having four inputs each, the memory required by the data array can be reduced by having the first sub-array store data for Y steps, the second sub-array store data for ¾ Y steps, the third sub-array store data for ½ Y steps and a fourth sub-array store data for ¼ Y steps. In this embodiment, a savings of 37.5% is realized, i.e., an emulation cycle can be increased by 37.5% more instructions without increasing the data array size.
The sequencer 308 is connected to the data array 320 the NBO arrays 390, and the control store array logic 305. For simplicity, the sequencer 308 is shown only connected to the first NBO array 390, in
When an NBO array is used, the control words also determine which one of the cluster inputs 240 is selected by the NBO Input Multiplexer 370, the read address for the data array 320 and the read address for the NBO arrays 390. The data array bus 340 interconnects the data array 320, sub-arrays 330 and the processors 230 such that data from any processor 230 or sub-array 330 can be coupled to any other processor 230 or sub-array 330 within the cluster 220. The processor bus 350 interconnects the processors 230 and the NBO arrays 390 such that data generated by the processors 230 can be coupled to any processor 230 or any NBO array 390. The NBO output bus 395 interconnects the NBO arrays 390 within the duster 220. The NBO output bus 395 provides a cluster output 250 that can be coupled to other clusters 220 within the emulation engine.
An NBO input multiplexer 370 selectively couples a duster input 240 from the NBO output bus of other clusters of processors to the data array 320 and the NBO array 390. The sequencer 308 provides timing for writing the data to a memory location within the data array 320 and the NBO array 390
The processors 230 emulate one or more logic functions defined by a control word provided by the control store array logic 305. The processors 230 receive data input from the data array 320 via the data array bus 340 such that any stored data may be coupled to any processor 230. The processors 230 process the data using a function defined by the associated control store word.
The data out signal from a processor 230 is distributed to each of the other processors 230 and the data array 320. During any logic or memory operation, the data out signal of a processor 230 may be accessed by none, one, or all of the processors 230 within the cluster 220 (shown in
As mentioned above, access to stored data is performed using a control word provided by the control store array logic 305. The multiplexer 465 is coupled to the selector logic 463 and controlled by the current control word from the control store array logic 305. The control word addresses the memory 462 to access a particular data word. The retrieved data as well as the input data are applied to the multiplexer 465. The selector logic 463 maps the control word into a selection signal that selects one of the multiplexer inputs for output to the register 466. The selector logic 463 also provides a output timing signal to the register 466. The output from the register 466 is coupled to the data array bus 340.
The processor 230 is a fundamental component of the emulation engine 200. The processor's primary function is to execute an N-input logical function (where N is an integer) and produce a function bit out during each step of the sequencer 308. The inputs for each logic function can be selected from a variety of sources, including bits stored from a previous operation, or from another one or more processors. The resulting function bit out may correspond to any one of: a logic gate output of the emulated design, a register output of the emulated design, a synthesized intermediate logic state, or a control bit generated for the emulation process. Additional common operations performed by the processor 230 during an emulation step include storing the function bit out for subsequent use by the processor, capturing and storing external (to the processor) data, receiving data from another processor, and latching data for use by another processor.
A benefit of the present invention is that the depth of the control store word stack can be increased, while the size of the data array does not increase. The illustrative embodiments show an cycle length increase of 25 to 37.5% will not result in an increase in the present amount of data array memory. This allows the hardware emulator to have a deeper control store word stack, emulate more steps per cycle, without an increase in the size of the data array within the hardware emulator.
While the foregoing is directed to embodiments of the present invention, other and further embodiments of the invention may be devised without departing from the basic scope thereof, and the scope thereof is determined by the claims that follow. While the foregoing is directed to embodiments of the present invention, other and further embodiments of the invention may be devised without departing from the basic scope thereof, and the scope thereof is determined by the claims that follow.
