[0001]    This invention was made with government support under Contract No. NBCHC020056 awarded by Defense Advanced Research Projects Agency (DARPA). The government has certain rights in this invention 
     
    
     BACKGROUND OF THE INVENTION 
       [0002]    1. Technical Field 
         [0003]    The present invention relates to pre-fetch operations in multiprocessor systems, and more particularly to data subscribe-and-publish mechanisms and methods for producer-consumer pre-fetch communications. 
         [0004]    2. Discussion of Related Art 
         [0005]    Pre-fetch operations have been widely used in modern computer systems to hide memory access latencies. In a multiprocessor system, a pre-fetch operation can be a vertical pre-fetch or a horizontal pre-fetch, also referred to as producer-consumer pre-fetch. A vertical pre-fetch can retrieve data from a high-level cache such as an L3 (level 3) cache to a low-level cache such as an L2 (level 2) cache. A horizontal pre-fetch can retrieve data from a cache in a producer node to a cache in a consumer node. A pre-fetch operation may involve both vertical and horizontal operations. In an SMP (symmetric multiprocessor) system, for example, a processor can issue a pre-fetch operation that retrieves data from the L2 cache in another processing node to the L1 (level 1) cache associated with the processor. 
         [0006]    Pre-fetch operations can be invoked by software or by hardware. For example, the PowerPC® architecture comprises DCBT (data cache block touch) and DCBTST (data cache block touch for store) instructions that allow software to invoke pre-fetch operations at appropriate times. The IBM® POWER4 system comprises a data streaming pre-fetch mechanism that can, when a streaming access patterns is detected, retrieve data from the memory to an L3 cache, from the L3 cache to an L2 cache, and from the L2 cache to an L1 cache. 
         [0007]    Pre-fetch operations in multiprocessor systems are subject to various inefficiencies due to a lack of coordination between a producer that generates data and a consumer that uses the data. In multiprocessor systems, pre-fetch operations can be consumer-initiated or producer-initiated, also referred to as pre-send or cache injection. The underlying cache coherence protocol may be made more complicated to deal with data pre-send operations, because a cache can receive data without a pending data request. 
         [0008]    Regarding a consumer-initiated pre-fetch operation, if the consumer does not know when the data is to be produced at the producer side, it can be difficult for the consumer to invoke the data pre-fetch operation at an appropriate time. For example, if the consumer invokes the pre-fetch operation before the data is produced, the consumer would obtain a stale copy of the data. The stale copy of the data needs to be invalidated, resulting in extra cache coherence overhead. 
         [0009]    Regarding a producer-initiated pre-fetch operation, if the producer does not know where the potential consumer resides, it can be difficult for the producer to determine, when newly produced data becomes available, where the data should be sent to. Even assuming that the producer knows where the consumer is, the producer may not know when it should send the data. If the data sent to a consumer is not the final data that is to be produced, for example, the data is not useful to the consumer and needs to be invalidated at the consumer side. Further, if the producer sends the data too early, the cache line holding the data at the consumer side can be replaced before the data is used by the consumer. 
         [0010]    Therefore, a need exists for an effective data pre-fetch mechanism to support producer-consumer pre-fetch communications. 
       SUMMARY OF THE INVENTION 
       [0011]    According to an embodiment of the present disclosure, a system supporting producer-consumer pre-fetch communications includes a first processor, wherein the first processor is a producer node and a second processor, wherein the second processor is a consumer node. The system further includes a data subscribe mechanism for performing a data subscribe operation at the consumer node, wherein the data subscribe operation records that a memory address is subscribed at the consumer node, a data publish mechanism for performing a data publish operation at the producer node, wherein the data publish operation sends data of the memory address from the producer node to the consumer node if the memory address is subscribed at the consumer node, and a communication network coupled to the producer node and the consumer node for enabling communicating between the producer node and the consumer node. 
         [0012]    The data subscribe operation is invoked when a data subscribe instruction is executed by computer-executable code at the consumer node. The data publish operation is invoked when a data publish instruction is executed by computer-executable code at the producer node. 
         [0013]    The system includes a subscribe prediction mechanism, the subscribe prediction mechanism determining when the data subscribe operation should be invoked. The subscribe prediction mechanism determines that the data subscribe operation should be invoked, if the memory address is found in an invalid cache state in a cache at the consumer node, the memory address has been accessed recently in the consumer node, and the data publish operation has been invoked at the producer node. 
         [0014]    The system includes a publish prediction mechanism, the publish prediction mechanism determining when the data publish operation should be invoked. The publish prediction mechanism determines that the data publish operation should be invoked, if a cache line of the memory address is replaced from a cache in the producer node, and the cache line is in a modified cache state. The publish prediction mechanism determines that the data publish operation should be invoked, if the producer node sends data of the memory address to a peer node in the multiple processing nodes. 
         [0015]    According to an embodiment of the present disclosure, a computer-implemented method of using data subscribe-and-publish operations for producer-consumer pre-fetch communications over a network includes (1) performing, by a consumer, a data subscribe operation, the data subscribe operation recording that a memory address is subscribed, (2) receiving, by the consumer, data of the memory address from a producer, and (3) caching, by the consumer, the data of the memory address for future use. 
         [0016]    The method includes (1) producing, by the producer, the data of the memory address, (2) performing, by the producer, a data publish operation, the data publish operation sending the data of the memory address to the consumer if the memory address is subscribed, and (3) sending, by the producer, the data of the memory address to the consumer. 
         [0017]    Performing a data subscribe operation comprises executing a data subscribe instruction. Performing a data publish operation comprises executing a data publish instruction. Performing a data subscribe operation comprises predicting, by a subscribe prediction mechanism, that the data subscribe operation should be invoked. Performing a data publish operation comprises predicting, by a publish prediction mechanism, that the data publish operation should be invoked. 
         [0018]    According to an embodiment of the present disclosure, a program storage device is provided readable by machine, tangibly embodying a program of instructions executable by the machine to perform method steps for data subscribe and publish operations supporting producer-consumer pre-fetch operations. The method includes (1) performing, by a consumer, a data subscribe operation, the data subscribe operation is recording that a memory address is subscribed, (2) receiving, by the consumer, data of the memory address from a producer, and (3) caching, by the consumer, the data of the memory address for future use. 
         [0019]    The method includes (1) producing, by the producer, the data of the memory address, (2) performing; by the producer, a data publish operation, the data publish operation sending the data of the memory address to the consumer if the memory address is subscribed, and (3) sending, by the producer, the data of the memory address to the consumer. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0020]    Preferred embodiments of the present disclosure will be described below in more detail, with reference to the accompanying drawings: 
           [0021]      FIG. 1  is a flow chart of a method for data subscribe and publish operations according to an embodiment of the present disclosure; 
           [0022]      FIG. 2A  is a diagram of two arrays that are used in an exemplary Red/Black iteration method; 
           [0023]      FIG. 2B  is a flow chart of computation steps of two coordinating processes in the exemplary Red/Black iteration method; 
           [0024]      FIG. 3  is a diagram of a multiprocessor system that supports data subscribe and publish operations according to an embodiment of the present disclosure; and 
           [0025]      FIG. 4  is a computer system for implementing data subscribe and publish operations according to an embodiment of the present disclosure. 
       
    
    
     DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS 
       [0026]    According to an embodiment of the present disclosure, a data subscribe-and-publish mechanism can effectively support producer-consumer pre-fetch communications in multiprocessor systems. The mechanism comprises architecture support of two pre-fetch primitives, data subscribe and data publish. The data subscribe primitive allows a consumer to register its intention to obtain data of a memory address, without actually retrieving the data. The data publish primitive allows a producer to publish data of a memory address to the consumers that have subscribed the corresponding memory address. 
         [0027]      FIG. 1  shows the flow chart of using data subscribe and publish operations for producer-consumer pre-fetch communications. At the consumer side, the consumer performs a data subscribe operation for a particular memory address ( 101 ). The data subscribe operation allows the consumer to receive data of the memory address once a data publish operation is performed at the producer side. When the consumer later receives the data from the producer ( 102 ), the consumer caches the data for future use ( 103 ). At the producer side, the producer produces data of the memory address ( 104 ), and performs a data publish operation for the memory address ( 105 ). The data publish operation causes the produced data to be sent to the consumer that has subscribed the memory address ( 106 ). 
         [0028]    Consider a producer-consumer synchronization example. A lock is used as a semaphore for producer-consumer coordination so that the consumer cannot access data of a memory address before the data is produced by the producer. At the consumer side, the consumer subscribes the memory address, acquires the lock, and reads the memory is address. The subscribe operation informs the system that the consumer may need to access data of the memory address once the data is available. At the producer side, the producer writes data to the memory address, publishes the memory address, and releases the lock. The publish operation informs the system that data of the memory address has been produced and thus can be sent to the potential consumer. 
         [0000]    
       
         
               
               
               
             
           
               
                   
                   
               
               
                   
                 Consumer 
                 Producer 
               
               
                   
                   
               
             
             
               
                   
                 . . . 
                 . . . 
               
               
                   
                 Subscribe (address); 
                 Write (address, data); 
               
               
                   
                 Acquire (lock); 
                 Publish (address); 
               
               
                   
                 Read (address); 
                 Release (lock); 
               
               
                   
                 . . . 
                 . . . 
               
               
                   
                   
               
             
          
         
       
     
         [0029]    Now consider an example of a Red/Black iteration method implemented using arrays A (red) and B (black) that are updated alternatively. Referring now to  FIG. 2A , array A is partitioned into two sub-arrays A 1  and A 2 , and array B is partitioned into two sub-arrays B 1  and B 2 . Without losing generality, suppose array A contains initial data. Array B can be determined using array A: the sub-array B 1  is determined based on A 1  and boundary data from A 2  (A 2 _BORDER), and the sub-array B 2  is determined based on A 2  and boundary data from A 1  (A 1 _BORDER). Following the computation of array B, arrays A and B can switch roles. Array A can then be determined using array B: the sub-array A 1  is determined based on B 1  and boundary data from B 2  (B 2 _BORDER), and the sub-array A 2  is determined based on B 2  and boundary data from B 1  (B 1 _BORDER). 
         [0000]    
       
         
               
               
               
             
           
               
                   
                   
               
               
                   
                 Process 1 
                 Process 2 
               
               
                   
                   
               
             
             
               
                   
                 ... 
                 ... 
               
               
                   
                 Subscribe A2_border; 
                 Subscribe A1_border; 
               
               
                   
                 Subscribe B2_border; 
                 Subscribe B1_border; 
               
               
                   
                 While (true) { 
                 While (true) { 
               
               
                   
                  Compute B1 using A1 and A2_border; 
                  Compute B2 using 
               
               
                   
                   
                  A2 and A1_border; 
               
               
                   
                  Publish B1_border; 
                  Publish B2_border; 
               
               
                   
                  Barrier; 
                  Barrier; 
               
               
                   
                  Compute A1 using B1 and B2_border; 
                  Compute A2 using 
               
               
                   
                   
                  B2 and B1_border; 
               
               
                   
                  Publish A1_border; 
                  Publish A2_border; 
               
               
                   
                  Barrier; 
                  Barrier; 
               
               
                   
                 } 
                 } 
               
               
                   
                 ... 
                 ... 
               
               
                   
                   
               
             
          
         
       
     
         [0030]    Referring to  FIG. 2B , two parallel processes can be used in the determinations: process  1  determines the sub-array A 1  and B 1 , and process  2  determines the sub-array is A 2  and B 2 . The two processes coordinate with each other using synchronization barriers: when a process reaches a synchronization barrier, it cannot move forward until the other process also reaches the corresponding synchronization barrier. 
         [0031]    Since process  1  needs to access A 2 _BORDER and B 2 _BORDER for its determination, it subscribes the two memory regions ( 201 ). Process  1  determines B 1  and publishes B 1 _BORDER ( 203 ). After passing a synchronization barrier ( 205 ), process  1  determines A 1  and publishes A 1 _BORDER ( 206 ). After passing another synchronization barrier ( 208 ), process  1  repeats. 
         [0032]    At the other side, process  2  subscribes A 1 _BORDER and B 1 _BORDER ( 202 ). Process  2  determines B 2  and publishes B 2 _BORDER ( 204 ). After passing a synchronization barrier ( 205 ), process  2  determines A 2  and publishes A 2 _BORDER ( 207 ). After passing another synchronization barrier ( 208 ), process  2  repeats. 
       The Subscribe-and-Publish Software Interface 
       [0033]    According to an embodiment of the present disclosure, the system comprises primitives for software to subscribe and publish data of a memory address with proper granularity (e.g., byte, word or cache line). These primitives can be implemented as explicit instructions at the instruction set architecture level, or as additional semantics associated with appropriate existing instructions (e.g., the DCBT and DCBTST instructions in PowerPC). 
         [0034]    Subscribe (address) 
         [0035]    Publish (address) 
         [0036]    Unsubscribe (address) 
         [0037]    The effect of a subscribe operation can remain valid for some period of time. Alternatively, the effect of a subscribe operation can be sticky, wherein once a consumer subscribes an address, the subscription remains valid until an explicit unsubscribe operation is performed. It should be appreciated by those skilled in the art that when an address is subscribed, the system may return a subscription handler to software. This allows software to use the handler, instead of the memory address, when an unsubscribe operation is needed. 
         [0038]    Rather than subscribing a single memory address, software can subscribe a memory address range or even a memory address pattern. An exemplary memory address pattern is a streaming pattern represented by d*x+c, wherein x is from 0 to n, d is a constant representing the stride of a stream, and c is a constant representing the starting address of the stream. 
         [0039]    Subscribe (address_range) 
         [0040]    Publish (address_range) 
         [0041]    Unsubscribe (address_range) 
       The Subscribe-and-Publish Architecture Support 
       [0042]    In multiprocessor systems such as CMP (chip multiprocessor) and SMP systems, architecture support for subscribe and publish operations can be seamlessly integrated with the underlying cache coherence support. 
         [0043]    Referring now to  FIG. 3 , a multiprocessor system comprises a consumer node ( 300 A) and a producer node ( 300 B). The consumer node ( 300 A) comprises a processor ( 301 ), a cache controller ( 302 ), a cache ( 303 ) and a subscription table ( 304 ). Likewise, the producer node ( 300 B) comprises a processor ( 305 ), a cache controller ( 306 ), a cache ( 307 ) and a subscription table ( 308 ). The consumer node ( 300 A) and the producer node ( 300 B) can communicate with each other via a network ( 309 ). 
         [0044]    In an exemplary embodiment of the present disclosure, the data subscribe and publish primitives can be implemented as follows. At the consumer side, when a subscribe operation is performed, the cache controller ( 302 ) at the consumer side records the subscribed memory address in the subscription table ( 304 ). The subscription table can record either the actual memory address, or a signature of the subscribed memory address, wherein the signature can be generated using one or more predefined hash functions. It should be noted that, if the memory address is found in the cache (although data of the memory address may be invalid in the cache), rather than recording the memory address in the subscription table, the cache controller can mark the corresponding cache line, indicating that the corresponding cache line has been subscribed. This allows a subscribed address to be recorded in the directory of the cache, which may reduce storage needed for the subscription table. 
         [0045]    At the producer side, when a publish operation is performed, the cache controller ( 306 ) at the producer side sends a publish transaction to all peer caches in the system, or a subset of all peer caches in the system. When the consumer receives the publish transaction, its cache controller ( 302 ) snoops its cache directory and checks the corresponding subscription table ( 304 ) to determine if the memory address is subscribed. The cache controller ( 302 ) then sends a snoop response back to the producer, indicating whether the memory address is subscribed. When the producer receives snoop responses from all peer caches (or a subset of all peer caches in the system), it determines whether there exists at least one potential consumer that has subscribed the memory address. If the memory address is subscribed, the cache controller ( 306 ) at the producer side can send data to those caches that have indicated their intention of obtaining the data in their snoop responses. 
         [0046]    It should be appreciated by those skilled in the art that, instead of sending a publish transaction, the producer can associate semantics of the publish transaction with a cache coherence message. For example, if the producer needs to send an invalidate request to all peer caches to obtain the exclusive ownership of a cache line, the producer can piggyback the publish transaction to the invalidate request. Further, when the producer receives subscription information regarding potential consumers that have subscribed a memory address, the producer can maintain the subscription information in a temporary buffer for future use to avoid sending another publish transaction later. 
         [0047]    Since subscribe and publish operations are heuristic operations that cannot comprise correctness of the system, the subscription table can, if needed, treat a subscribed memory address as subscribed, and treat an unsubscribed address as subscribed. For example, if the subscription table records actual memory addresses, the subscription table can be full when a new memory address needs to be subscribed. In this case, the subscription table can remove a previously subscribed address according to a proper replacement policy so that the new memory address can be recorded in the subscription table. 
         [0048]    An exemplary implementation of a subscription table recording signatures of memory addresses comprises a bit vector that can be indexed by one or more hash functions. When a memory address needs to be subscribed, the cache controller sets the corresponding one or more bits in the bit vector. Given a memory address, the cache controller can predict with some probability that the memory address is subscribed if the corresponding one or more bits are all set. 
         [0049]    Instead of relying on software to initiate subscribe and publish operations, the system can have build-in hardware support to dynamically initiate subscribe and publish operations. For example, the system can comprise a subscribe prediction mechanism that predicts when a consumer should subscribe a given memory address. Further, the system can comprise a publish prediction mechanism that predicts when a producer should publish data of the memory address. 
         [0050]    In an illustrative embodiment of the present disclosure, the system employs a subscribe prediction mechanism to predict whether an address is subscribed when a publish transaction is observed from network. A cache line is enhanced with reference information that indicates whether the cache line has been used since the data is brought to the cache. When data is first brought into the cache, its reference information indicates that the data has not been accessed yet. Each time the cache line is accessed, the reference information is set to indicate that the data has been used. The cache controller periodically clears the reference information. If the cache line is invalidated, the reference information remains, the reference information is lost if the cache line is used to hold data for another address. The reference information can be maintained using a reference bit or encoded with existing cache states. 
         [0051]    When a publish transaction is received from the network, the cache controller snoops its cache directory. If the address is found (although the data is invalid) and the corresponding reference information shows that the data was used recently before it was invalidated, then the cache controller predicts that the address is subscribed. As a result, the snoop response indicates that the address is subscribed so that the producer should send the data. This subscribe prediction mechanism works well for producer-consumer pre-fetch communications if the set of consumers remain stable, and cache capacity miss rate is low so that an invalidated cache line can maintain its reference information. 
         [0052]    According to an exemplary embodiment of the present disclosure, the system can employ a publish prediction mechanism to predict when a publish operation of a memory address needs to be performed. An exemplary publish prediction mechanism can predict a publish operation if a modified cache line is cast-out from the cache due to a cache line replacement. As a result, the cache controller can send a publish transaction to consult peer caches whether any of them has subscribed the memory address. Furthermore, the publish prediction mechanism can predict a publish operation if the cache is to supply data to another cache. Consider a scenario in which a consumer issues a memory read transaction that hits a modified cache line in a producer. In an SMP system, the consumer sends a read request to all peer caches (or a subset of all peer caches, depending on the underlying cache coherence protocol). When a cache receives the read request, the cache can indicate in its snoop response whether the address is subscribed. Thus, when all snoop responses are received, the consumer knows in which peer caches the address has been subscribed. The consumer can then send the data, or notify the producer to send the data, to the peer peers in which the address is subscribed. 
         [0053]    It is to be understood that the present invention may be implemented in various forms of hardware, software, firmware, special purpose processors, or a combination thereof. In one embodiment, the present invention may be implemented in software as an application program tangibly embodied on a program storage device. The application program may be uploaded to, and executed by, a machine comprising any suitable architecture. 
         [0054]    Referring to  FIG. 4 , according to an embodiment of the present invention, a computer system ( 401 ) for implementing data subscribe and publish operations to support producer-consumer pre-fetch communications can comprise, inter alia, a central processing unit (CPU) ( 402 ), a memory ( 403 ) and an input/output (I/O) interface ( 404 ). The computer system ( 401 ) is generally coupled through the I/O interface ( 404 ) to a display ( 405 ) and various input devices ( 406 ) such as a mouse and keyboard. The support circuits can include circuits such as cache, power supplies, clock circuits, and a communications bus. The memory ( 403 ) can include random access memory (RAM), read only memory (ROM), disk drive, tape drive, or a combination thereof. The present invention can be implemented as a routine ( 407 ) that is stored in memory ( 403 ) and executed by the CPU ( 402 ) to process the signal from the signal source ( 408 ). As such, the computer system ( 401 ) is a general-purpose computer system that becomes a specific-purpose computer system when executing the routine ( 407 ) of the present invention. 
         [0055]    The computer platform ( 401 ) also includes an operating system and micro instruction code. The various processes and functions described herein may either be part of the micro instruction code, or part of the application program (or a combination thereof) which is executed via the operating system. In addition, various other peripheral devices may be connected to the computer platform such as an additional data storage device and a printing device. 
         [0056]    It is to be further understood that, because some of the constituent system components and method steps depicted in the accompanying figures may be implemented in software, the actual connections between the system components (or the process steps) may differ depending upon the manner in which the present invention is programmed. Given the teachings of the present invention provided herein, one of ordinary skill in the related art will be able to contemplate these and similar implementations or configurations of the present invention. 
         [0057]    Having described embodiments for a mechanism and method for data subscribe and publish operations to support producer-consumer pre-fetch communications, it is noted that modifications and variations can be made by persons skilled in the art in light of the above teachings. It is therefore to be understood that changes may be made in the particular embodiments of the invention disclosed which are within the scope and spirit of the disclosure.
A system supporting producer-consumer pre-fetch communications includes a first processor, wherein the first processor is a producer node, and a second processor, wherein the second processor is a consumer node. The system further includes a data subscribe mechanism for performing a data subscribe operation at the consumer node, wherein the data subscribe operation records that a memory address is subscribed at the consumer node, a data publish mechanism for performing a data publish operation at the producer nod; wherein the data publish operation sends data of the memory address from the producer node to the consumer node if the memory address is subscribed at the consumer node, and a communication network coupled to the producer node and the consumer node for enabling communicating between the producer node and the consumer node.