JP2797128B2 - Logic simulator - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION [Object of the Invention] (Field of Industrial Application) The present invention relates to a logic simulator.

(Prior Art) In general, a semiconductor device is configured by a logic circuit including a large number of basic functional elements. For example, when designing a new semiconductor device, whether or not the designed logic circuit operates as expected is performed. Are simulated in advance by a logic simulator. Conventionally, such a logic simulator has been configured by software using a general-purpose computer or the like.

In order to speed up the logic simulation in such a logic simulator, Japanese Patent Laid-Open No.
No. 52, JP-A-63-257841, and the like propose a logic simulator in which a part of the software of the logic simulator as described above is replaced with hardware.

(Problems to be Solved by the Invention) However, in recent years, semiconductor devices tend to be highly integrated, and accordingly, logic circuits to be simulated by a logic simulator also tend to be large-scale and complicated. For this reason, even in a logic simulator in which a part of the conventional software described above is replaced with hardware, it may take several hours or tens of hours for the simulation, and it is required to further speed up the simulation. I have.

In particular, the logic circuit to be simulated is RAM
In the case of reading and writing data by accessing these memories during simulation, conventional logic simulators have to respond between hardware and software. This necessitates a problem that the simulation speed is reduced.

The present invention has been made in view of such a conventional situation, and aims to provide a logic simulator that can perform a simulation at a higher speed than a conventional one even for a logic circuit having a memory such as a RAM and a ROM. Is what you do.

[Structure of the Invention] (Means for Solving the Problems) That is, a logic simulation according to the present invention comprises an input / output device, at least data on the configuration of a simulated logic circuit input from the input / output device, and the logic A plurality of RAMs for storing data relating to a test pattern for testing the operation of the circuit, data stored in a memory in the logic circuit, and a simulation result; A simulation chip for simulating the state of a circuit, wherein a memory chip in the logic circuit is treated as a plurality of cells having multiple inputs and one output, and data stored in the memory is read from the RAM as necessary. And characterized in that:

According to a second aspect of the present invention, in the logic simulator according to the first aspect, the simulation chip has a test in which information on an event type of a simulation input signal and a net name where the event has occurred are described in order of occurrence time. A vector sequentially reading from the RAM and expanding it in the memory, and a time wheel unit for writing a newly generated event between these test vectors in the order of occurrence time; and reading the information of the event sequentially from the time wheel unit. An accumulator unit that executes a simulation in each net; and a function logic unit that receives a simulation result from the accumulator unit, determines an occurrence state of an event in each logic block, and outputs a determination result. Toss .

(Operation) In the logic simulator of the present invention, at least data relating to a configuration of a logic to be simulated, data relating to a test pattern for testing the operation of the logic, and data stored in a memory in the logic circuit are provided. Store multiple simulation results,
Has RAM. Then, the simulation chip simulates the state of the logic circuit to be simulated by self-running (only the arithmetic processing in the simulation chip) in response to the RAM.

The data stored in the memories (RAM and ROM) constituting the logic circuit to be simulated is stored in advance in a dedicated RAM (RAM, ROM data memory) in the logic simulator. Then, the simulation chip treats the memory as a plurality of cells having multiple inputs and outputs, and reads and writes data from the dedicated RAM as needed.

Therefore, even a logic circuit having a memory such as a RAM and a ROM can execute a simulation without responding to a general-purpose computer during the simulation.

For this reason, the simulation speed can be significantly increased as compared with the related art.

Embodiment Hereinafter, a logic simulator according to one embodiment of the present invention will be described with reference to the drawings.

As shown in FIG. 1, a logic simulator of this embodiment includes a simulation chip 1 composed of hardware formed on one chip, a data storage unit 2 composed of, for example, a plurality of RAMs, An engineering work station (hereinafter, referred to as EWS) 3 as an apparatus constitutes a main part thereof.

The simulation chip 1 includes a time wheel unit (hereinafter, TWU) 11, an accumulator unit (hereinafter, ACU) 12, a function logic unit (hereinafter, FWU).
DU) 13.

On the other hand, the data storage unit 2 includes a condition state memory (hereinafter, referred to as COM) 21, a test vector memory (hereinafter, referred to as TVM) 22, a time wheel memory (hereinafter, referred to as T).
WM) 23, event table memory (hereinafter ETM) 24, net information memory (hereafter NI)
M) 25, result storage memory (RSM) 2
6, Cell Spec Memory (hereinafter CSM) 27, RAM, RO
An M data memory (hereinafter referred to as RRM) 28, a net signal state memory (hereinafter referred to as STM) 29 and the like are provided.

The simulation chip 1 and the data storage unit 2
It is connected via an external bus (external data bus, external address bus) 4.

The TWU 11, ACU 12, and FDU 13 in the logic unit 1 are connected via an internal bus (internal data bus, internal address bus) 14.

Further, of the plurality of memories, only the STM 28 is connected to the ACU 12 via a dedicated state bus (state data bus, state address bus) 30.

The data required for the simulation is input by the EWS3, transferred to the data storage unit 2, and taken into the simulation chip 1 as necessary. Necessary data is stored.

The data necessary for the simulation include data related to the configuration of the logic, that is, net information data related to the connection state of each cell (logic element), cell specification data related to the specification of each cell, and test vectors related to the input signal for the simulation. However, these are pre-EW
It is written from S3 into TVM22, NIM25, CSM27.

The test vector stored in the TVM 22 describes, for example, the type of a change (hereinafter, referred to as an event) such as rising or falling of an input signal, and information on a net name where the event has occurred, in the order of occurrence time. Further, each event is provided with an event gate flag indicating the order of occurrence of the event.

As shown in FIG. 4, the net information data stored in the NIM 25 includes, for example, a net next-stage memory (hereinafter referred to as NNM) 25a indicating which cell the output-side net of a certain cell is connected to, and an extended net. The next stage memory (hereinafter referred to as ENNM) 25b, the net front stage memory (hereinafter referred to as NBM) 25c which indicates which net is connected to the input side of a certain cell, and the extended net front stage memory (hereinafter referred to as ENBM) 25d are provided. ing. Also,
This net information data includes information on the cell type (for example, whether it is an AND gate or an OR gate) and information on the fan-out (load capacity) of the cell. In addition, the cell specification data stored in the CSM 27 indicates performance required for calculating a delay time due to a fan-out and a timing error such as a hold time and a setup time of each cell.

Of the net information data relating to the above-described logic configuration, as for memories such as RAM and ROM, for example, as shown in FIG.
101101z and a cell 103 having a plurality of outputs 102a〜102z, and as shown in FIG.
This is handled as a plurality of one output cells 103a to 103z divided for each 102z.

In this way, by dividing the RAM and the ROM for each output and handling them, when performing a simulation in the logic unit 1, it is possible to process each divided cell by focusing on only one output. For this reason, RAM and ROM
It can be handled in the same way as ordinary cells such as AND gates and OR gates.

The actual data stored in the RAM and ROM is stored in the RRM 28 according to the address, and the data is read and written by accessing the RRM 28 as necessary. .

Next, regarding the configuration and operation of the logic unit 1 composed of hardware formed on one chip, TWU11, A
CU12 and FDU13 will be described in this order.

 The TWU 11 is configured, for example, as shown in FIG.

In the TWU 11, the test vectors written in the TVM 22 from the EWS 3 are sequentially read, expanded to the TWM 23 and the ETM 24, and a newly generated event is written between these test vectors in the order of the occurrence time.

That is, the TWM 23 is a memory for managing an event, has an address in absolute time, and stores, as data, an event value (pointer) in the ETM 24 which stores event-related data such as an event occurrence net name and an event value. The event occurrence time (TWM address: pointer) and the like are stored. The ETM 24 has, as data, an occurrence net name and an event value of an event that has occurred at a certain time, and further has an ETM address value (pointer) in which another event data that has occurred at the same time is stored.

The data bus register 40 of the TWU 11 is a bidirectional register that connects an internal bus and an external bus. Further, the comparator logic 41 determines whether or not the event occurs at the same time.
Determines whether a newly generated event or an event that has been loaded disconnects the pointer (whether it is necessary to reconnect the chain of pointers), or whether memory writing is not prohibited. The addition logic 43 calculates the absolute time of a newly generated event from the current absolute time and the delay value.

In addition, the TVM counter 44 sets the test vector of the TVM 22 to TW
TWM counter 45 is for loading into M
The ETM counter 46 determines the absolute time of the address of M23 as ET.
Indicates the address of M24.

A before event register (hereinafter, referred to as a BE register) 47 indicates data of the TWM 23 at the current time. The next event register (hereinafter referred to as the NE register) 48 is the TVM2
Stores and processes data loaded from step 2 and newly generated event data.

The TWU control logic 49 controls the operation of the TWU 11.

 Next, the operation of the TWU 11 will be described.

First, the TWU 11 loads, into the TWM 23, a test vector for performing a simulation accommodated in the TVM 22.
(However, only the time range indicated by TWM23 is loaded.)

In the above operation, if there is an event that occurs at the same time, the net name and event value of the event are written to the ETM 24, and the address of the ETM 24 is written as a pointer of the TWM 23. This operation is performed using the BE register 48 and the NE register 48. If the loaded event exceeds the previously loaded event and it is necessary to update the pointer indicating the next occurrence time of the TWM 23 (reconnect the pointer chain), the pointer is updated.

When the loading of the test vector from the TVM 22 to the TWM 23 is completed as described above, the events are sequentially received in response to the event read request signal (ACU request) from the ACU 12.
Read from WM23 to ACU12.

When the data is transmitted, the right to use the external bus 4 is transferred to the ACU 12, and the TWU 11 is in a standby state until a newly generated event write request signal coming from the FDU 13 or an ACU request from the ACU 12 comes.

Then, when the ACU request comes, the event is sequentially read from the TWM 23 to the ACU 12 again.

When an event write request signal is generated from the FDU 13, the net name, event value and delay value of the newly generated event are sent to the internal data bus 14. After latching this data in the data bus register 40, the TWU 11 calculates the absolute time of the newly generated event from the current absolute time and the delay value in the adder logic 43 and writes the calculated absolute time in the TWM 23. At this time, if it is necessary to update the pointer indicating the next event occurrence time of the TWM 23 (reconnect the pointer chain), the pointer is updated.

Thereafter, if there is still an event in the TWM 23, the event is read from the TWM 23 to the ACU 12 as described above, and the same processing is performed. If no event exists in the TWM 23, a test vector in the next time range is loaded from the TVM 22 to the TWM 23, and the above processing is repeated. Then, all the test vectors for performing the simulation in the TVM 22 are loaded and processed, and if all the events generated thereby are processed, the operation is terminated.

In the example shown in FIG. 3, SRAM is used as each memory. However, when DRAM is used, it is necessary to add a DRAM controller circuit.

 Next, the ACU 12 will be described with reference to FIG.

In ACU12, first, ACU control logic 60 starts ACU
A request is issued, and the event data output on the internal bus in synchronization with the TW acknowledge signal from TWU11 is
Latch into register 61. Upon receiving the TW acknowledge signal, the ACU 12 obtains the occupation right of the external bus 4, latches the event data, and sets the event read request signal to "L" to enter the internal operation.

Then, the STM 28 is accessed using the event occurrence net name (address) latched in the IBUS register 61, and the current state (logical value) of the event occurrence net and the event gate flag are stored in the status register 62.

Thereafter, the event gate flag from the TWU 11 stored in the IBUS register 61 and the event gate flag from the STM 28 stored in the status register 62 are
By performing a comparison operation in the LU 63, it is determined whether the current event is a valid event, an invalid event, or an uncertain event and has to be replaced with the logical value “E”.

If it is determined in the above determination that the current event is invalid, the event gate flag of the IBUS register 61 is written to the STM 29 in preparation for the calculation of the event data from the next TWU 11, and the processing of the current event ends. .

On the other hand, in the above determination, when it is determined that the current event is valid or indefinite, the event gate flag of the IBUS register 61 is written to the STM 29, and then the contents of the current event are written and left in the RSM 26 via the data selector 64. At this time, the address at which the current event is written is sequentially incremented from “0000” to “FFFF” by the RSM write address counter 65.

Note that the simulation result is once TWM23 or EWM
It is written to TM24, read from these memories after the delay time, becomes a past event only after checking the event gate flag, and is written to RSM26.

Next, the ACU 12 enters a task of finding an output change (next-stage event) of the next-stage cell caused by the current event.

First, the NNM 25a in the NIM 25 is identified by the net name (address) where the event occurred, which is latched in the IBUS register 61.
And stores the net name (address), cell type, and fan-out in which the next event may occur in the NN register 66. Here, if there are two or more nets where the next-stage event may occur, only the pointers connecting the next-stage net addresses are read for the second and subsequent nets, and after processing the first next-stage net, The next next net is sequentially read out by the pointer and processed.

Next, the NBM 25c in the NIM 25 is accessed by the address of the next-stage net stored in the NN register 66, and the address of the input net affecting the next-stage net and its input pin code (clock, clear, data enable, Load) is stored in the NB register 67. When there are two or more addresses of the input net, as in the case of the next-stage net, the input is read out one by one using the pointer.
Further, by parallel processing, the STM 29 is accessed with the address of the next-stage net stored in the NN register 66, and the current state (logical value) of the next-stage net and the event gate flag are stored in the status register 62.

Thereafter, the STM 29 is accessed using the address of the input net stored in the NB register 67, and the current state (logical value) of the input net is stored in the status register 62. Also,
The ENBM 25d is accessed by a pointer connecting the address of the input net stored in the NB register 67, and the address of another input net is stored in the NB register 67. And
The information on the next stage net, input net, pin code, cell type, fan-out, etc. stored in the status register 62, the NN register 66, and the NB register 67 is transferred from the data selector 68 to the internal bus 14 every time the status register 62 is rewritten. Transfer to the input register of FDU13 via

When all the information has been transferred to the FDU 13, the ACU control logic 60 issues an ACU continue or an ACU request to pass the occupation right of the external bus 4 to the FDU 13.

That is, when there are a plurality of next-stage nets, an ACU continuation signal is output and the processing of the FDU 13 and the TWU 11 is waited for, and if there is a TW acknowledge, the above process is repeated for the next next-stage net. If there is no next net, the NN register 66, NB register 67, and status register 62 are all cleared, and the next current event is cleared.
It is output from the TWU 11 onto the internal bus 14, issues an ACU request and waits until a TW acknowledgment is received.

 Next, the FDU 13 will be described with reference to FIG.

First, the FDU 13 latches the data transferred from the ACU 12 as described above. Then, in each logic block, the output logic value is determined from the input terminal logic value, and the output logic value of the designated cell is selected based on the cell type data.

Next, the selected output logic value is compared with the current output logic value to determine occurrence of an event (presence or absence of a change). When the output is determined by input data other than the event pin (the pin where the event has occurred), it is determined that no event has occurred.

If no event has occurred, a signal indicating that no event has occurred is sent to the internal bus 14 and the processing of the FDU 13 ends.

On the other hand, if an event occurs, the rising / falling change of the event is determined from the current output logic value and the selected output logic value, and the CSM 27 is determined based on the cell type, input pin name, and output pin name. The address is created, the delay time is calculated from the data input from the CSM 27 and the fan-out data, sent to the internal bus 14 together with the net address, the presence / absence of an event, and the logical value, and the processing of the FDU 13 is completed.

Thus, the state of the simulated logic based on the event that has occurred at a certain time is simulated.

As described above, with respect to memories such as RAM and ROM of the logic circuit to be simulated, the state of each divided cell is sequentially simulated as a plurality of one output cells divided for each output. Further, since the data stored in these memories is expanded in the RRM 28, the simulation is performed by reading from the RRM 28 and writing into the RRM 28 as necessary.

By repeating the processing by the TWU 11, the ACU 12, and the FDU 13, the temporal change of the logic to be simulated according to the test vector in the TVM 22 is obtained.
Without responding to EWS3 during the simulation,
Simulate sequentially.

That is, in the logic simulator of this embodiment, all the logic parts other than the memory are formed as hardware on one chip, and the simulation can be performed by this hardware alone. In addition, memories such as a RAM and a ROM of the logic circuit to be simulated are treated as a plurality of output cells divided for each output, and a simulation is performed in the same manner as a normal cell such as another AND gate or an OR gate. Furthermore, the data stored in the memory such as the RAM and ROM of the logic circuit to be simulated is previously expanded in the dedicated RRM 28, read out from the RRM 28 as needed, and written into the RRM 28 to perform the simulation. Do.

Therefore, for example, even when performing a simulation of a logic circuit having a memory such as a RAM and a ROM,
There is no need for the hardware part (simulation chip 1) and the software part (EWS3) to respond during the simulation as in the conventional logic simulator. For this reason, the time required for such a response can be eliminated, and the simulation speed can be significantly increased as compared with the related art.

In the above embodiment, the TWU 11 and the ACU 12
And an example in which the FDU 13 is provided, it is not always necessary to provide them on one chip.
Alternatively, it may be provided on three to three chips separately. With such a configuration, it is easy to change the configuration of each unit, but the simulation speed is slightly slower than when it is provided on one chip.

[Effects of the Invention] As described above, according to the logic simulator of the present invention, even a simulation of a logic circuit having a memory such as a RAM and a ROM can be performed at a higher speed than in the past.

[Brief description of the drawings]

FIG. 1 is a diagram showing an overall configuration of a logic simulator according to one embodiment of the present invention, FIG. 2 is a diagram for explaining handling of a memory, and FIG. 3 is a configuration of a time wheel unit of the logic simulator of FIG. FIG. 4 is a diagram showing a configuration of an accumulator unit of the logic simulator of FIG. 1, and FIG. 5 is a diagram showing a configuration of a function logic unit of the logic simulator of FIG. 1 simulation chip 2 data storage unit (RAM) 3 engineering work station (input / output device) 4 external bus 11 time wheel unit 12 accumulator unit 13 ... Function logic part, 14 ... Internal bus, 21 ... Condition state memory, 22 ... Test vector memory, 23
…… Time wheel memory, 24 …… Event table memory, 25 …… Net information memory,
26 …… Result storage memory, 27… Cell spec memory, 28… RAM, ROM data memory, 29… Net signal state memory, 30… State bus.

──────────────────────────────────────────────────続 き Continuation of the front page (56) References JP-A-62-226240 (JP, A) JP-A-2-176945 (JP, A) JP-A-2-309270 (JP, A) JP-A-2- 308373 (JP, A) JP-A-59-90152 (JP, A) JP-A-54-75251 (JP, A) (58) Fields investigated (Int. Cl. ⁶ , DB name) G06F 17/50 JICST file (JOIS)

Claims (2)

(57) [Claims] An input / output device, at least data relating to a configuration of a simulated logic circuit input from the input / output device, data relating to a test pattern for testing the operation of the logic circuit, and The data stored in the memory and the simulation results
RAM, a simulation chip that simulates the state of the logic circuit in a self-running manner by responding to the RAM, and treats the memory in the logic circuit as a plurality of cells having multiple inputs and one output. Said
Read the data stored in the memory from the RAM,
A logic simulator, comprising: a simulation chip for writing. 2. The logic simulator according to claim 1, wherein the simulation chip includes a test vector in which information on an event type of a simulation input signal and a net name where the event has occurred are described in order of occurrence time. A time wheel unit that sequentially reads from the RAM and expands the memory, and writes a newly generated event between these test vectors in the order of occurrence time, and sequentially reads information of the event from the time wheel unit, and A logic simulator comprising: an accumulator unit for executing a simulation; and a function logic unit for receiving a simulation result from the accumulator unit, determining an occurrence state of an event in each logical block, and outputting a determination result. Over data.