Links

Images

Classifications

G—PHYSICS

G06—COMPUTING; CALCULATING; COUNTING

G06F—ELECTRICAL DIGITAL DATA PROCESSING

G06F5/00—Methods or arrangements for data conversion without changing the order or content of the data handled

G06F5/06—Methods or arrangements for data conversion without changing the order or content of the data handled for changing the speed of data flow, i.e. speed regularising or timing, e.g. delay lines, FIFO buffers; over- or underrun control therefor

G06F5/10—Methods or arrangements for data conversion without changing the order or content of the data handled for changing the speed of data flow, i.e. speed regularising or timing, e.g. delay lines, FIFO buffers; over- or underrun control therefor having a sequence of storage locations each being individually accessible for both enqueue and dequeue operations, e.g. using random access memory

G06F5/14—Means for monitoring the fill level; Means for resolving contention, i.e. conflicts between simultaneous enqueue and dequeue operations for overflow or underflow handling, e.g. full or empty flags

G—PHYSICS

G06—COMPUTING; CALCULATING; COUNTING

G06F—ELECTRICAL DIGITAL DATA PROCESSING

G06F2205/00—Indexing scheme relating to group G06F5/00; Methods or arrangements for data conversion without changing the order or content of the data handled

Abstract

A buffer memory status detection circuit has a binary logic gate (e.g. an OR gate) coupled to a comparator output signal that is asserted when a sum of a first address pointer of a FIFO memory array plus a first offset equals a second address pointer, and to a reset signal. Binary logic provides a binary output (i.e. “0” or “1”) in a first clock domain to two synchronization registers in series that convert the output to a second clock domain. An optional pipeline register improves timing of the output in the second clock domain, and is particularly desirable for use with high-speed clocks.

Description

FIELD OF THE INVENTION

This invention relates generally to digital logic devices, and more particularly to devices and methods for configuring random access memory (“RAM”) to function as a first-in, first-out (“FIFO”) memory system.

BACKGROUND OF THE INVENTION

FIFO memory systems are used in a wide variety of applications, such as buffering high-speed serial data immediately after it has been parallelized, for temporary storage of a data packet during packet processing, or buffering data going to or coming from a disk. Data values that are sequentially written to a FIFO buffer are read from the FIFO buffer in the same order, namely the first data entered into the FIFO memory system is the first data read from the FIFO memory system.

FIFO buffers are implemented in RAM and the flow of data into and out of RAM is controlled by address counters that track the read and write addresses being used. The address counters coordinate the data flow into and out of RAM to insure that memory is available to accept incoming data to prevent overflowing the RAM, and that data is stored in RAM before a read operation executes.

FIFO memory systems generate status flags, such as FIFO FULL and FIFO EMPTY, which indicate the RAM is full or empty. In other words, these flags indicate whether or not there is sufficient space in RAM for a WRITE to occur or a READ to be performed. The FIFO FULL status flag is used to prevent a WRITE operation to a full FIFO memory buffer. The FIFO EMPTY status flag is used to prevent a READ operation from an empty FIFO memory buffer.

FIFO memory systems can be synchronous or asynchronous. A FIFO memory system in which both the read address counter and the write address counter are clocked by the same clock signal is referred to as a synchronous FIFO memory system. A FIFO memory system in which the read address counter and the write address counter are clocked by different clock signals is referred to as an asynchronous FIFO memory system. Asynchronous FIFO memory systems are extremely useful in digital data systems where different sides of the FIFO memory system are independently clocked, either at different clock rates, or at the same clock rate, but with an unknown phase difference (“skew”).

In both synchronous and asynchronous FIFO systems, the read and write address counters are circular counters that wrap around to an initial address after the last address is accessed. The read and write address counter output signals are either multiplexed to address a single-port random access memory (RAM), or they are separately provided to address different input ports of a multi-port RAM (e.g. a dual-port RAM).

FIFO memory systems have been configured in programmable logic devices (“PLDs”), such as a field-programmable gate arrays (“FPGAs”) and complex programmable logic devices (“CPLDs”). PLDs are semiconductor integrated circuits that have a “fabric” of programmable logic, and other functional portions, such as RAM.

FIFO memory systems have been implemented in PLDs using the fabric of the PLD to provide the FIFO control logic, such as generating the status flags, and providing the write and read addresses of FIFO memory systems. Such FIFO memory systems are described in co-owned U.S. Pat. Nos. 5,898,893 and 6,434,642. These patents are hereby incorporated by reference in their entirety for all purposes. The logic for operating the FIFO memory system is typically developed in configurable logic blocks (“CLBs”) surrounding an embedded block of RAM (“BRAM”), and the embedded BRAM is operated as a FIFO buffer. In alternative designs, distributed memory is used in a FIFO memory system. However, in either instance it is often desirable to have CLBs available to perform other logic functions. Additional information regarding configuring FIFO memory systems in FPGAs is available in Application Note XAPP131, available from XILINX, INC., of San Jose, Calif.

Programming CLBs to provide the logic functions of a FIFO memory system can be challenging in certain applications, particularly generating status flags in asynchronous applications. Therefore there is a need for an improved FIFO memory system.

SUMMARY OF THE INVENTION

The present invention includes a FIFO having almost empty and/or almost full indications.

One embodiment of the present invention includes a buffer memory status detection circuit having a comparator with a comparator output signal that is asserted when the sum of a first address pointer of a FIFO memory array plus a first offset equals the second address pointer. Binary logic provides a binary output (i.e. “0” or “1”) in a first clock domain to two synchronization registers in series that convert the output to a second clock domain. An optional pipeline register improves timing of the output in the second clock domain, and is particularly desirable for use with high-speed clocks.

Another embodiment of the present invention includes a system for determining a substantially empty condition (almost empty) in a queue such as a first-in-first-out (FIFO). The SYSTEM includes: a comparator having a comparator output that is asserted when a write pointer of the FIFO equals a read pointer of the FIFO plus a predetermined offset; and a state machine coupled to the comparator having: a first state indicating the write pointer is less than the read pointer plus the predetermined offset, wherein the substantially empty condition is true; a second state indicating the write pointer equals the read pointer, wherein the substantially empty condition is true; a third state indicating the write pointer is greater than the read pointer plus the predetermined offset, wherein the substantially empty condition is false; a first transition from the second state to the first state when a read operation occurs; and a second transition from the second state to the third state when a write operation occurs.

Another embodiment of the present invention includes a system for determining a substantially full condition (almost full) a FIFO. The FIFO includes a comparator having a comparator output that is asserted when a write pointer equals a read pointer plus a predetermined offset; and a state machine coupled to the comparator having: a first state indicating the comparator output is deasserted, wherein the substantially full condition is false; a second state indicating the comparator output is asserted, wherein the substantially full condition is true; a third state indicating the comparator output is deasserted, wherein the substantially full condition is true; a first transition from the second state to the first state when a read operation occurs; and a second transition from the second state to the third state when a write operation occurs.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1A is a diagram of a PLD with an embedded FIFO memory system according to an embodiment of the invention.

FIG. 1B is a diagram of the PLD of FIG. 1A showing additional details of the embedded FIFO memory system.

FIG. 2A is a block diagram of a portion of a FIFO memory system.

FIG. 2B is a logic diagram of the block diagram shown in FIG. 2A.

FIG. 3A is a circuit diagram of an ALMOST EMPTY detection circuit.

FIG. 3B is a state diagram of an ALMOST EMPTY logic function.

FIG. 4A is a circuit diagram of an ALMOST FULL detection circuit.

FIG. 4B is a state diagram of an ALMOST FULL logic function.

FIG. 5A is a diagram of a circuit for generating an EMPTY flag.

FIG. 5B is a diagram of a circuit for generating a FULL flag.

FIG. 6A is a diagram of a pre-fetch circuit for zero cycle latency.

FIG. 6B is a read cycle timing diagram of a pre-fetch circuit for zero cycle latency.

FIG. 7A is a diagram of a pre-fetch circuit for generating −1 cycle latency.

FIG. 7B is a diagram of a circuit for pre-loading a binary offset to a Gray-code counter.

FIG. 8 is a diagram of a circuit for pre-loading a binary offset to a Gray-code counter.

FIG. 9A is a flow chart of a method of operating an embedded FIFO memory system in a programmable logic device according to an embodiment of the invention.

FIG. 9B is a simplified method of detecting buffer memory status in a FIFO memory system.

FIG. 9C is a simplified flow chart of a method of pre-fetching data in an embedded FIFO memory system.

FIG. 9D is a simplified flow chart of a method for Gray-code counting in a programmable logic device.

DETAILED DESCRIPTION OF THE DRAWINGS

I. An IC with an Embedded FIFO Memory System

Embodiments of the present invention include hardwired FIFO circuitry embedded in an integrated circuit (IC). In an exemplary embodiment the IC further includes a programmable function circuit coupled to the embedded FIFO, where the programmable function circuit may a configurable logic block (CLB), a programmable multi-gigabit transceiver (MGT) or other circuitry having a programmable function.

In the exemplary embodiment, the FIFO further includes full, empty, substantially full, and substantially empty indications. For purposes of ease of illustration and in one example, the buffer addressing, for example BRAM addressing, for the FIFO data is circular, the read pointer (rptr) and write pointer (wptr) are initialized to the same buffer position, and the rptr or wprt are incremented when there is a read or write, respectively, to the FIFO. Further, the substantially full and substantially empty indications are illustrated by almost full and almost empty status flags.

As known to one of ordinary skill in the art the circular buffer may be conceptual and an actual implementation may include a FIFO buffer having a fixed length, e.g., M storage elements, where M is a positive number, so that the buffer entries go from 0 to (M-1). The read pointer and write pointer are modulo M, so that the pointers wrap around. In another embodiment the pointers may be decremented rather than incremented and in a further embodiment the increment/decrement interval may be any integer value.

To continue with the illustrative example, the reads and writes happen asynchronously, hence the rptr and the wptr are incremented independently. Initially the rptr is set (or reset) to be equal to the wptr and this indicates an empty state for the FIFO. Assuming no reads and only writes, the wptr will reach an almost full state when it is at or within a write pointer offset distance of the rptr. The writes can continue, until the wptr equals the rptr, and the FIFO is in the full state. If there is a further write, a write error will be indicated. Continuing from the full state (rptr=wptr) and assuming no writes and only reads, the rptr will reach an almost empty state when it is at or within a read pointer offset distance of the wptr. The reads can continue, until the rptr equals the wptr, and the FIFO is in the empty state. If there is a further read, a read error will be indicated. The normal operation of the FIFO includes both multiple reads and writes and the almost full, full, empty, and almost empty states may occur in one or more combinations.

FIG. 1A is a diagram of an IC such as PLD 10 with an embedded FIFO memory system 12 according to an embodiment of the invention. The embedded FIFO memory system 12 includes a BRAM (which in this embodiment is illustrated as a dual-port RAM, but is alternatively a single-port RAM) 14 and various embedded FIFO logic circuits, such as a write pointer 16, a read pointer 18, and status flag logic 20. Data (not shown), WRITE COUNTER (“wrcount”), WRITE ADDRESS (“waddr”), READ ADDRESS (“raddr”), READ COUNT (“rdcount”), READ CLOCK (“rdclk”), READ ENABLE (“rden” or “ren”), WRITE ERROR (“wrerr”), READ ERROR (“rderr”), ALMOST EMPTY (“aempty”), ALMOST FULL (“afull”), EMPTY, FULL, RESET, WRITE ENABLE (“wren”), WRITE CLOCK (“wrclk”) and similar signals are coupled between the embedded FIFO memory system 12 and fabric portion(s) 22 of the PLD 10. Data is stored in the BRAM 14 in a circular file system.

The embedded FIFO memory system 12 is an asynchronous FIFO memory system, which means that the data values are written to the BRAM 14 using one clock domain (wrclk) and the data values are read from the BRAM 14 using another clock domain (rdclk). The FIFO logic circuits perform the necessary read and write pointer management tasks and generate status flags, such as FULL, ALMOST FULL, ALMOST EMPTY, and EMPTY. The write pointer and read pointer are fully synchronous within their respective clock domains, but the read clock and the write clock are asynchronous to each other.

In a specific embodiment, the maximum depth of the FIFO memory system is programmable from 512 entries to 2046 entries. When the read pointer equals the write pointer, either the EMPTY flag or the FULL flag will be generated, depending on the direction the pointer is moving, as is described in further detail below in section II. Basically, if the ALMOST EMPTY condition has been and continues to be asserted, then the FIFO memory buffer will be empty when subsequently the read and write pointers are equal. If the ALMOST FULL condition has been and continues to be asserted, then the FIFO memory buffer will be full when subsequently the read and write pointers are equal.

A RESET signal resets all flops and initializes the FIFO status flags after power-up (power on). The RESET signal may be asynchronous or synchronous. The RESET signal is typically kept HIGH for a sufficient number of read clock and write clock cycles to ensure that all internal states are reset to the correct values. When RESET is asserted HIGH, EMPTY and ALMOST EMPTY status flags are set to “1” and FULL and ALMOST FULL status flags are set to “0”.

If enabled, the read pointer increments on every read clock cycle. When the read pointer reaches a selected offset, an ALMOST EMPTY flag will be generated. For example, if the selected offset is ten, the ALMOST EMPTY flag will be generated when the read pointer is equal to or within ten addresses of the write pointer in the FIFO memory array. If the read pointer address reaches (i.e. increments until it equals) the write pointer address, the EMPTY flag will be generated. If there is another read then the read pointer will freeze and a read error flag is generated and sent to the fabric 22 and/or off-chip (i.e. to a circuit/IC external to the PLD 10). An error routine may be executed which may include resetting the read pointer to the write pointer.

The write pointer operates in a similar way as the read pointer. If enabled, the write pointer advances one address on every write clock cycle. When the write pointer reaches a selected offset, an ALMOST FULL flag will be generated. The selected offset for the write pointer does not have to equal the selected offset for the read pointer. In addition the write pointer offset and read pointer offset are integer numbers. In an exemplary embodiment of the present invention the write pointer offset is a positive number and the read pointer offset is a positive number.

When the write pointer reaches the read pointer, the write pointer will stop (“freeze”). Further attempts to write data to the FIFO memory will trigger a WRITE ERROR signal (flag). The WRITE ERROR flag is sent to a data transmitting device, which could be a portion of the fabric of the PLD or an external data transmitting device, to prevent writing to a full BRAM 14. An error routine may be executed which may include resetting the write pointer to the read pointer.

The write pointer is in the WRITE CLOCK domain and the read pointer is in the READ CLOCK domain. Reading data from the BRAM 14 is done on the rising READ CLOCK signal when READ ENABLE is valid, as long as the BRAM 14 is not empty. If the READ ENABLE is still asserted when the BRAM 14 is empty, the read pointer will be frozen and a READ ERROR signal will be generated. Similarly, writing data to the BRAM 14 is done on the rising edge of the WRITE CLOCK signal when WRITE ENABLE is valid, as long as the BRAM 14 is not full. If the WRITE ENABLE is still asserted when the BRAM 14 is full, the write pointer will be frozen so that the data in the FIFO queue will not be corrupted, and then a WRITE ERROR signal will be generated.

In a specific embodiment, the FIFO memory system 12 is configured in a variety of organizations, for example: 4 k entries by 4 bits, 2 k entries by 9 bits, 1 k entries by 18 bits, or 512 entries by 36 bits. These configurations are exemplary only to illustrate the flexibility of FIFO systems according to some embodiments of the invention. The organizations vary according to the size and/or type of the BRAM used, and in some embodiments, BRAMs are concatenated or otherwise combined to obtain other organizations (i.e. widths and depths).

Some embodiments of the invention can be described with state diagrams and use binary logic circuits to determine the status of the FIFO memory buffer (e.g. BRAM) before converting the binary code to Gray code for the status flag, as discussed in further detail in section IV, below.

FIG. 1B is a diagram of the PLD 10 of FIG. 1A showing additional details of the embedded FIFO memory system. The BRAM array 14 has two ports, A and B (i.e. it is a two-port BRAM array). The same BRAM array can be used as part of a FIFO memory system, or as a conventional BRAM in the PLD 10. In a conventional application, input data (“DIN”) 30 is written to the Write Data Latch 32, and then to the BRAM array 14. The input address of port B (ADDRINB(n)) 34 is provided from the fabric (see FIG. 1A, ref. num. 22) or off-chip to the Write Address Latch 36 through the multiplexer 38.

The multiplexer 38 selects between using the conventional write address 34 and the write address 42 provided by the Write Counter 40. In other words, the multiplexer selects between using the BRAM array 14 in a conventional memory fashion, or as a FIFO memory array in an embedded FIFO memory system.

When the BRAM array 14 is used in an embedded FIFO memory system, the multiplexer couples the write address 42 from the Write Counter 40 of the FIFO memory system to the Write Address Latch 36, and allows using the BRAM array 14 in a known manner by coupling the external input address 34 to the Write Address Latch 36. The Read Counter 44, multiplexer 46, and Read Address Latch 48 operate in a similar fashion.

The FIFO memory system status flags 50 are shown as going off chip, but are routed to logic blocks (not shown) of the PLD 10 in alternative embodiments.

FIG. 2A is a block diagram of a portion of a FIFO memory system according to an embodiment of the present invention. ALMOST EMPTY logic 70, EMPTY logic 72, FULL logic 74, ALMOST FULL logic 76, and their associated outputs 80, 82, 84, 86 are shown. The ALMOST EMPTY comparator 88, FULL/EMPTY comparator 90, and ALMOST FULL comparator 92 receive input in both the read clock domain and in the write clock domain. The ALMOST EMPTY comparator 88 receives input 94 from the binary-to-Gray code generator 120 operating in the READ CLOCK domain, and receives input 98 from another binary-to-Gray counter 126 operating in the WRITE CLOCK domain. Similarly, the ALMOST FULL comparator 92 receives input 102 in the WRITE CLOCK domain, and input 104 in the READ CLOCK domain. The ALMOST EMPTY output (ALMOST EMPTY status flag) 80 and EMPTY output (EMPTY status flag) 82 are in the READ CLOCK domain, and the ALMOST FULL output (ALMOST FULL status flag) 86 and FULL output (FULL status flag) 84 are in the WRITE CLOCK domain. DATA IN 106 is written to the BRAM 14 in the WRITE CLOCK domain, and DATA OUT 108 is read from the BRAM 14 in the READ CLOCK domain.

The block includes four binary-to-Gray code generators 120, 122, 124, 126. Using Gray code for generating status flags of FIFO memory systems is known; however, in conventional FIFO memory systems, offsets for programming the ALMOST EMPTY and ALMOST FULL conditions are added as Gray code to the read and write counters before comparing.

The early warning flags, i.e., almost full and almost empty, are based on detecting a specified arithmetic difference between the two addresses for read and write. Comparing binary addresses would inevitably create decoding spikes and glitches, since one clock edge often changes multiple address bits, and these changes can affect the identity comparator at slightly different times. The well-known solution to this problem is to use Gray-coded address counters; however, arithmetic operation on Gray-coded addresses is extremely complex. Thus, in one embodiment of the present invention, the required offset (positive or negative) is added from the binary address value of either the write or the read address, and the result is then converted into a Gray code. This offset Gray-coded value is then identity-compared with the Gray-coded value of the other address. The output of this comparator is active whenever the read and write addresses differ by the offset.

In the block diagram of FIG. 2A, the ALMOST EMPTY (“AEMPTY—OFFSET”) offset 110, for example, is added by adder 112 as a binary number (i.e. in the binary domain), and then converted to Gray code in the binary-to-Gray code generator 120 before being compared 88 to the output 98 of the WRITE COUNTER 128, which has also been converted to Gray code by another binary-to-Gray code generator 126. Detailed discussion of the complementary paths is omitted, as they would be familiar to one of ordinary skill in the art.

FIG. 2B is a logic diagram of the block diagram shown in FIG. 2A. As discussed in relation to FIG. 2A, the READ ADDER 140 receives a binary ALMOST EMPTY offset 110, which is added to the binary output 142 from the incrementor 144 in the READ COUNTER 146 before being converted to Gray code in the binary-to-Gray converter 120. The comparator 88 is 12-bit Gray code comparator that uses static gates. The read pointer generation is done using the incrementor 144 and a flip-flop 148. The output 150 of the flip-flop 148 is fed back to the input of the incrementor 144. The control signals to the incrementor are FULL, EMPTY, READ ENABLE, WRITE ENABLE, and CLOCK. The write pointer is generated in a similar fashion, and a detailed description is omitted. The ALMOST EMPTY 80, EMPTY 82, FULL 84, and ALMOST FULL 86 outputs and synchronization logic circuits are discussed in further detail below.

FIGS. 3A and 3B generally show buffer memory status detection circuits. These circuits are embedded in a programmable logic device, such as an FPGA or CLD. These detection circuits detect when a first address pointer of an embedded FIFO memory array equals the sum of a second address pointer plus a selected offset, and also convert the output signal (FIFO status flag) to the proper clock domain.

FIG. 3A is a circuit diagram of an ALMOST EMPTY detection circuit 170 (similar to circuit 70 in FIG. 2B). Conventional Gray-code ALMOST EMPTY (or ALMOST FULL) circuits are normally required to implement a “greater than” function, which consumes a considerable amount of silicon area on the chip. An embodiment of the present invention uses a state machine to monitor the write and read pointer movement.

When RESET 172 is asserted high (resetting the wtpr=rptr), the ALMOST EMPTY output (status flag) 80 is set to “1” by asynchronously setting the first flip-flop 176 to “1”. The first flip-flop 176 and second flip-flop 178 (flip-flops are also referred to as flops herein) are cross-coupled through inverters 177, 179. When the output q of the first flop 176 is “1”, the inverter 179 provides a “0” to the data port d of the second flop 178. The output q of the second flop 178 is coupled to the data port d of the first flop 176 through the inverter 177. Thus the “0” output from the second flop 178 is converted to a “1” at the data input port of the first flop 176.

If, for example, there are a series of writes with no reads, then wprt will increase until wprt=rptr+aempty offset, i.e., wprt=off—rtpr, where aempty offset is a user selected positive number. When the output of identity comparator 80, e.g., signal 174 (wptr=off—rptr), is asserted, flop 176 is asynchronously set to “1” via OR gate 175 and flop 178 is asynchronously set to “1”. Output 194 is thus “1” and the inputs to flops 176 and 179 are “0”. Flops 188 and 190 are then set to “1”. If there is another write clock (wrclk 184) with the write enable (wren 186) asserted and wptr>rptr—off, then both the q output 194 of flop 176 and the q output of flop 178 becomes “0”. The d input 179 to flop 178 becomes “1”. As long as wptr>rptr—off, there may then follow a series of write clocks and read clocks. Two read clocks will propagate the “0” at q 194 through flops 188 and 190 to set ae3=“0”. After another read clock (with wptr>rptr—off), the aempty status flag is “0”. Flop 192 is an optional pipeline register that will be discussed below. The two read clock cycles synchronized AEMPTY back to the write clock domain.

In the above example, if there is a read clock after off—rptr=wptr, i.e., wptr<off—rptr, and read enable (rden) is asserted, then output q 194 of flop 194 remains “1”and the aempty flag remains asserted.

The first two flops 188, 190 (also known as synchronization registers) in the output path are both clocked by the READ CLOCK signal (rdclk) 180. The input ae1 to the first flop 188 can be across clock domains; however, the second flop 190 insures that ae2 is in the READ CLOCK domain. The optional third flop 192 in the output path is a pipeline register that improves the output timing of the ALMOST EMPTY (aempty) status flag 80 because it is controlled only by the READ CLOCK signal 180. The pipeline register 192 is especially desirable when either or both of the WRITE CLOCK and READ CLOCK are high-frequency clocks.

FIG. 3B is a state diagram 199 of an ALMOST EMPTY logic function, such as the ALMOST EMPTY logic function shown in FIG. 3A. There are three states in this state machine: 1) the under state has wptr not equal to off—rptr, i.e., ptr—eq=0; in this under case wptr<off—rptr (i.e., the write pointer is less than the read pointer+aempty offset); 2) the equal state has wptr=off—rptr (i.e., ptr—eq=1); and 3) the over state has wptr not equal to off—rptr, i.e., ptr—eq=0; in this over case wptr>off—rptr.

A RESET signal places the write pointer and read pointer to the same memory address, which puts the state machine into the under state 202 because of the read pointer offset (i.e., wptr<off—rptr). Initially, the ALMOST EMPTY flag is set. As write operations occur with ptr—eq=0 205, the FIFO memory array fills up. As read operations occur with ptr—eq=0 205, the FIFO memory array empties. When ptr—eq=1 207 (see FIG. 3A, ref. num. 174), the state machine transitions into the equal state 200, which keeps the ALMOST EMPTY flag set. The arrows are combinational (independent of clock domain). The states are clocked.

A write operation 206 from the equal state 200 transitions the state machine to the over state 208 (wprt>off—rptr) and resets the AMOST EMPTY flag. Continued write operations 209 keep the state in the over state 208 until sufficient read operations have occurred to attain ptr—eq=1 210 (i.e., off—rptr=wptr), which transitions the state machine to the equal state 200 and sets the ALMOST EMPTY status flag (asserted) when the state machine is in the equal state 200. If an additional read operation occurs, ptr—eq does not equal “1”, and the state machine transitions 204 to the under state 202 from the equal state 200 and the ALMOST EMPTY flag remains set.

When the system is either in the under state 202 or equal state 200, the ALMOST EMPTY flag is set (i.e., if wptr =<rptr+aempty offset, then ALMOST EMPTY=1). In the over state, the ALMOST EMPTY flag is reset (i.e., if wptr>rptr+aempty offset, then ALMOST EMPTY=0).

FIG. 4A is a circuit diagram of an ALMOST FULL detection circuit 220 (similar to circuit 76 in FIG. 2B). The ALMOST FULL detection circuit 220 works similarly to the ALMOST EMPTY detection circuit 170 shown in FIG. 3A, with some differences. The RESET signal 172 is provided to an OR gate 221, as is the signal 224 when the offset write pointer (i.e., off—wptr=wprt+afull offset) equals the read pointer (rptr), where afull offset is a positive number. The ALMOST FULL status flag (afull) 86 is set to “0” at reset, instead of to “1”, as is the ALMOST EMPTY status flag 80 of FIG. 3A. The ALMOST FULL detection circuit 220 also has two flops 226, 228, cross-coupled thorough inverters 227, 229.

The “lower” flop 228 is clocked by the READ CLOCK signal 234 when READ ENABLE 236 is asserted. The “upper” flop 226 is clocked by the WRITE CLOCK signal (wrclk) 230, as are the synchronization registers 238, 240, and pipeline register 242. When the offset write pointer equals the read pointer 224 (i.e. when the ALMOST FULL condition is met), the lower 228 and upper 226 flops are set, which produces a “1” on the output (af1) 244 of the lower flop 228. The first 238 and second 240 synchronization registers are set when the output 244 of the lower flop 228 is asserted and af3=1 and after a write clock, afull flag is set. Further discussion of circuit 220 is omitted as the operation is similar to the description of the almost empty circuit.

FIG. 4B is a state diagram 250 of an ALMOST FULL logic function. The state diagram operates in a similar fashion to the state diagram 199 shown in FIG. 3B except that ptr—eq=1 means that off—wprt=rptr, ptr—eq=0 means that off—wprt is not equal to rptr and the almost full status flag is reset in the under state 263 (afull=0) and set in the equal 253 and over 261 states (afull=1).

At reset the state machine 250 starts in the under state 263. Reads and writes are made to the FIFO until there are sufficient writes to have prt—eq=1 (i.e., off—wptr=rptr, see 224 of FIG. 4A). Once the equal state 253 is reached, the equal state 253 and the over state 261 (reached from the equal state 253 by a further write operation 258) and will keep the ALMOST FULL signal asserted afull=1 when wptr+afull offset >=rptr) until the a read operation transitions the state machine from the equal state 253 to the under state 263, i.e., when rprt<off—wptr. In the under state 263 the ALMOST FULL output 86 will be deasserted (after a three read clock cycle delay). The operation of the state diagram 250 is understood by those of skill in the art with reference to the description of FIG. 3B, hence a further description of the operation of the state diagram 250 is omitted. Hence, if ALMOST FULL is asserted, and the read pointer equals the write pointer, then we know that the FIFO memory buffer is full.

FIG. 5A is a diagram of a circuit 280 for generating an EMPTY flag 82 (similar to circuit 72 in FIG. 2B). The EMPTY flag 82 is generated if the read pointer equals the write pointer 282 (i.e. the FULL/EMPTY comparator (see FIG. 2A, ref. num. 90) is asserted), the ALMOST EMPTY signal status flag 80 is asserted, and the DATA VALID bit (vld bit) 286 is not set. When the DATA VALID bit is zero, it indicates that data in output register is not valid, and the EMPTY flag is set (see also, FIGS. 7A, 7B, and related description). When DATA VALID is “1”, it indicates the data in the output register is valid, and the EMPTY flag is not set, even though the BRAM array may be empty.

In some embodiments of FIFO memory systems, latency is reduced by sending the first written data directly to an output register, so that the data is available to be read on the first read cycle. In other embodiments, the first written data is sent to the output of an output register, so that the data is available to be read before the first read cycle. In other words, the VALID BIT (vld bit) 286 monitors whether valid data is available in the output register. In some modes of operation, the read cycles might keep the output register empty, so that successive write cycles (words) go directly to the output buffer. In such an instance, data is available to be read, even though the FIFO memory array is empty (WRITE POINTER=READ POINTER 282 and ALMOST EMPTY status flag 80 is asserted). When the FIFO memory array is empty, and the output data register is not valid, the EMPTY status flag 82 is generated by the EMPTY LOGIC 291.

Two stages of asynchronously set registers 288, 290 are used to synchronize the EMPTY flag 82 back to the READ CLOCK domain by gating the registers 288, 290 with the READ CLOCK signal 180 and setting the registers 288, 290 with the output 292 from the AND gate 294. These registers also filter out glitches that might occur on the EMPTY status flag (empty) output 82, as discussed above in relation to FIGS. 3A and 4A.

Using the ALMOST EMPTY signal 80 allows the circuit 280 to differentiate between FULL and EMPTY conditions of the FIFO memory array. The write pointer equals the read pointer in both conditions, but if the ALMOST EMPTY signal has been set, and the read and write pointers become equal, then the FIFO memory array is known to be empty, not full. Similarly, if the ALMOST FULL signal is set and then the read and write pointers become equal, then the FIFO memory array is known to be full.

FIG. 5B is a diagram of a circuit 300 for generating a FULL status flag 84 (similar to circuit 74 in FIG. 2B). It is similar to the circuit 280 for generating an EMPTY status flag 82 shown in FIG. 5A, except the asynchronously set registers 302, 304 are gated by the WRITE CLOCK signal 184 and a pipeline register 306 is used instead of the EMPTY logic 291 shown in FIG. 5A. Similarly, the ALMOST FULL status flag 86 and output 282 from the FULL/EMPTY comparator (see FIG. 2A, ref. num. 90) are provided to the AND gate 301. The pipeline register 306 introduces one WRITE CLOCK 184 latency for both setting and resetting to improve timing of the FULL status flag 84 to the WRITE CLOCK.

III. A Reduced Cycle Latency FIFO in a PLD

FIG. 6A is a diagram of a pre-fetch circuit 320 for zero cycle latency. The first word written to an empty FIFO memory array 14 (e.g. a BRAM of a PLD) is pre-fetched to the input 322 of the output register 324 after three transitions of the READ CLOCK signal (two sync cycles plus one pre-fetch cycle). READ ENABLE (rden) 236 does not have to be asserted for this to occur if the first word detection circuit 326 generates a data valid 286 signal (see also, FIG. 5A, ref. num. 286). Thus, the first word is read from the register 324 as soon as READ ENABLE 236 is asserted. However, reading the first word from the FIFO memory requires READ ENABLE 236 to be high and a rising READ CLOCK signal. These timing conditions are merely exemplary.

FIG. 6B is a read cycle timing diagram 330 of a pre-fetch circuit for zero cycle latency. The first word W1 is present in data out 322 essentially as soon as READ ENABLE 236 goes high. For example, referring to FIG. 6A, if only one write operation occurs, and a subsequent read operation occurs, both the memory 14 and the output register 324 are empty, and the data valid output 286 is not set. If one write operation occurs and no read operation occurs, the data (word) in the write operation goes to the output register 324 and the data valid output 286 is set, indicating that a word is available to be read, even though the memory 14 is empty.

FIG. 7A is a diagram of a pre-fetch circuit 340 for generating −1 cycle latency, also known as first-word fall through (“FWFT”). FWFT mode allows the first word written to an empty FIFO memory array 14 (e.g. BRAM of a PLD) to be pre-fetched from the output 322 of the FIFO memory array 14 to the output 342 of an output register 324′ after four transitions of the READ CLOCK signal (see FIG. 7B, rdclk 180) (i.e. two sync cycles and two pre-fetch cycles). READ ENABLE 236 does not have to be asserted for the first word to be read in FWFT mode; however, reading the next word from the FIFO memory array (assuming additional words have been written in the intervening time) does require a READ ENABLE signal for access. A FIFO memory system operating in FWFT mode produces a −1 cycle latency. In this embodiment, a DATA VALID output indicates that the register output 342 is valid.

FIG. 7B is a first-word fall through timing diagram 350. The first word W1 is available on data out (do) before READ ENABLE 236 is asserted. When READ ENABLE 236 goes high, the second word W2 is read on the associated rising edge of the READ CLOCK signal 180.

IV. A Method and System for Gray-Code Counting in a PLD

A 12-bit binary-to-Gray (“BTG” or “B2G”) code converter gate level implementation (not separately shown) provides a first binary input and a second binary input to an exclusive NOR gate. The first input stream is shifted one place to the “right” (e.g. for a four-bit system, the first input data word 1111 becomes 0111; in other words, the most significant bit becomes “0” in the shifted binary input). The exclusive NOR gate converts the binary input and shifted binary input to Gray code. Performing the logic operation(s) in binary avoids generating the false outputs that can arise if the comparison is made in the Gray-code domain, after the binary inputs have been converted to Gray code, because the Gray code string has only one edge transition. Converting the binary inputs to Gray code before adding can produce intermediate transitions that cause glitches on the output Gray code.

FIG. 8 is a diagram of a circuit for pre-loading a binary offset to a Gray-code counter 360. A user-selectable binary offset value 362 and an n-bit binary count 364 are provided to a binary adder 366. The n-bit binary output 368 of the binary adder 366 is provided to a binary-to-Gray converter 770, which provides a Gray-code output to a multiplexer 374.

An OR gate 375 provides a select signal to the multiplexer 374. When the select signal is “1”, the “1” port of the multiplexer (i.e. the output 372 of the binary-to-Gray converter 370) is coupled to the register 376. The select signal is “1” when either the reset signal or pointer increment (ptr—inc) signal is “1”. A read pointer increment signal, for example, is generated when the READ CLOCK signal transitions and READ ENABLE is asserted. The Gray-code output of the binary-to-Gray converter 370 is provided through the multiplexer 374 to the register 376 each time the read pointer is incremented. The register 376 provides a Gray-code output 377 to the almost empty comparator (see FIG. 2A, ref. num. 88), for example. If the select signal from the OR gate 375 to the multiplexer 374 is “0”, the output 377 of the register 376 is fed back through the multiplexer 374 to the register 376 (i.e. the value in the register does not change). Similarly, the write pointer increment signal is generated when the WRITE CLOCK signal transitions and WRITE ENABLE is asserted.

On reset, the binary counter 380 is set to “0”, and the output 364 of the binary counter 380 is added 366 to the offset value 362, which is also in binary form. The sum 368 of the output 364 of the binary counter 380 and the binary offset value 362 is provided to the binary-to-Gray converter 370. At reset, the output 372 of the binary-to-Gray converter 370 represents the Gray-code value of the offset value, since the binary counter 380 is at zero.

The Gray-code value of the offset is typically not all “1's” or all “O's”, thus simply resetting the binary-to-Gray code converter would not provide the desired selectable offset value, which can be a selected number of memory addresses, for example. Adding the offset value to the counter output in binary form is a quick, robust way to provide user-selectable offset values in Gray code from the register 376. Thus, the comparator (see, e.g., FIG. 2A, ref. num. 88) receives the user-selectable offset value as Gray code (i.e. the register 376 is loaded with the offset value in Gray code), and compares this value with the Gray code value of the write counter (see, e.g. FIG. 2A, ref. num. 98) to determine whether the FIFO memory buffer is almost empty.

As read operations occur (and while reset=0), the pointer increment signal (ptr—inc) increments the binary counter 380, and the output value 364 from the binary counter 380 is added 366 to the offset value 362, converted into Gray code, and provided to the register 376 through the multiplexer 374. Thus, the content of the register 376 will be updated.

A similar circuit is implemented for the write portions of the FIFO memory system (ref. generally, FIGS. 2A, 2B).

V. Exemplary Methods

FIG. 9A is a flow chart of a method 900 of operating an embedded FIFO memory system in a programmable logic device according to an embodiment of the invention. A first pointer address from a FIFO memory array embedded in the programmable logic device is read in a first clock domain (step 902). A first binary offset value is added to the first pointer address to produce a first sum (step 904). The first sum is converted to a first Gray code value (step 906), and a second pointer address is read from the FIFO memory array in a second clock domain (step 908). The second pointer address is converted to a second Gray code value (step 910), and the first Gray code value is compared to the second Gray code value (decision 912). If the first Gray code value equals the second Gray code value, a first comparator output is asserted (step 914). The first comparator output is coupled to a first logic block (step 916), and is converted from the first clock domain to a first status flag in the second clock domain (step 918).

In further embodiments, the first pointer address is converted to a third Gray code value (step 920), and the second Gray code value is compared to the third Gray code value (decision 922). A second comparator output is asserted if the second Gray code value equals the third Gray code value (step 924). The second comparator output is supplied to both a second logic block and to a third logic block (step 926), such as an EMPTY logic block and a FULL logic block.

If the first comparator output is asserted (decision 927), a second status flag is generated by the second logic block in the second clock domain (step 928). For example, if the first comparator output drives ALMOST EMPTY logic and the second comparator output is asserted, which indicates that read pointer position equals the write pointer position in the BRAM, for example, the EMPTY logic block generates an EMPTY status flag.

In another or further embodiment, a second binary offset value is added to the second pointer address to produce a second sum (step 930). The second sum is converted to a fourth Gray code value (step 932), and the fourth Gray code value is compared to the third Gray code value (decision 934). A third comparator output is asserted if the fourth Gray code value equals the second Gray code value (step 936). The third comparator output is coupled to a fourth logic block (step 938) that converts the first comparator output from the second clock domain to a fourth status flag in the first clock domain (step 940). In an alternative embodiment, if the third comparator output is asserted (decision 941), a third status flag is generated by the third logic block in the first clock domain (step 942). The order in which the steps are described is not limiting, and many steps can be performed essentially concurrently or in alternative sequences.

FIG. 9B is a simplified method 950 of detecting buffer memory status in a FIFO memory system. A comparator output is asserted when a sum of a first pointer value and a selected pointer offset value equals a second pointer value in a first clock domain (step 952). A binary output value is established when the comparator output is asserted (step 954). The binary output value, which is generally in the first clock domain but may have additional transitions (glitches), is provided to a first synchronization register set by the binary output and clocked in a second clock domain (step 956). The binary output value from the first synchronization register is provided to a second synchronization register that is also set by the binary output value and clocked in the second clock domain (step 958). The second synchronization register provides the binary output value in the second clock domain (step 960).

In a further embodiment, the binary output value from the second synchronization register is provided to a pipeline register clocked in the second clock domain and the pipeline register outputs a FIFO buffer memory status flag, such as an ALMOST EMPTY or ALMOST FULL FIFO memory buffer status flag, in the second clock domain (step 962).

FIG. 9C is a simplified flow chart of a method 970 of pre-fetching data in an embedded FIFO memory system. A first word is written to an empty FIFO memory array embedded in a programmable logic device (step 972) and provided to an output register of the FIFO memory system (step 974). The first word in the output register is detected (step 976), and a data valid signal is generated (step 977). In one embodiment, the first word is provided to an output of the output register, and is output before a read enable signal is asserted. In an alternative embodiment, the step of reading the first word occurs when a read enable signal is asserted.

In a further embodiment, the data valid signal is coupled to an EMPTY detection circuit of the embedded FIFO memory system (step 980) and an EMPTY status flag is suppressed (step 982) if the data valid signal is asserted, allowing the word to be read from the output register (or the output register output) (step 983), which de-asserts the data valid signal (step 984) if no new data has been written to the output register.

In another embodiment, after the first word has been read, a second word is written to the empty FIFO memory array and provided to the output register. This second word is detected and a second data valid signal is generated, thus allowing reading the second word from the output register. For example, if the read clock is faster than the write clock, multiple words may fall through to the output register and be read from the output register while the FIFO memory array remains empty.

FIG. 9D is a simplified flow chart of a method 990 for Gray-code counting in a programmable logic device. FIG. 8 illustrates an example of a circuit suitable for performing this method. A selected pointer offset binary value is added to a pointer count binary value to produce a binary sum (step 991). The binary sum is converted to a Gray-code value (step 992), and the Gray-code value is coupled to a first port of a multiplexer (step 993). The multiplexer output is coupled to a register input (step 994), and the register output is coupled (fed back) to a second port of the multiplexer (step 996). The pointer count binary value is incremented in response to a pointer increment signal to create an incremented Gray-code value (step 997), and the incremented Gray-code value is coupled through the multiplexer when the pointer increment signal is asserted (step 998), and the register output is coupled through the multiplexer when the pointer increment signal is not asserted (step 999).

In the foregoing specification, the invention has been described with reference to specific exemplary embodiments thereof. Other embodiments will be apparent to those of ordinary skill in the art. For example, specific embodiments have been discussed with reference to PLDs, such as FPGAs and CPLDs; however, embodiments of the invention can be implemented in other types of integrated circuits such as application specific integrated circuits (ASICs). Thus, it is evident that various modifications and changes may be made thereunto without departing from the broader spirit and scope of the invention as set forth in the appended claims and their full scope of equivalents.

Claims (30)

1. A buffer memory status detection circuit comprising:

a comparator output signal asserted when a sum of a first address pointer value of an embedded first-in, first-out (“FIFO”) memory array plus a first offset pointer value equals a second address pointer value of the embedded FIFO memory array;

a first flip-flop set when the comparator output signal is asserted, and having a first data input port, a first data output port, and a first clock port coupled to a first clock signal in a first clock domain;

a second flip-flop set when the comparator output signal is asserted and reset when the reset signal is asserted, and having a second data input port, a second data output port, and a second clock port coupled to a second clock signal in a second clock domain;

a first inverter coupling the second data output to the first data input; and

a second inverter coupling the first data output to the second data input.

a first synchronization register having a first synchronization register input port coupled to one of the first data output port and the second data output port and having a first synchronization register output port, a first synchronization set port, and a first synchronization clock port; and

a second synchronization register having a second synchronization register input port coupled to the first synchronization register output port and having a second synchronization output port, a second synchronization set port and a second synchronization clock port, wherein the first synchronization register input port is coupled to the first synchronization set port and to the second synchronization set port, and the first synchronization register clock port and second synchronization register clock port are coupled to a common clock signal.

4. The buffer memory status detection circuit of claim 3 wherein the first synchronization data input port is coupled to the first data output port and the common clock signal is the second clock signal.

5. The buffer memory status detection circuit of claim 3 wherein the first synchronization data input port is coupled to the second data output port and the common clock signal is the first clock signal.

a pipeline register having a pipeline register data input port, a pipeline register data output port, and a pipeline register clock port, wherein the pipeline register clock port is clocked by the common clock signal.

7. The buffer memory status detection circuit of claim 1 further comprising a binary logic gate coupled to the comparator output signal and to a reset signal.

8. A buffer memory status detection circuit comprising:

an OR gate coupled to a comparator output signal asserted when a sum of a read address pointer and a selected read pointer offset equals a write address pointer of an embedded FIFO memory array and to a reset signal, and generating an output signal;

a first flip-flop set when the output signal is asserted, and having a first data input port, a first data output port, and a first clock port coupled to a write clock signal;

a second flip-flop set when the comparator output signal is asserted and reset when the reset signal is asserted, and having a second data input port, a second data output port, and a second clock port coupled to a read clock signal;

a first inverter coupling the second data output to the first data input;

a second inverter coupling the first data output to the second data input;

a first synchronization register having a first synchronization register input port coupled to the first data output port and having a first synchronization register output port, a first synchronization set port, and a first synchronization clock port; and

a second synchronization register having a second synchronization register input port coupled to the first synchronization register output port and having a second synchronization output port, a second synchronization set port and a second synchronization clock port, wherein the first synchronization register input port is coupled to the first synchronization set port and to the second synchronization set port, and the first synchronization register clock port and second synchronization register clock port are coupled to the read clock signal.

an OR gate coupled to a comparator output signal asserted when a sum of a write address pointer and a selected write pointer offset equals a read address pointer of an embedded FIFO memory array and to a reset signal, and generating an output signal;

a first flip-flop set when the output signal is asserted, and having a first data input port, a first data output port, and a first clock port coupled to a write clock signal;

a second flip-flop set when the comparator output signal is asserted and reset when the reset signal is asserted, and having a second data input port, a second data output port, and a second clock port coupled to a read clock signal;

a first inverter coupling the second data output to the first data input;

a second inverter coupling the first data output to the second data input;

a first synchronization register having a first synchronization register input port coupled to the second data output port and having a first synchronization register output port, a first synchronization set port, and a first synchronization clock port; and

a second synchronization register having a second synchronization register input port coupled to the first synchronization register output port and having a second synchronization output port, a second synchronization set port and a second synchronization clock port, wherein the first synchronization register input port is coupled to the first synchronization set port and to the second synchronization set port, and the first synchronization register clock port and second synchronization register clock port are coupled to the write clock signal.

12. A method of detecting buffer memory status in a first-in, first-out (“FIFO”) memory system comprising:

asserting a comparator output when a sum of a first pointer value and a selected pointer offset value equals a second pointer value in a first clock domain;

establishing a binary output value when the comparator output is asserted;

providing the binary output value to a first synchronization register set by the binary output and clocked in a second clock domain;

providing the binary output value from the first synchronization register to a second synchronization register, the second synchronization register being set by the binary output value and clocked in the second clock domain; and

providing the binary output value from the second synchronization register in the second clock domain.

13. The method of claim 12 further comprising steps of:

providing the binary output value from the second synchronization register to a pipeline register clocked in the second clock domain; and

outputting a FIFO buffer memory status flag in the second clock domain.

14. A method of detecting buffer memory status in a first-in, first-out (“FIFO”) memory system comprising:

performing N write operations to an embedded FIFO memory array, where N is a first integer value;

performing M read operations from the embedded FIFO memory array, where M is a second integer value; and

asserting a FIFO status flag when a difference between M and N equals X, X being a selected offset value.

15. The method of claim 14 wherein the write operations occur in a write clock domain and the read operations occur in a read clock domain.

16. The method of claim 14 wherein X is a read pointer offset and the FIFO status flag is an ALMOST EMPTY status flag in the read clock domain.

17. The method of claim 14 wherein X is a write pointer offset and the FIFO status flag is an ALMOST FULL status flag in the write clock domain.

18. The method of claim 14 further comprising steps, prior to the step of performing N write operations, of

asserting a reset signal; and

setting a read pointer and a write pointer to an address of the embedded FIFO memory array.

19. A buffer memory status detection circuit comprising:

means for coupling a comparator output value to a binary logic circuit in a first clock domain;

means for generating a binary output value in response to the comparator output value; and

means for synchronizing the binary output value to a second clock domain.

20. A buffer memory status detection circuit comprising:

a logic gate having:

a first buffer memory status flag input and

a comparator output input, and producing a logic gate output if a first buffer memory status flag is asserted and a comparator output is asserted, the comparator output being asserted when a write pointer of an embedded first-in, first-out (“FIFO”) memory array equals a read pointer of the embedded FIFO memory array;

a first synchronization register having:

a first data input port,

a first data output port,

a first clock port, and

a first set port, wherein the logic gate output is coupled to the first data input port and the first set port, and the first clock port is coupled to a first clock signal;

a second synchronization register having:

a second data input port,

a second data output port,

a second clock port, and

a second set port, wherein the first data output port is coupled to the second data input port, the logic gate output is coupled to the second set port, and the second clock port is coupled to the first clock signal.

21. The buffer memory status detection circuit of claim 20 wherein the logic gate is an AND gate.

a pipeline register clocked by the first clock signal, a pipeline data input port being coupled to the second data output port and a pipeline data output port providing a FIFO status flag in the first clock domain.

23. The buffer memory status detection circuit of claim 20 wherein the FIFO status flag is an EMPTY status flag and further comprising:

a logic block clocked in the first clock domain and having a logic block data input coupled to the second data output port and a DATA VALID port configured to receive a DATA VALID signal, the EMPTY status flag being suppressed when the DATA VALID signal is asserted.

coupling a comparator output and a FIFO status flag to an AND gate, the comparator output being asserted when a read pointer of an embedded FIFO memory array equals a write pointer of the embedded FIFO memory array, and the FIFO status flag being asserted when a difference between the read pointer and the write pointer equals a selected offset value;

producing a binary output from the AND gate when the comparator output is asserted and the FIFO status flag is asserted; and

synchronizing the binary output to a selected clock domain of the asynchronous FIFO memory system; and

providing a second FIFO status flag in the selected clock domain.

25. The method of claim 24 wherein the second FIFO status flag is an EMPTY status flag in a read clock domain.

26. The method of claim 24 wherein the second FIFO status flag is a FULL status flag in a Write clock domain.

27. A system for determining a substantially empty condition in a first-in-first-out (FIFO) comprising:

a comparator having a comparator output that is asserted when a write pointer of the FIFO equals a read pointer of the FIFO plus a predetermined offset; and

a state machine coupled to the comparator comprising:

a first state indicating the write pointer is less than the read pointer plus the predetermined offset, wherein the substantially empty condition is true;

a second state indicating the write pointer equals the read pointer, wherein the substantially empty condition is true;

a third state indicating the write pointer is greater than the read pointer plus the predetermined offset, wherein the substantially empty condition is false;

a first transition from the second state to the first state when a read operation occurs; and

a second transition from the second state to the third state when a write operation occurs.

28. The system of claim 27 wherein the predetermined offset is an integer.

29. A system for determining a substantially full condition in a first-in-first-out (FIFO) comprising:

a comparator having a comparator output that is asserted when a write pointer of the FIFO equals a read pointer of the FIFO plus a predetermined offset; and

a state machine coupled to the comparator comprising:

a first state indicating the comparator output is deasserted, wherein the substantially full condition is false;

a second state indicating the comparator output is asserted, wherein the substantially full condition is true;

a third state indicating the comparator output is deasserted, wherein the substantially full condition is true;

a first transition from the second state to the first state when a read operation occurs; and

a second transition from the second state to the third state when a write operation occurs.

30. The system of claim 27 wherein the predetermined offset is an integer.