Wide-elasticity buffer
Through the multi-column data buffer and channel shifter circuit in the wide elastic buffer system, the skip order set is detected and processed, which solves the data transmission problem caused by the frequency difference of clock domain in PCIe devices, and the correct data sequence is achieved Processing and transfer.
Patent Information
- Application Number
- CN202411175266.X
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Priority Date
- 2020-05-19
- Filing Date
- 2021-05-13
- Publication Date
- 2024-12-03
AI Technical Summary
In PCIe devices, due to the frequency differences between clock domains, overflow or underflow problems in data transmission may be caused. It is difficult for the prior art to effectively solve the data sequence changes caused by such frequency differences.
Using a wide elastic buffer system, through multiple columns of data buffers and channel shifter circuits, detect skip sequences, and add or delete skip symbols if necessary to compensate for frequency differences and ensure that data is at different times. Smooth transmission between domains.
It effectively avoids data order changes, ensures the correct sorting and transmission of data between different clock domains, supports skip requests from different protocols, and improves system flexibility and efficiency.
Smart Images

Figure CN119070966A_ABST
Abstract
Description
[0001] This application is a divisional application of invention patent application No. 202180036619.6, with the application date of May 13, 2021, international application number PCT / US2021 / 032223, and entered the Chinese national stage on November 21, 2022, and the invention name is "Wide Elastic Buffer".
[0002] Priority application
[0003] This application claims priority to U.S. patent application serial number 16 / 877,695 filed on May 19, 2020, the contents of which are incorporated herein by reference in their entirety. Technical Field
[0004] The present disclosure relates to buffers. Background Art
[0005] Two devices communicate using a communication protocol. The two devices nominally operate at the same frequency, but use independent clock generation circuits. As a result, small differences between the actual frequencies may result. In addition, even though the frequencies are the same, the phases of the clocks are independent. Due to these clock differences, buffering is used to allow data to cross from one clock domain to another.
[0006] PCI express (PCIe) is a high-speed bidirectional serial connection. Currently, there are five generations of PCIe, although more are planned. Each subsequent generation provides higher data transfer than the previous generation and is backward compatible, allowing devices to negotiate a common protocol using the first generation (GEN1) protocol before upgrading to the next generation. Elastic buffers (also called rate matching first-in-first-out (FIFO)) are used to cross the clock domain boundary between the transmitter clock and the receiver clock at the receiver.
[0007] Even though PCIe devices are designed to operate at the same frequency, there will be some variation between physical devices. For example, the PCIe GEN1 protocol allows a tolerance of 300 parts per million (300ppm). Other protocols have larger tolerances. For example, the use of the separate reference independent clock (SRIS) feature in PCIe increases the tolerance by 5000ppm. However, any frequency difference (even within tolerance) will eventually result in an overflow if the transmitting device provides data faster than the receiving device can process the data, or an underflow if the transmitting device does not provide data as fast as the receiving device can process the data. Special skip symbols are periodically inserted by the transmitter. When skip symbols are received, the receiver can add or remove skip symbols to prevent overflow or underflow of the elastic buffer. Summary of the invention
[0008] The present disclosure provides a system. The system includes: a data buffer circuit configured to buffer data in a data buffer, the data buffer including a plurality of columns; and a channel shifter circuit coupled to the data buffer circuit and configured to perform operations, the operations including: accessing a plurality of data elements including two data elements from each of the plurality of columns; and generating an output based on detecting a skip ordered set in the accessed plurality of data elements, the skip ordered set including symbols less than the number of columns in the plurality of columns, the output including a number of output data elements equal to the number of columns, two of the output data elements having been accessed from a single column in the plurality of columns.
[0009] The present disclosure also provides a method. The method includes: buffering data by a data buffer circuit including a plurality of columns; accessing a plurality of data elements including two data elements from each of the plurality of columns by a channel shifter circuit; and generating an output by the channel shifter circuit, the output including a number of output data elements equal to the number of columns of the plurality of columns, two of the output data elements having been accessed from a single column of the plurality of columns.
[0010] The present disclosure also provides a non-transitory machine-readable medium storing instructions. The instructions, when executed by one or more processors, cause the one or more processors to perform operations, the operations comprising: buffering data by a data buffer circuit comprising a plurality of columns; accessing a plurality of data elements comprising two data elements from each of the plurality of columns by a channel shifter circuit; and generating an output by the channel shifter circuit based on detecting a skip ordered set in the accessed data elements, the skip ordered set comprising fewer symbols than the number of columns of the plurality of columns, the output comprising a number of output data elements equal to the number of columns, two of the output data elements having been accessed from a single column of the plurality of columns. BRIEF DESCRIPTION OF THE DRAWINGS
[0011] In the figures of the accompanying drawings, some embodiments of the disclosed technology are shown by way of example and not limitation.
[0012] Figure 1 is a high-level schematic diagram of a system interfaced with a network and including a wide elastic buffer, according to some example embodiments.
[0013] Figure 2 is a high-level schematic diagram of an implementation of a wide elastic buffer according to some example embodiments.
[0014] Figure 3 is an example showing register file contents, channel shifter output, and read pointer modifications for a wide elastic buffer.
[0015] Figure 4 is an example showing register file contents, channel shifter output, and read pointer modifications for a wide elastic buffer.
[0016] Figure 5 is a flowchart of a method of maintaining pointers in a wide elastic buffer according to some example embodiments.
[0017] Figure 6 is a block diagram illustrating components of a system for performing the methods described herein, according to some example embodiments. DETAILED DESCRIPTION
[0018] Example methods, systems, and circuits for maintaining a wide elastic buffer will now be described. In the following description, many examples with example specific details are set forth to provide an understanding of the example implementations. However, it will be apparent to one of ordinary skill in the art that these examples can be practiced without these example specific details and / or in a combination of details different from those given herein. Therefore, specific implementations are given for simplicity of illustration and not for purposes of limitation.
[0019] The receiving device uses an elastic buffer that is wider than the number of data elements transferred in each cycle. To fill the columns of the elastic buffer evenly, the write pointer references each column in turn. Thus, the first data element is written to the first column, the second data element is written to the second column, and so on, until one data element has been received for each column, at which point the write pointer points to the next entry in the first column.
[0020] To compensate for the frequency difference between the two devices, the sending device periodically sends a skip request with a default number of skipped data elements. To compensate for the difference, the receiving device ignores one or more skipped data elements, thus using the period of the skip request to process data, even if the sending device does not send data during the period of the skip request.
[0021] Alternatively, if the receiving device is faster than the sending device, the elastic buffer will empty at a rate that depends on the speed difference. To compensate for the difference, the receiving device adds one or more skip data elements to the skip request, thereby processing less data in the elastic buffer than indicated by the skip request.
[0022] However, if the read pointers for each column are simply adjusted to reflect the skipped data, the effect will be to change the order in which the data is read from the elastic buffer, unless the amount of data skipped is an even multiple of the width of the elastic buffer. For example, if a wide elastic buffer is four columns wide and three data elements are skipped, three read pointers will be incremented and the fourth will remain unchanged. As a result, the next read of the four data elements will include data ordered in a manner that depends on the alignment of the three data elements and not just on the order in which the elements were received.
[0023] To avoid this problem, a two-row wide elastic buffer is read at a time. This allows a row of results to be constructed from any combination of data elements from the two rows. As a result, the data can be reordered to provide correctly ordered data elements for the width of the elastic buffer, even when jumps are added or removed. The column pointers are adjusted appropriately to ensure that they continue to point to the next data to be read.
[0024] Figure 1 is a high-level schematic diagram of a system 100 connected to a network interface and including a wide elastic buffer according to some example embodiments. The system 100 includes a physical medium attachment (PMA) interface 105, a receive (RX) polarity bit reversal sign exchange circuit 110, an 8-bit / 10-bit (8b / 10b) decoder circuit 115 and a 128-bit / 130-bit (128b / 130b) decoder circuit 120, a fifth generation (GEN5) block synchronizer circuit 125, a comma detection and symbol alignment circuit 130, a wide elastic buffer 135, an RX pipe circuit 140, a pseudo-random bit stream (PRBS) checker circuit 145, a chip attachment unit interface (CAUI) gearbox circuit 150, a synchronization gearbox circuit 155, and an RX multiplexer (MUX) logic 160, which are connected by physical traces, buses, or other connecting circuits as shown. For readability, the following are shown in FIG. Figure 1 The various MUXs between components 105 to 160 are not shown.
[0025] The PMA interface 105 receives a data read request. The data read request and the near-end physical coding sublayer (PCS) loopback input are provided to the MUX, and one or the other is provided as an input to the RX polarity bit-reversed symbol exchange circuit 110. The RX polarity bit-reversed symbol exchange circuit 110 is used to reverse the data, swap the byte order, and reverse the bit order, as determined by three configuration lines, which are rev_bit, rev_pol, and swap_symbol. This allows the system 100 to communicate with other systems that use other physical configuration options to represent data. The output of the RX polarity bit-reversed symbol exchange circuit 110 is formatted in a manner expected by the rest of the system 100 and is directed to all (or selectively to one) of the comma detection and symbol alignment circuit 130, the 128b / 130b decoder 120, the CAUI gearbox circuit 150, the synchronization gearbox circuit 155, the RX MUX logic 160, the far-end PMA parallel loopback, and the PRBS checker circuit 145. The PRBS checker circuit 145 can detect transmission errors by comparing the received data pseudo-randomly generated by the transmitter with the same PRBS generated locally.
[0026] System 100 may implement a peripheral interconnect interface express (PCIe) device supporting Generation 1 to Generation 5 (GEN1-GEN5) protocols. 8b / 10b decoder circuit 115 is used for GEN1 communications and GEN2 communications. 128b / 130b decoder 120 is used for GEN3 to GEN5 communications. 8b / 10b decoding converts 10 coded bits to 8 decoded bits. 128b / 130b decoding converts 130 coded bits to 128 decoded bits. GEN5 processing also includes a GEN5 block synchronizer circuit 125.
[0027] PMA parallelization occurs at arbitrary word boundaries. Therefore, the parallel data from the RX PMA clock data recovery (CDR) must be realigned to meaningful character boundaries by the GEN5 block synchronizer circuit 125. The PCIe 4.0 base specification outlines the use of 130-bit blocks (except for skip (or SK) blocks) to form data. SK ordered sets can be 66 bits, 98 bits, 130 bits, 162 bits, or 194 bits long. The block synchronizer searches for the electrical idle exit sequence ordered set (or the last number of fast training sequences (NFTS) ordered set) or the skip (SKP) ordered set to identify the correct boundary of the incoming stream and achieve block alignment. After receiving the SKP ordered set, the block is realigned to the new block boundary because it can be variable length.
[0028] The MUX selects the output of the RX polarity bit reversal symbol exchange circuit 110 or the GEN5 block synchronizer circuit 125 based on the communication protocol of the system 100 to be provided as input to the comma detection and symbol alignment circuit 130. The comma detection and symbol alignment circuit 130 can be configured to support various standards (e.g., PCIe GEN1 or GEN2) by programming various characters for detection, and aligning in response to detection. Symbol alignment uses alignment and sequence characters to identify the correct symbol boundaries in the received data stream. The attributes for alignment and sequence detection symbols are specified to be 10 bits wide. This block provides a very general and programmable comma mode with sequence options to suit any protocol scheme and custom scheme. The skip request is also called the comma mode because the first character of the PCIe skip request is a comma (COM) symbol followed by multiple SKPs.
[0029] The wide elastic buffer 135 is used to synchronize the received data from the PMA recovered clock with the system clock or local clock (usually the transmit clock). The wide elastic buffer 135 includes multiple first-in-first-out (FIFO) columns and compensates for the frequency difference between the PMA recovered clock and the system clock or local clock by adding or deleting preconfigured skip (or fill or alignment) characters from the received data stream. The elastic FIFO provides an indication that the skip (or fill or alignment) character is added to the downstream logic or deleted. For PCIe, the elastic FIFO also includes appropriate status encoding to indicate whether the operation is to add a character or delete a character.
[0030] As shown in system 100, when data is received in an 8b / 10b encoding format, the wide elastic buffer 135 stores the encoded 10b data. This allows the system 100 to operate as a loopback slave system. PCIe requires the loopback slave system to retransmit the received 10-bit information as received. Therefore, by storing the 10b data and retransmitting the 10b data without decoding and re-encoding, operation as a loopback slave system is supported. Since the 128b / 130b data is decoded into 8-bit data before being stored in the wide elastic buffer 135, the wide elastic buffer 135 is able to store both 8-bit data and 10-bit data.
[0031] The PCI Express 4.0 Base Specification defines that a SKP ordered set (OS) can be 66, 98, 130, 162, or 194 bits long. SKPOS has the following fixed bits: 2-bit sync, 8-bit SKP END, and 24-bit LFSR = 34 bits. The wide elastic buffer 135 adds or deletes 4 SKP characters (32 bits) to prevent the FIFO from becoming empty or full, respectively. If the FIFO is close to full, it deletes 4 SKP characters by disabling writes when a SKP is found. If the FIFO is close to empty, the design waits for the SKP ordered set to start, then stops reading data from the FIFO, and inserts the SKP into the output data.
[0032] The CAUI gearbox circuit 150 and the synchronous gearbox circuit 155 adapt the PMA data width to the width of the PCS interface. The CAUI gearbox circuit 150 supports a 64-bit PMA interface width and a 66-bit PCS interface width. The synchronous gearbox circuit 155 supports a 64-bit PMA interface width and a 67-bit PCS interface width.
[0033] Both the CAUI gearbox circuit 150 and the synchronous gearbox circuit 155 support synchronous mode. The gearbox will stop the data throughput by deactivating the 'data_valid' signal for 1 clock cycle to match the ratio. This structure handles the 'data_valid' signal. The CAUI gearbox circuit 150 can also support asynchronous mode, where the gearbox is responsible for providing data on every clock cycle of the receiver clock.
[0034] When not operating with the gearbox, the output of the wide elastic buffer 135 is provided to the RX pipe circuit 140 or to the RX MUX logic 160. The RX pipe circuit 140 is used to support other communication modes, bypassing the wide elastic buffer 135 and other components of the system 100. The MUX controls the input to the RX MUX logic 160 to select from the outputs of the RX pipe circuit 140, the wide elastic buffer 135, the CAUI gearbox circuit 150, the 8b / 10b decoder 115, and the synchronous gearbox circuit 155. The data provided to the RX MUX logic 160 is provided as an output of the system 100. Therefore, the system 100 provides a PMA interface 105 that handles the necessary data format conversion, buffers the data, and provides the data on the RX MUX logic 160 in a conventional manner, ready for processing by the device. In addition, the output is sent to the far end PCS loopback.
[0035] Figure 2is a high-level schematic diagram of an implementation of a wide elastic buffer 200 according to some example embodiments. The wide elastic buffer 200 includes a write controller 210; a data buffer circuit 230 including four register files 220A, 220B, 220C, and 220D; a read controller 240, a skip ordered set (SOS) detector 250, and a lane shifter 260. The register files 220A to 220D may be generally referred to as "register files 220".
[0036] Data is received on the DATA_IN signal and written to a common write address provided by the write controller 210. Figure 2 As shown in , the common write address is the same for all register files 220A to 220D. In addition, the write controller 210 provides the common write address to the read controller 240. This allows the read controller 240 to always know how full the data buffer circuit 230 is. The write controller 210 operates in the PMA recovered clock domain. The read controller 240, the SOS detector 250, and the channel shifter 260 operate on the internal clock domain. Each of the register files 220A to 220D is a column in a four-entry wide buffer, which allows data to be transferred asynchronously between two clock domains.
[0037] The common write address increases according to the size of the incoming data, and can point to any one of the register files 220A to 220D. For example, if the incoming data is four entries wide, the common write address points to the address in the register file 220A. When writing data, the entry is written to each of the register files 220A to 220D, and the common write address is increased by four (to point to the next address in the register file 220A). As another example, if the incoming data is one entry wide, the common write address points to the address in any one of the register files 220A to 220D. When writing data, only the entry is written to the register file pointed to by the common write address, and the common write address is increased by one (to point to the next available entry in the next register file). Therefore, using the common write address, any size of incoming data up to the number of register files can be processed.
[0038] To read data, read controller 240 reads data from each of register files 220A to 220D using two read addresses. The eight read data entries are provided to channel shifter 260. Channel shifter 260 selects and rearranges the eight read data entries based on the eight read data entries and the signal from read controller 240 to generate a four-entry output, provided as a DATA_OUT signal. Figure 2The example of uses four register files and a four-entry output, but other sizes are contemplated (e.g., eight register files and an eight-entry output). Additionally, each entry may be a byte, 10 bits, word, double word, or another amount of data.
[0039] The SOS detector 250 checks the data read from the data buffer circuit 230 to determine whether the skip data command is part of the data. For example, in PCIe GEN1 to PCIe GEN2, the SOS includes a COM symbol followed by one or more SKPs. If a skip data instruction is detected, the read controller 240 is notified and enabled to send appropriate signals to the channel shifter 260. In PCIe GEN3 to PCIe GEN5, the SOS includes one or more groups of four SKPs followed by a SKIP END. Therefore, when implemented in a PCIe GEN1 or PCIe GEN2 system, the SOS detector 250 can determine that a skip data command is received based on the COM symbol; in a PCIe GEN3, PCIe GEN4, or PCIe GEN5 system, a skip data command can be detected based on the SKP symbol; in other systems, other symbols or sequences can be used to detect a skip data command.
[0040] The channel shifter circuit 260 reads one or more elements from the data buffer circuit 230 and provides them as DATA_OUT. After reading the data from the data buffer circuit 230, the channel shifter circuit 260 updates the pointer for each register file 220. Typically, one entry is read from each register file 220 and each pointer is incremented by one.
[0041] If the SOS detector 250 detects that the decoded symbol is a skip request, the read controller 240 determines how many symbols to skip for the skip request. The number of symbols to be skipped may be the same as the number of symbols for the skip request, or may be more or less symbols. The number of symbols to be skipped may be based on the fill level of the data buffer circuit 230. For example, if the data buffer circuit 230 is more than half full, fewer symbols may be skipped, thereby facilitating the clearing of the data buffer. As another example, if the data buffer circuit 230 is less than half full, more symbols may be skipped, thereby retaining the data in the data buffer. The fill level of the register files 220A to 220D may be determined by taking the difference between the common write address and one of the read addresses (e.g., the read address of the register file 220A) and comparing the difference with the size of the register file.
[0042] In response to the skip request, the lane shifter circuit 260 modifies the pointer of the first of the register files 220A to 220D by a different amount than the pointer of the second of the register files 220A to 220D. The different pointer modifications allow multiple entries to be read from one register file 220 while only one entry is read from the other register file 220, or allow one entry to be read from one register file 220 without reading any entries from the other register file 220.
[0043] Allowing a different number of entries to be read from each register file 220 allows skip data requests to be processed at a granularity of less than an entire row of the data buffer circuit 230. As a result, skip requests from protocols that support a maximum number of skips less than the number of columns of the data buffer circuit 230 can be accommodated while still making full use of the data buffer circuit 230. Compared to other solutions that disable columns of the data buffer circuit 230 so that the (enabled) width of the data buffer is no greater than the maximum entry that can be skipped, the system 100 is enabled to run at a lower clock rate, have a larger buffer, or both. In addition, the data buffer with limited width has limited ability to handle protocols that transmit more data per clock cycle. For example, if a protocol that sends four entries per clock is being used, and the data buffer is one entry wide, the logic that transmits four entries into the data buffer must be executed at a clock four times faster to allow four writes to be completed before the next set of four entries are received. Using the solution described herein, both narrow (e.g., one entry per clock) and wide (e.g., four entries per clock) protocols can be efficiently processed by the same hardware.
[0044] Although the examples described here refer to PCIe, wide elastic buffers can be used in other systems and other protocols. For example, Universal Serial Bus (USB) or Serial Advanced Technology Attachment (SATA) protocols can use wide elastic buffers.
[0045] Figure 3 3 is an example 300 showing register file contents 310, channel shifter output 320, and read pointer modification 330 for a wide elastic buffer. Register file contents 310 show eight rows of data in each of four register files. Letters A to X are used to indicate data, COM indicates the start of a skip data request, and SK is a received skip entry. The number in brackets indicates that the data entry is the first data entry in the output of channel shifter output 320.
[0046] Register file contents 310 include eight four-entry communications, sixteen two-entry communications, or thirty-two single-entry communications, with the first received communication at the bottom right and the last received communication at the top left. If the receiving device and the transmitting device were perfectly synchronized, then channel shifter output 320 would match register file contents 310, and each rightmost entry in register file contents 310 would contain brackets. However, in Figure 3 In the example of , the receiving device operates slightly slower than the sending device. Therefore, some received skip entries will be ignored, allowing the receiving device to catch up by processing additional data entries.
[0047] Channel shifter output 320 shows seven data outputs formed with eight rows of data in register file contents 310. Each two-entry COM / SK pattern in register file contents 310 results in a single-entry COM pattern in channel shifter output 320, reducing the number of data entries to be skipped. Although the data in register file contents 310 is modified, the order of the data in channel shifter output 320 is unchanged.
[0048] Read pointer modification 330 shows the change to the read pointer of the corresponding column in register file content 310 after filling a row of channel shifter output 320. Thus, for the first row of channel shifter output 320, one of data values D, C, B, and A is read from each column of register file content 310, and the read pointer for each column is incremented by one as shown in the first row of read pointer modification 330.
[0049] For the second output row, the read pointer for each column points to data values F, E, SK, and COM. The next read pointer for each column points to data values SK, COM, H, and G. Because the channel shifter accesses all eight data values, it is able to remove the first SK (before E), move E and F, and place G from the next row in the appropriate position. Thus, the second output row is generated. One entry is consumed from each of the first three columns, thus increasing the read pointer for that column. Two entries (COM and G) are consumed from the fourth column, and the read pointer for that column is increased by two, as shown in the second row of read pointer modification 330.
[0050] Since the read pointer is not modified by the same amount, during the preparation of the third output row, data will be read from different input rows for different columns. Therefore, the data available for the channel shifter are SK and COM for the first column, COM and K for the second column, H and J for the third column, and I and SK for the fourth column. In addition, the last column from which data is read is stored, so the channel shifter knows that the first entry of the third output row is not the fourth column but the third column. Therefore, the channel shifter can determine that the data is H, COM, SK, I, J, K, COM in sequence. Removing SK and outputting four entries produces H, COM, I, J shown in the third row of the channel shifter output 320. In this case, two entries are obtained from the third column, and as shown in the third row of the read pointer modification 330, the pointer of the third column increases by two.
[0051] Figure 4 4 is an example 400 showing register file contents 410, channel shifter output 420, and read pointer modification 430 for a wide elastic buffer. Register file contents 410 show the same data values as register file contents 310, but the position of the number in brackets indicates that the data entry is the first data entry in the output of channel shifter output 420 and the position is consistent with Figure 3 In the difference. Figure 4 In the example of , the receiving device operates slightly faster than the sending device. Therefore, some skip entries will be added, allowing the receiving device to slow down by processing fewer data entries.
[0052] Channel shifter output 420 shows nine data outputs formed with eight rows of data in register file contents 410. Each two-entry COM / SK pattern in register file contents 410 results in a three-entry COM / SK / SK pattern in channel shifter output 420. Although the data in register file contents 410 is modified, the order of the data in channel shifter output 420 is unchanged.
[0053] Read pointer modification 430 shows the change to the read pointer of the corresponding column in register file content 410 after filling a row of channel shifter output 420. Thus, for the first row of channel shifter output 420, one of data values D, C, B, and A is read from each column of register file content 410, and the read pointer for each column is incremented by one as shown in the first row of read pointer modification 430.
[0054] For the second output row, the read pointer for each column points to data values F, E, SK, and COM. The next read pointer for each column points to data values SK, COM, H, and G. Because the channel shifter can access all eight data values, it can insert SK before E. This increases the number of data entries to be skipped and shifts E to the next position. Thus, the second output row is generated. One entry is consumed from each of the last three columns, so the read pointers for those columns are increased. No entries are consumed from the first column, so the read pointer for that column is not increased (or alternatively, increased by zero), as shown in the second row of read pointer modification 430.
[0055] Since the read pointer is not modified by the same amount, during the preparation of the third output row, data will be read from different input rows for different columns. Therefore, the data available to the channel shifter is F and SK for the first column, COM and K for the second column, H and J for the third column, and G and I for the fourth column. In addition, the last column from which data is read is stored, so the channel shifter knows that the first entry of the third output row is not the fourth column but the first column. Therefore, the channel shifter can sequentially determine that the data is F, G, H, COM, SK, I, J, K, COM. SK is not added or removed in the first position, so the four entries output are F, G, H, COM shown in the third row of the channel shifter output 420. In this case, one entry is taken from each column of the register file content 410, and each pointer is increased by one as shown in the third row of the read pointer modification 430.
[0056] although Figures 2 to 4 The example of shows four columns used in a wide elastic buffer, but other widths are contemplated. For example, the wide elastic buffer may be eight columns, twelve columns, sixteen columns, or thirty-two columns wide. Larger widths to support higher transfer rates are also possible.
[0057] Figure 5 is a flow chart of a method 500 for maintaining pointers in a wide elastic buffer according to some example embodiments. The method 500 includes operations 510, 520, and 530. By way of example and not limitation, reference is made to Figure 3 to Figure 4 For example data, method 500 is described as being Figure 1 System 100 and Figure 2 The wide elastic buffer 200 is implemented as a component.
[0058] In operation 510, the SOS detector 250 notifies the read controller 240 that a skip request has been received, the skip request indicating that a certain number of data entries in the data buffer are to be skipped, the number of entries to be skipped not being an even multiple of the number of columns in the data buffer. Figures 4 to 5The COM, SK sequence is a request to skip two data entries, which is not a data buffer (for example, by Figure 2 An even multiple of the number of columns (four) in the data buffer formed by the four register files 220A to 220D in FIG.
[0059] In operation 520, the read controller 240 modifies a first pointer for a first column of the data buffer by a certain amount in response to the skip request. Also in response to the skip request, in operation 530, the read controller 240 modifies a second pointer for a second column of the data buffer by a different amount. For example, each of the second, third, fourth, and sixth rows of the read pointer modification 430 shows that the pointer for one column is increased by two, while the pointers for the other three columns are increased by one. As another example, each of the second, fourth, fifth, and eighth rows of the read pointer modification 430 shows that the pointer for one column remains unchanged, while the pointers for the other three columns are increased by one.
[0060] In response to instructions received from the read controller 240, the channel shifter 350 selects the ninth SK value for each of the four output channels of DATA_OUT among the eight data values read from the register files 320A to 320D. Thus, under the control of the read controller 240, the channel shifter 350 outputs the correct four entries to support the addition or subtraction of the SK value from DATA_IN. By modifying the read pointer, the read controller 240 maintains the state necessary to ensure that the modification of the output does not result in reordered, lost, or duplicated data.
[0061] Figure 6 6 is a block diagram illustrating components of a system 600 for performing the methods described herein according to some example embodiments. Not all components need be used in various embodiments. For example, a client, a server, an autonomous system, and a cloud-based network resource may each use a different set of components, or in the case of a server, use, for example, a larger storage device.
[0062] An example computing device in the form of a computer 600 (also referred to as computing device 600 and computer system 600) may include a processor 605, memory storage 610, removable storage 615, and non-removable storage 620, all connected via a bus 640. Although the example computing device is shown and described as a computer 600, in different embodiments the computing device may be in different forms. For example, the computing device may alternatively be a smartphone, tablet, smartwatch, or include a computer system 600 that is associated with the computer system 600. Figure 6Another computing device having elements that are the same or similar to those shown and described. Devices such as smart phones, tablet computers, and smart watches are collectively referred to as "mobile devices." In addition, although various data storage elements are shown as part of computer 600, the storage device may also or alternatively include cloud-based storage or server-based storage that can be accessed via a network such as the Internet.
[0063] Memory storage 610 may include volatile memory 645 and nonvolatile memory 650, and may store programs 655. Computer 600 may include or access a computing environment that includes various computer-readable media, such as volatile memory 645; nonvolatile memory 650; removable storage 615; and non-removable storage 620. Computer storage includes random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM) and electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disk read-only memory (CD ROM), digital versatile disk (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage, or any other medium capable of storing computer-readable instructions.
[0064] The computer 600 may include or access a computing environment including an input interface 625, an output interface 630, and a communication interface 635. The output interface 630 may be docked with a display device or include a display device, such as a touch screen, which may also be used as an input device. The input interface 625 may be docked with a touch screen, a touch pad, a mouse, a keyboard, a camera, one or more device-specific buttons, one or more sensors integrated in the computer 600 or coupled to the computer via a wired or wireless data connection, and one or more of other input devices or include a touch screen, a touch pad, a mouse, a keyboard, a camera, one or more device-specific buttons, one or more sensors integrated in the computer 600 or coupled to the computer via a wired or wireless data connection, and one or more of other input devices. The computer 600 may be connected to one or more remote computers (such as a database server) using a communication interface 635 to operate in a networked environment. The remote computer may include a personal computer (PC), a server, a router, a network PC, a peer device, or other public network nodes, etc. The communication interface 635 may be connected to a local area network (LAN), a wide area network (WAN), a cellular network, a WiFi network, a Bluetooth network, or other networks.
[0065] Computer instructions stored on computer readable media (e.g., programs 655 stored in memory storage device 610) can be executed by processor 605 of computer 600. Hard disk drives, CD-ROMs, and RAM are some examples of items that include non-transitory computer readable media such as storage devices. The terms "computer readable media" and "storage devices" do not include carrier waves because carrier waves are considered too short-lived. "Computer readable non-transitory media" include all types of computer readable media, including magnetic storage media, optical storage media, flash memory media, and solid-state storage media. It should be understood that the software can be installed in a computer and sold with the computer. Alternatively, the software can be obtained and loaded into the computer, including obtaining the software through physical media or distribution systems, including, for example, obtaining the software from a server owned by the creator of the software or a server that has never been owned but used by the creator of the software. For example, the software can be stored on a server for distribution over the Internet.
[0066] Program 655 is shown as including a write control module 660 and a read control module 665. Any one or more of the modules described herein may be implemented using hardware (e.g., a processor of a machine, an ASIC, an FPGA, or any suitable combination thereof). In addition, any two or more of these modules may be combined into a single module, and the functions described herein for a single module may be subdivided into multiple modules. In addition, according to various example embodiments, the modules described herein as being implemented within a single machine, database, or device may be distributed across multiple machines, databases, or devices.
[0067] The write control module 660 maintains a common write pointer for multiple register files to write received data into a buffer for clock domain crossing.
[0068] The read control module 665 maintains two read pointers for each of the plurality of register files for reading buffered data and modifying the read data to generate output data that compensates for the frequency difference between the external clock domain and the internal clock domain.
[0069] An abstract of the present disclosure is provided to comply with 37 CFR § 1.72 (b), which requires that the abstract allow the reader to quickly determine the nature of the technical disclosure. The abstract is submitted with the understanding that it will not be used to interpret or limit the claims. In addition, in the foregoing detailed description, it can be seen that various features are combined together in a single embodiment for the purpose of streamlining the present disclosure. The method of the present disclosure should not be interpreted as limiting the claims. Therefore, the attached claims are hereby incorporated into the detailed description, with each claim acting alone as a separate embodiment.
[0070] The solution of the present invention also includes:
[0071] (1) A system comprising:
[0072] a data buffer circuit configured to buffer data in a data buffer, the data buffer comprising a plurality of columns, the plurality of columns comprising a first column and a second column; and
[0073] A channel shifter circuit configured to perform operations comprising:
[0074] detecting that a symbol in the data buffer is a skip request to skip a corresponding number of data entries in the data buffer, the number of data entries to be skipped not being an even multiple of the number of columns; and
[0075] In response to the skip request:
[0076] modifying a first pointer of the first column by a first amount; and
[0077] A second pointer for the second column is modified by a second amount that is different from the first amount.
[0078] (2) A system according to (1), wherein:
[0079] The number of columns of the data buffer is four; and
[0080] The number of skipped data entries is less than four.
[0081] (3) The system of (1), wherein the first amount is one greater than the second amount.
[0082] (4) A system according to (1), wherein:
[0083] the first amount is two; and
[0084] The second amount is one.
[0085] (5) A system according to (1), wherein:
[0086] The first amount is one; and
[0087] The second amount is zero.
[0088] (6) A system according to (1), wherein:
[0089] The first pointer of the first column is a first read pointer of the first column;
[0090] The second pointer of the second column is a second read pointer of the second column; and
[0091] A single write pointer is used for the data buffer, and the single write pointer can point to any column of the data buffer.
[0092] (7) The system according to (6), wherein the operation further comprises:
[0093] The first amount is determined based on the single write pointer and the first read pointer.
[0094] (8) The system according to (1), wherein the operation further comprises:
[0095] Based on a determination that the data buffer is less than half full, a number of data entries to be skipped is reduced.
[0096] (9) The system according to (1), wherein the operation further comprises:
[0097] Based on a determination that the data buffer is greater than half full, a number of data entries to be skipped is increased.
[0098] (10) A method comprising:
[0099] receiving, via a network, a skip request indicating skipping of a certain number of data entries in a data buffer, the data buffer comprising a plurality of columns, the plurality of columns comprising a first column and a second column, the number of data entries to be skipped not being an even multiple of the number of columns; and
[0100] In response to the skip request:
[0101] modifying a first pointer of the first column by a first amount; and
[0102] A second pointer for the second column is modified by a second amount that is different from the first amount.
[0103] (11) The method according to (10), wherein:
[0104] The number of columns is four; and
[0105] The number of skipped data entries is less than four.
[0106] (12) The method according to (10), wherein the first amount is one greater than the second amount.
[0107] (13) The method according to (10), wherein:
[0108] the first amount is two; and
[0109] The second amount is one.
[0110] (14) The method according to (10), wherein:
[0111] The first amount is one; and
[0112] The second amount is zero.
[0113] (15) The method according to (10), wherein:
[0114] The first pointer of the first column is a first read pointer of the first column;
[0115] The second pointer of the second column is a second read pointer of the second column; and
[0116] A single write pointer is used for the data buffer, and the single write pointer can point to any column of the data buffer.
[0117] (16) The method according to (15), further comprising:
[0118] The first amount is determined based on the single write pointer and the first read pointer.
[0119] (17) The method according to (10), further comprising:
[0120] Based on a determination that the data buffer is less than half full, a number of data entries to be skipped is reduced.
[0121] (18) A non-transitory machine-readable medium storing instructions that, when executed by one or more processors, cause the one or more processors to perform operations comprising:
[0122] receiving, via a network, a skip request indicating skipping of a certain number of data entries in a data buffer, the data buffer comprising a plurality of columns, the plurality of columns comprising a first column and a second column, the number of data entries to be skipped being not an even multiple of the number of columns; and
[0123] In response to the skip request:
[0124] modifying a first pointer of the first column by a first amount; and
[0125] A second pointer for the second column is modified by a second amount that is different from the first amount.
[0126] (19) The non-transitory machine-readable medium according to (18), wherein:
[0127] The number of columns of the data buffer is four; and
[0128] The number of data entries to be skipped is less than four.
[0129] (20) The non-transitory machine-readable medium of (18), wherein the first amount is one greater than the second amount.
Claims
1. A system, include: a data buffer circuit configured to buffer data in a data buffer, the data buffer comprising a plurality of columns; as well as a channel shifter circuit coupled to the data buffer circuit and configured to perform operations comprising: accessing a plurality of data elements including two data elements from each of the plurality of columns; as well as Based on detecting a skip ordered set in the plurality of data elements being accessed, generating an output, the skip ordered set comprising fewer symbols than a number of columns in the plurality of columns, the output comprising a number of output data elements equal to the number of columns, two of the output data elements having been accessed from a single column in the plurality of columns.
2. The system according to claim 1, further comprising: include: a write controller operating on a first clock domain and configured to write data to the data buffer circuit; Wherein, the channel shifter circuit operates on a second clock domain different from the first clock domain.
3. The system according to claim 2, in, The write controller employs a single write pointer that can point to any column in the data buffer.
4. The system according to claim 1, in: The accessing of the plurality of data elements including two data elements from each of the plurality of columns comprises using two read addresses for the columns; and Each column of the plurality of columns includes more than two rows.
5. The system according to claim 1, in, The operations also include determining that the accessed data element includes a skip request.
6. The system according to claim 5, in: The skip request includes a first number of symbols; and The output includes a sequence of symbols that skips a second number of symbols different than the first number of symbols.
7. The system according to claim 6, in, The operations also include: Based on a determination that the data buffer is less than half full, the channel shifter circuit sets the second number to a value greater than the first number.
8. A method, include: buffering data by a data buffer circuit including a plurality of columns; accessing, by a channel shifter circuit, a plurality of data elements including two data elements from each of the plurality of columns; as well as An output is generated by the channel shifter circuit, the output comprising a number of output data elements equal to the number of columns of the plurality of columns, two of the output data elements having been accessed from a single column of the plurality of columns.
9. The method according to claim 8, further comprising: include: writing data to the data buffer circuit by a write controller operating on a first clock domain; Wherein, the channel shifter circuit operates on a second clock domain different from the first clock domain.
10. The method according to claim 9, in, The write controller employs a single write pointer capable of pointing to any column in the data buffer circuit.
11. The method according to claim 8, in: The accessing of the plurality of data elements including two data elements from each of the plurality of columns comprises using two read addresses for the columns; and Each column of the plurality of columns includes more than two rows.
12. The method according to claim 8, further comprising: include: Determining the plurality of data elements being accessed includes a skip request.
13. The method according to claim 12, in: The skip request includes a first number of symbols; and The output includes a sequence of symbols that skips a second number of symbols different than the first number of symbols.
14. The method according to claim 13, further comprising: include: Based on a determination that the data buffer circuit is less than half full, the channel shifter circuit sets the second number to a value greater than the first number.
15. A non-transitory machine-readable medium storing instructions that, when executed by one or more processors, cause the one or more processors to perform operations, the operations include: buffering data by a data buffer circuit including a plurality of columns; accessing, by a channel shifter circuit, a plurality of data elements including two data elements from each of the plurality of columns; as well as Based on detecting a skip ordered set in the accessed data elements, an output is generated by the channel shifter circuit, the skip ordered set including fewer symbols than the number of columns of the plurality of columns, the output including a number of output data elements equal to the number of columns, two of the output data elements having been accessed from a single column of the plurality of columns.
16. The non-transitory machine-readable medium of claim 15, in, The operations also include: writing data to the data buffer circuit by a write controller operating on a first clock domain; Wherein, the channel shifter circuit operates on a second clock domain different from the first clock domain.
17. The non-transitory machine-readable medium of claim 16, in, The write controller employs a single write pointer capable of pointing to any column in the data buffer circuit.
18. The non-transitory machine-readable medium of claim 15, in: The accessing of the plurality of data elements including two data elements from each of the plurality of columns comprises using two read addresses for the columns; and Each column of the plurality of columns includes more than two rows.
19. The non-transitory machine-readable medium of claim 15, in, The operations also include: Determining the plurality of data elements being accessed includes a skip request.
20. The non-transitory machine-readable medium of claim 19, in: The skip request includes a first number of symbols; and The output includes a sequence of symbols that skips a second number of symbols different than the first number of symbols.
