|Publication number||US6101568 A|
|Application number||US 09/139,243|
|Publication date||Aug 8, 2000|
|Filing date||Aug 25, 1998|
|Priority date||Aug 25, 1998|
|Publication number||09139243, 139243, US 6101568 A, US 6101568A, US-A-6101568, US6101568 A, US6101568A|
|Inventors||Nicholas J. Richardson|
|Original Assignee||Stmicroelectronics, Inc.|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (4), Referenced by (60), Classifications (5), Legal Events (6)|
|External Links: USPTO, USPTO Assignment, Espacenet|
The present application is related to the inventor's applications "BUS INTERFACE UNIT HAVING MULTIPURPOSE TRANSACTION BUFFER" and "COMPUTER SYSTEM HAVING NON-BLOCKING CACHE AND PIPELINED BUS INTERFACE UNIT", which were filed on the same day as the present application. These related applications are herein incorporated by reference.
The present invention relates to a bus interface unit for a computer system, and more specifically to a bus interface unit for use in a computer system having an out-of-order processing unit and a non-blocking cache.
A typical conventional computer system includes a central processing unit ("CPU"), a cache subsystem, and a bus interface unit ("BIU"). During operation, a read or write request from the CPU is first sent to the cache. If the cache contains the target data (i.e., on a cache hit), the cache directly services the request. Conversely, if the cache does not contain the target data (i.e., on a cache miss) or if the request is directed to an uncacheable memory address or an input/output ("I/O") address, the cache passes the request on to the BIU. When the BIU receives a read or write request, the request is submitted to the external memory or I/O systems using a predefined bus protocol, and any results are returned back to the cache and CPU (via the cache). Additionally, the cache services snoop requests from external agents such as other processors in order to perform cache-coherency operations.
One bus protocol used in modern computer systems is the PentiumŪ II bus protocol as defined in Volume 1 of the Pentium Pro Family Developer's Manual, which is published by Intel Corporation (Santa Clara, Calif.) and is herein incorporated by reference. In accordance with this protocol, the BIU communicates with the memory and I/O systems using several different read and write request transaction formats including: bus read line ("BRL"), bus read and invalidate line ("BRIL"), bus invalidate line ("BIL"), bus write line ("BWL"), bus read partial ("BRP"), bus write partial ("BWP"), I/O read ("IOR"), and I/O write ("IOW"). A brief description of each of these transactions will now be given.
A bus read line transaction is requested when a new line is to be loaded into the cache. When a CPU read from a cacheable address misses the cache, the cache issues a BRL transaction to the BIU. In response, the BIU makes a read request to main memory for the number of bytes required to fill a cache line (e.g., 32 bytes). Because the CPU can process read transactions speculatively and out-of-order, BRLs do not have any ordering requirements either with respect to each other or with respect to other types of bus transactions.
A bus read and invalidate line transaction is initiated when a CPU write transaction to a cacheable address misses the cache. Like a BRL, a BRIL causes the BIU to read a line from external memory. Additionally, the addressed line is invalidated in all other caches (for external agents in the system) in which the line resides. Although in conventional systems memory writes must generally be kept in order, a BRIL does not directly influence the ordering of the CPU write transaction from which it was generated. Thus, BRILs do not have any ordering requirements either with respect to each other or with respect to other types of bus transactions. Similarly, a bus invalidate line transaction is initiated when a CPU write to a cacheable address hits a shared line in the cache. Such a shared line must be changed to the exclusive state before it can be modified by the CPU. The BIL transaction is used to invalidate the addressed line in all other caches in which the line resides, without reading any data from the external memory. BILs also do not have any ordering requirements either with respect to each other or with respect to other types of bus transactions.
A bus write line transaction is generated when the cache writes a displaced cache line back to memory so that a new line can be loaded into the cache. A BWL is also generated when multiple CPU write transactions to uncacheable memory addresses are accumulated (i.e., write-combined) in the BIU. In a BWL, an entire line (e.g., 32 bytes) is written to the external memory. Like BRLs, BWLs do not have any ordering requirements either with respect to each other or with respect to other types of bus transactions.
The bus read partial and I/O read transactions are generated when the CPU issues a read transaction that is directed to an uncacheable memory address or an I/O address, respectively. When a BRP or an IOR is submitted to the bus by the BIU, one to eight bytes of data are read from the designated address. Similarly, the bus write partial I/O write transactions are generated when the CPU issues a write transaction to an uncacheable memory address or an I/O address. The BWP and IOW transactions cause one to eight bytes of data to be written to the designated address. While the BIU must issue BRPs, BWPs, IORs, and IOWs to the bus in the order in which they are received from the CPU, these types of transactions do not have any ordering requirements with respect to BRLs, BRILs, BILs, and BWLs.
When the BIU receives a read or write request, the transaction is buffered in the BIU. More specifically, the BIU consolidates and orders the received transactions, and then issues the transactions on the bus so as to increase the efficiency (i.e., throughput) of the bus. The bus requests received by the BIU can be divided into two fundamental transaction classes: in-order transactions and speculative write-combine ("SWC") transactions. The BIU stores the in-order transactions (BRLs, BRILs, BILs, BWLs, IORs, IOWs, BRPs, and non-combinable BWPs) in one or more first-in, first-out ("FIFO") queues so that the transactions can be issued to the system bus in the order received. For example, in a typical BIU, a first FIFO queue is used to store cacheable, line-oriented transactions (e.g., BRLs and BWLs), and a second FIFO queue is used to store uncacheable, byte-oriented transactions (e.g., IORs and IOWs).
The SWC transaction requests received by the BIU are stored in a "combining" buffer. In more detail, each SWC request is received by the BIU as a request for writing a relatively small amount of data to memory (e.g., one to eight consecutive bytes for a BWP). If the data bytes to be written by multiple SWC requests fall within the address boundaries of the same data line, the BIU can concatenate the data and issue a single write line request to the system bus. For this purpose, the BIU holds SWC requests in a special combining buffer while awaiting additional SWC requests that can be combined into the held transactions. Each "transaction" stored in a combining buffer is transferred to one of the in-order FIFO queues for issuance to the system bus only after the occurrence of a predefined triggering event (e.g., the combining buffer entry becomes full).
While combining SWC requests increases the efficiency of the bus, the conventional BIU uses completely independent buffers for in-order and SWC transactions. Because each buffer holds all of the address, data, and control information for stored transactions, the combining buffer must be limited to a small number of entries to keep the chip area reasonable. However, when a new SWC request falls outside the address ranges of current entries in a full combining buffer, an incomplete entry must be issued by the BIU to make room for the new request. Thus, the addition of a relatively small buffer that does not significantly increase cost can only produce a limited performance increase. On the other hand, if all incoming write requests are simply placed in an in-order FIFO buffer, each SWC request can only be combined with others that arrive before the original request passes through the FIFO buffer. In this case, an additional buffer is not needed, but the performance increase is limited by the relatively short window of opportunity for write combining multiple requests.
In view of these drawbacks, it is an object of the present invention to remove the above-mentioned drawbacks and to provide a write-combining bus interface unit that increases the performance of a computer system without increasing cost or complexity. The bus interface unit includes a single random-access transaction buffer for storing the address, data, and control information for all transactions. When an in-order transaction is received, a pointer to the corresponding informational entry in the transaction buffer is placed in an ordering queue. On the other hand, when an SWC request is received, a mode flag is set to indicate that the entry in the transaction buffer is for a combinable write request. Subsequent SWC requests in the same address range are merged with the entry, and a ready flag is used to indicate when the write-combine entry is ready to be issued to the system bus. Because each entry in the dual purpose transaction buffer can be used to store either an in-order or an SWC transaction, a relatively large number of buffer entries can be selectively used to store write-combine entries. Thus, SWC requests for many different address ranges can be handled simultaneously without forcing the issuance of incomplete entries. Further, entry type information and transaction ordering information are stored using a set of flags and pointer queues. This eliminates the need for a separate combining buffer with dedicated transaction entries, so the chip area is reduced. Therefore, the bus interface unit of the present invention can efficiently combine individual write transactions to increase the throughput of the bus without increasing the cost of the system.
It is another object of the present invention to provide a write-combining bus interface unit that makes efficient use of the fields in the transaction buffer. In the dual purpose transaction buffer, the byte-enable flags for a write-combine entry occupy a portion of the field that is used to store the address/control information for an in-order transaction entry. This dual use of the address/control field eliminates the need to add write-combine-specific control bits to each transaction buffer entry, and thus prevents an increase in chip area.
It is yet another object of the present invention to provide a write-combining bus interface unit having control logic that prevents a deadlock situation. The bus interface unit includes a counter that keeps track of the number of write-combine entries present in the transaction buffer. Whenever the counter reaches a predetermined threshold, all write-combine entries in the transaction buffer are marked for immediate issuance to the system bus. In this manner, the bus interface unit prevents the transaction buffer from filling with incomplete write-combine entries so as to not leave any space for new in-order transactions.
According to a first embodiment of the present invention, a bus interface unit is provided that includes a random-access transaction buffer and at least one pointer queue. The transaction buffer stores entries for both in-order transactions and combinable write transactions, and the pointer queue stores pointers to the buffer entries for in-order transactions. The bus interface unit uses the pointers stored in the pointer queue to order the in-order transactions stored in the transaction buffer. Further, when the bus interface unit receives a combinable write transaction whose writing address falls within the address range of one of the combinable write transactions stored in the transaction buffer, the received combinable write transaction is merged with the stored combinable write transaction.
A second embodiment of the present invention provides a method of processing requested bus transactions in a computer system. According to the method, address and data information for both in-order transactions and combinable write transactions is stored as entries in a random-access buffer. Additionally, ordering information for in-order transactions is stored by placing a pointer to each in-order transaction entry in one or more pointer queues. When a received combinable write transaction has a write address that falls within the address range of one of the combinable write transactions stored in the transaction buffer, the received combinable write transaction is merged into the buffer entry for the stored combinable write transaction. In a preferred embodiment, buffer entries for combinable write transactions are marked when ready for issuance to the bus.
A third embodiment of the present invention provides a method of processing requested bus transactions in a computer system. According to this method, the bus interface unit determines if a requested transaction is a combinable write transaction. If the requested transaction is not a combinable write transaction, address and data information for the requested transaction is loaded into an empty entry in a random-access buffer, and a pointer to that buffer entry is placed in a pointer queue. On the other hand, if the requested transaction is a combinable write transaction, the bus interface unit determines if the transaction's write address falls within the address range of a buffer entry that stores a combinable write transaction. If so, the requested combinable write transaction is merged into the buffer entry for the stored combinable write transaction. In one preferred embodiment, if the write address does not fall within the address range of any buffer entry storing a combinable write transaction, the data information for the requested combinable write transaction is loaded into an empty entry in the random-access buffer.
Other objects, features, and advantages of the present invention will become apparent from the following detailed description. It should be understood, however, that the detailed description and specific examples, while indicating preferred embodiments of the invention, are given by way of illustration only and various modifications may naturally be performed without deviating from the present invention.
FIG. 1 is a block diagram of a bus interface unit according to an embodiment of the present invention;
FIG. 2 is a block diagram of a preferred embodiment of the bus interface unit of FIG. 1;
FIG. 3 is a flow chart of the process used to store an in-order transaction in the bus interface unit of FIG. 2;
FIG. 4 is a flow chart of the process used to store an SWC transaction in the bus interface unit of FIG. 2; and
FIG. 5 is a block diagram of essential portions of a computer system that includes a bus interface unit.
Preferred embodiments of the present invention will be described in detail hereinbelow with reference to the attached drawings.
In a computer system, a non-blocking cache subsystem 42 is connected between an out-of-order processing unit ("CPU") 40 and a pipelined bus interface unit ("BIU") 44, as shown in FIG. 5. The BIU 44 is also connected to the system bus 54, along with external memory 46 and various I/O systems 48. In some systems, external agents (such as external CPU 50 and its cache 52) are also coupled to the cache 42. In preferred embodiments, the system bus operates in accordance with the PentiumŪ II bus protocol described above.
FIG. 1 shows a block diagram of the BIU 44 of such a computer system according to an embodiment of the present invention. As shown, a single random-access transaction buffer, which is known as the bus request queue ("BRQ") 12, receives the address, control, and data information for all memory and I/O transactions requested by the cache. Each entry in the BRQ includes a first field 12a for storing the transaction address and other control information, a second field 12b for storing any transaction data (e.g., up to one line, or 32 bytes, of data), and a valid flag 12c for indicating when a transaction is stored in the entry. In addition to the BRQ 12 that stores a collection of randomly-accessible entries, the BIU includes an in-order queue 14 that stores information about the order in which transactions are to be sent to the bus and returned to the cache. Each entry in the queue stores a pointer to one of the informational entries in the random-access BRQ. In further embodiments, multiple queues are provided to separately store ordering information for different types of transactions. The BIU also includes a counter 16 that is coupled to the BRQ 12.
The operation of the BIU of FIG. 1 will now be explained. When an in-order transaction request (i.e., any non-combinable write request) is received from the cache, a new BRQ entry (e.g., 18) is allocated to hold the address, control, and data information for the transaction. Additionally, a pointer to the BRQ entry is placed at the rear of the FIFO in-order queue 14 to allow in-order transactions to be issued to the system bus in the same order as they were received by the BIU. When the BIU is ready to issue an in-order transaction, the pointer at the head of the in-order queue 14 is used to select the BRQ entry corresponding to the next-in-line transaction. After the transaction is issued, the BIU removes the transaction's pointer from the in-order queue.
When a first speculative write-combine ("SWC") request is received from the cache, a new BRQ entry (e.g., 19) is allocated to hold the address, control, and data information for the request. Instead of placing a pointer to the BRQ entry in the in-order queue 14, the BIU sets a mode flag 19a to indicate that the BRQ entry is storing a non-order dependent write-combine request. Furthermore, the BIU increments the value of the counter 16 to register that a write-combine request has been stored, and sets the proper byte-enable flags to indicate which data bytes are to be written. In a preferred embodiment, a portion of the BRQ field 12a used to hold address and control information for in-order transactions is used for the byte-enable flags. That is, if the data field 12b of each BRQ entry holds 32 bytes, then 32 bits in the address/control field 12a of the BRQ entry (e.g., the low-order address bits 19c) are used as byte-enable flags when the entry stores a write-combine request.
Then, when another SWC request is received from the cache, the BIU compares the new request with all write-combine requests currently stored in the BRQ 12. If the address of the new SWC request falls within the address range of a stored write-combine request, the new request is merged into the existing one. More specifically, the data from the new request is merged into the data field 12b of the stored write-combine entry and the appropriate byte-enable flags are set. In such a case, a new BRQ entry is not allocated so the counter is not incremented. If, on the other hand, the address of the new SWC request does not fall within the address range of a stored write-combine request, the request is stored in a new BRQ entry in the manner described above.
The BIU holds each write-combine request in the BRQ until release is triggered by the occurrence of a special event. For example, release of a write-combine request may be triggered when the request's data field becomes full, when the counter value reaches a predetermined threshold, when a memory read request overlaps the address range of the write-combine request, or when the BIU receives a synchronizing transaction (i.e., a transaction such as an IOW or IOR that requires the completion of all prior external memory transactions). When such an event triggers the release of a write-combine request, a "ready" flag 19b is set in the request's BRQ entry to indicate that the transaction is ready to be issued to the system bus. In preferred embodiments, new SWC requests are prevented from merging with a write-combine request that has been marked as ready in order to insure that the data to be written does not change during the bus transaction.
FIG. 2 shows in detail a BIU according to a preferred embodiment of the present invention. As shown, random-access BRQ 22 receives the address, control, and data information for all incoming transactions from a pipeline register 20. The BRQ 22 of FIG. 2 is identical to the BRQ 12 described above for FIG. 1, so a further description thereof is omitted. Additionally, a first priority encoder 24 is used to select an empty BRQ entry when storing a new transaction, and a second priority encoder 26 is used to select a write-combine BRQ entry for issuance to the system bus. A FIFO in-order queue 30 stores pointers to in-order BRQ entries to indicate the order in which these transactions are to be issued. When a BRQ entry is ready to be issued, the entry is selected by either the in-order queue 30 or second priority encoder 26 (via first multiplexer 34 and second multiplexer 36), and a transaction request is sent to a bus request generator ("BRG") 32. The BIU also includes a counter 16 that keeps track of the number of write-combine entries in the BRQ.
The operation of the BIU of the preferred embodiment will now be explained with reference to the flowcharts of FIGS. 3 and 4. When the cache 42 sends a new in-order transaction request (S10), the first priority encoder 24 selects a BRQ entry that has a cleared valid flag and asserts the load signal for that entry to load the transaction's address, control, and data information (S 12). The mode flag for the selected entry is cleared to indicate that the entry is storing an in-order transaction (S 14). Additionally, a pointer to the BRQ entry used to store the new transaction is placed at the rear of the FIFO in-order queue (S 16).
Whenever the in-order queue 30 is not empty, it sends a transaction request to the BRG 32. When the BRG is ready to service the in-order request, the pointer at the head of the in-order queue is used to select the next-in-line transaction's BRQ entry (via the multiplexers 34 and 36). The BRG 32 issues the transaction to the system bus using the information stored in the BRQ 22, and then the pointer is removed from the in-order queue 30. When the transaction is completed, the BIU clears the valid flag for the transaction's BRQ entry so that the entry can be used for another transaction.
When the cache 42 sends a new SWC transaction request (S20), the BIU compares the address of the new request with all write-combine requests currently stored in the BRQ (S22). If the address of the new SWC request does not fall within the address range of a stored write-combine request, the first priority encoder 24 allocates an empty BRQ entry for the SWC request in the manner described above (S24). Additionally, the mode flag for the selected BRQ entry is set and the counter value is incremented because the entry is storing a write-combine request (S26). While the received SWC request contains less than a full line of data (e.g., 1 to 8 bytes), the write-combine entry is stored with a data size of one line (e.g., 32 byte) and with its address aligned on a line address boundary. Therefore, the BIU must set byte-enable flags to indicate the valid data bytes in the entry (S26). (The byte-enable flags occupy a portion of the entry that would be used to hold control information for an in-order transaction, as described above.)
On the other hand, if the address of the new SWC request falls within the address range of a stored write-combine request, then the load signal of the first priority encoder 24 is inhibited to prevent the allocation of a BRQ entry to the incoming request (S28). Additionally, the data from the new request is written into the data portion of the stored write-combine request and the corresponding byte-enable flags are set (S30).
When a triggering event requires that a write-combine entry be written to memory, the ready flag for the entry is set. In particular, the ready flag for one write-combine entry is set if a read request overlaps the address range of the entry, or if mergers cause all of the byte-enable flags for the entry to be set (i.e., if the entry becomes full). Further, the ready flags for all write-combine entries in the BRQ are simultaneously set if the counter value reaches a predetermined threshold, or if an I/O or special synchronizing request is received. Once a write-combine entry's ready flag is set, other SWC requests are prevented from merging with that entry so that the data to be written does not change while the BRG is issuing the transaction. Additionally, the counter value is decremented whenever a single ready flag is set and is reset to zero whenever all ready flags are set. This allows the counter to accurately keep track of the number of "waiting" write-combine entries (i.e., those that have not already been marked for issuance to the system bus).
The second priority encoder 26 OR's together the ready flags for all write-combine entries so that whenever one or more ready flags are set, a transaction request is sent to the BRG 32. When the BRG is ready to service the write-combine request, the second priority encoder 26 selects one of the write-combine entries (via the multiplexers 34 and 36) based on the set ready flags and a priority scheme. The BRG examines the byte-enable flags for the selected write-combine entry. If all byte-enable flags are set, the BRG issues a BWL and all of the entry's data is written to memory in one transaction. Alternatively, if all byte-enable flags are not set, the BRG issues one or more BWPs to the system bus so as to write only the entry's valid data bytes to memory. When all bus transactions spawned by the write-combine entry are completed, the BIU clears the valid flag for the entry so that it can be used for another transaction.
As previously explained, the present invention provides a bus interface unit that increases performance through the efficient handling of combinable write requests. A single random-access transaction buffer is used to store the necessary information for all bus transactions requested by the CPU or cache. An ordering queue stores pointers to entries in the transaction buffer that store in-order transaction requests, and a mode flag is set for entries that store combinable write requests. Because of this single buffer/pointer ordering queue/mode flag structure, any buffer entry can be used for storing a write-combine request and the total number of entries available for write-combine requests is dynamic. This increases the number of separate write-combine entries that can simultaneously exist so as to create a greater opportunity for the combining of write requests. At the same time, the need for a dedicated combining buffer is eliminated. Thus, the BIU of the present invention efficiently adapts to the mix of transactions that are presented during program execution.
Further, in preferred embodiments, the BIU includes a counter that keeps track of the total number of write-combine entries in the transaction buffer. This allows the BIU to prevent deadlock by monitoring and limiting the number of incomplete write-combine entries stored in the transaction buffer. Additionally, some embodiments of the present invention make dual use of a portion of the transaction buffer. One portion of the transaction buffer is used to hold address and control information for in-order transaction entries and the byte-enable flags for write-combine entries. This dual use eliminates the need for dedicated byte-enable flags, and thus prevents an increase in chip area.
The embodiments of the present invention described above relate to a computer system having PentiumŪ-type processors and a system bus that operates in accordance with the PentiumŪ II bus protocol. However, the bus interface unit of the present invention could be implemented in a system that utilizes a different type of processor and/or a different bus protocol. Similarly, while the above embodiments are described in relation to a multiple processor computer system, single or multiple processor computer system having varying features and abilities could be implemented with the bus interface unit of the present invention. Further, some embodiments of the present invention may not include dedicated circuitry for requesting issuance of write-combine requests. (For example, in one embodiment, a pointer to a write-combine entry is placed in the in-order queue when the entry is "ready" to be issued.)
Additionally, other design choices, such as the computer system's architecture, the number of in-order queues and the use of each, the number of entries in the transaction buffer and each in-order queue, the format of the transaction buffer entries and flags, and the transaction selection and deadlock prevention mechanisms could easily be adapted by one of ordinary skill in the art. Furthermore, embodiments of the present invention may not include all of the features described above. For example, the dual purpose address/control field, the write-combine entry counter, and the cache subsystem may not be included in all embodiments.
While there has been illustrated and described what are presently considered to be the preferred embodiments of the present invention, it will be understood by those skilled in the art that various other modifications may be made, and equivalents may be substituted, without departing from the true scope of the invention. Additionally, many modifications may be made to adapt a particular situation to the teachings of the present invention without departing from the central inventive concept described herein. Therefore, it is intended that the present invention not be limited to the particular embodiments disclosed, but that the invention include all embodiments falling within the scope of the appended claims.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US5185869 *||Feb 5, 1990||Feb 9, 1993||Nec Corporation||System for masking execution ready signal during unsettled period of determining branch condition to prevent reading out of stored instructions|
|US5526495 *||Aug 23, 1993||Jun 11, 1996||Fujitsu Limited||Bus control system in a multi-processor system|
|US5737566 *||Dec 20, 1993||Apr 7, 1998||Motorola, Inc.||Data processing system having a memory with both a high speed operating mode and a low power operating mode and method therefor|
|US5778431 *||Dec 19, 1995||Jul 7, 1998||Advanced Micro Devices, Inc.||System and apparatus for partially flushing cache memory|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US6449701 *||Sep 20, 2000||Sep 10, 2002||Broadcom Corporation||Out of order associative queue in two clock domains|
|US6559852 *||Jul 31, 1999||May 6, 2003||Hewlett Packard Development Company, L.P.||Z test and conditional merger of colliding pixels during batch building|
|US6591325 *||Apr 11, 2000||Jul 8, 2003||Hitachi, Ltd.||Method and apparatus of out-of-order transaction processing using request side queue pointer and response side queue pointer|
|US6628292 *||Jul 31, 1999||Sep 30, 2003||Hewlett-Packard Development Company, Lp.||Creating page coherency and improved bank sequencing in a memory access command stream|
|US6629218||Jul 9, 2002||Sep 30, 2003||Broadcom Corporation||Out of order associative queue in two clock domains|
|US6633298 *||Jul 31, 1999||Oct 14, 2003||Hewlett-Packard Development Company, L.P.||Creating column coherency for burst building in a memory access command stream|
|US6680737 *||Dec 12, 2002||Jan 20, 2004||Hewlett-Packard Development Company, L.P.||Z test and conditional merger of colliding pixels during batch building|
|US7089364 *||Apr 15, 2004||Aug 8, 2006||International Business Machines Corporation||System and method to stall dispatch of gathered store operations in a store queue using a timer|
|US7181561 *||Jun 19, 2003||Feb 20, 2007||Advanced Micro Devices, Inc.||Ordering rule controlled command storage|
|US7200715 *||Mar 21, 2002||Apr 3, 2007||Network Appliance, Inc.||Method for writing contiguous arrays of stripes in a RAID storage system using mapped block writes|
|US7206865 *||Mar 28, 2003||Apr 17, 2007||Intel Corporation||Apparatus and method for combining writes to I/O|
|US7269709||Oct 11, 2002||Sep 11, 2007||Broadcom Corporation||Memory controller configurable to allow bandwidth/latency tradeoff|
|US7305526 *||Nov 5, 2004||Dec 4, 2007||International Business Machines Corporation||Method, system, and program for transferring data directed to virtual memory addresses to a device memory|
|US7353301 *||Oct 29, 2004||Apr 1, 2008||Intel Corporation||Methodology and apparatus for implementing write combining|
|US7404017 *||Jan 16, 2004||Jul 22, 2008||International Business Machines Corporation||Method for managing data flow through a processing system|
|US7441087 *||Aug 17, 2004||Oct 21, 2008||Nvidia Corporation||System, apparatus and method for issuing predictions from an inventory to access a memory|
|US7493456||Oct 13, 2006||Feb 17, 2009||International Business Machines Corporation||Memory queue with supplemental locations for consecutive addresses|
|US7500029 *||Oct 29, 2004||Mar 3, 2009||Intel Corporation||Maximal length packets|
|US7526593 *||Oct 3, 2006||Apr 28, 2009||Nvidia Corporation||Packet combiner for a packetized bus with dynamic holdoff time|
|US7657669 *||Jun 19, 2008||Feb 2, 2010||International Business Machines Corporation||Apparatus and program storage device for managing dataflow through a processing system|
|US7676603 *||Apr 20, 2004||Mar 9, 2010||Intel Corporation||Write combining protocol between processors and chipsets|
|US7840758 *||Mar 22, 2007||Nov 23, 2010||International Business Machines Corporation||Variable store gather window|
|US7930475||Feb 22, 2007||Apr 19, 2011||Netapp, Inc.||Method for writing contiguous arrays of stripes in a RAID storage system using mapped block writes|
|US7970989 *||Jun 30, 2006||Jun 28, 2011||Intel Corporation||Write ordering on disk cached platforms|
|US7979633||Apr 2, 2004||Jul 12, 2011||Netapp, Inc.||Method for writing contiguous arrays of stripes in a RAID storage system|
|US7984248 *||Dec 29, 2004||Jul 19, 2011||Intel Corporation||Transaction based shared data operations in a multiprocessor environment|
|US8176266 *||Nov 10, 2010||May 8, 2012||Intel Corporation||Transaction based shared data operations in a multiprocessor environment|
|US8356128||Sep 16, 2008||Jan 15, 2013||Nvidia Corporation||Method and system of reducing latencies associated with resource allocation by using multiple arbiters|
|US8356142 *||Nov 12, 2003||Jan 15, 2013||Nvidia Corporation||Memory controller for non-sequentially prefetching data for a processor of a computer system|
|US8356143||Oct 22, 2004||Jan 15, 2013||NVIDIA Corporatin||Prefetch mechanism for bus master memory access|
|US8370552||Oct 14, 2008||Feb 5, 2013||Nvidia Corporation||Priority based bus arbiters avoiding deadlock and starvation on buses that support retrying of transactions|
|US8386648||Dec 1, 2003||Feb 26, 2013||Nvidia Corporation||Hardware support system for accelerated disk I/O|
|US8468278||Dec 28, 2007||Jun 18, 2013||Intel Corporation||Methods and apparatuses for flushing write-combined data from a buffer|
|US8595394||Dec 1, 2003||Nov 26, 2013||Nvidia Corporation||Method and system for dynamic buffering of disk I/O command chains|
|US8683132||Sep 29, 2003||Mar 25, 2014||Nvidia Corporation||Memory controller for sequentially prefetching data for a processor of a computer system|
|US8694688||Dec 28, 2007||Apr 8, 2014||Nvidia Corporation||Disk controller for implementing efficient disk I/O for a computer system|
|US8698823||Apr 8, 2009||Apr 15, 2014||Nvidia Corporation||System and method for deadlock-free pipelining|
|US8700808||Dec 28, 2007||Apr 15, 2014||Nvidia Corporation||Hardware support system for accelerated disk I/O|
|US20030182502 *||Mar 21, 2002||Sep 25, 2003||Network Appliance, Inc.||Method for writing contiguous arrays of stripes in a RAID storage system|
|US20030217244 *||Oct 11, 2002||Nov 20, 2003||Kelly James Daniel||Memory controller configurable to allow bandwidth/latency tradeoff|
|US20040107306 *||Jun 19, 2003||Jun 3, 2004||Advanced Micro Devices, Inc.||Ordering rule controlled command storage|
|US20050160205 *||Jan 16, 2004||Jul 21, 2005||International Business Machines Corporation||Method, apparatus and program storage device for managing dataflow through a processing system|
|US20050235067 *||Apr 20, 2004||Oct 20, 2005||Intel Corporation||Write combining protocol between processors and chipsets|
|US20050251622 *||Apr 15, 2004||Nov 10, 2005||International Business Machines Corp.||Method to stall store operations to increase chances of gathering full entries for updating cachelines|
|US20060095609 *||Oct 29, 2004||May 4, 2006||Sivakumar Radhakrishnan||Methodology and apparatus for implementing write combining|
|US20060095677 *||Aug 17, 2004||May 4, 2006||Hakura Ziyad S||System, apparatus and method for issuing predictions from an inventory to access a memory|
|US20060101226 *||Nov 5, 2004||May 11, 2006||Benhase Michael T||Method, system, and program for transferring data directed to virtual memory addresses to a device memory|
|US20060161740 *||Dec 29, 2004||Jul 20, 2006||Sailesh Kottapalli||Transaction based shared data operations in a multiprocessor environment|
|US20060168384 *||Oct 29, 2004||Jul 27, 2006||Sivakumar Radhakrishnan||Maximal length packets|
|US20070079044 *||Oct 3, 2006||Apr 5, 2007||Nvidia Corporation||Packet Combiner for a Packetized Bus with Dynamic Holdoff time|
|US20080005465 *||Jun 30, 2006||Jan 3, 2008||Matthews Jeanna N||Write ordering on disk cached platforms|
|US20080091881 *||Oct 13, 2006||Apr 17, 2008||Ibm Corporation||Method and apparatus for queuing memory access commands in a memory queue of an information handling system|
|US20080177914 *||Dec 28, 2007||Jul 24, 2008||Nvidia Corporation||Hardware support system for accelerated disk I/O|
|US20080177925 *||Dec 28, 2007||Jul 24, 2008||Radoslav Danilak||Hardware support system for accelerated disk I/O|
|US20080313368 *||Jun 19, 2008||Dec 18, 2008||International Business Machines Corporation||Apparatus and program storage device for managing dataflow through a processing system|
|US20090031058 *||Dec 28, 2007||Jan 29, 2009||Sivakumar Radhakrishnan||Methods and Apparatuses for Flushing Write-Combined Data From A Buffer|
|US20100095036 *||Oct 14, 2008||Apr 15, 2010||Nvidia Corporation||Priority Based Bus Arbiters Avoiding Deadlock And Starvation On Buses That Support Retrying Of Transactions|
|US20100259536 *||Apr 8, 2009||Oct 14, 2010||Nvidia Corporation||System and method for deadlock-free pipelining|
|CN100390764C||Sep 29, 2005||May 28, 2008||国际商业机器公司||Method and system for transferring data directed to virtual memory addressed to a device memory|
|CN100524266C||Jul 11, 2006||Aug 5, 2009||辉达公司||Method and equipment for transmitting data transmission request by packets in a bus|
|U.S. Classification||710/310, 711/E12.017|
|Aug 25, 1998||AS||Assignment|
Owner name: STMICROELECTRONICS, INC., TEXAS
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:RICHARDSON, NICHOLAS J.;REEL/FRAME:009415/0504
Effective date: 19980820
|Dec 10, 2003||FPAY||Fee payment|
Year of fee payment: 4
|Jan 22, 2008||FPAY||Fee payment|
Year of fee payment: 8
|Mar 19, 2012||REMI||Maintenance fee reminder mailed|
|Aug 8, 2012||LAPS||Lapse for failure to pay maintenance fees|
|Sep 25, 2012||FP||Expired due to failure to pay maintenance fee|
Effective date: 20120808