KR100319708B1 - Shared memory multi-processor system by employing a direction separated dual ring architecture - Google Patents

Abstract

The present invention relates to a multiprocessor system of distributed shared memory architecture, and includes a point-to-point bidirectional split double ring that supports snooping to connect multiple clusters together. The direction-separated double ring of the present invention provides a first direction and a first direction for transmitting a data request signal received from a neighboring cluster at a front end to a neighboring cluster at a later end along a first direction or a second direction, depending on a property of a data block. It has a two-way ring. Thus, the present invention has the effect of providing better performance than the method of simply doubling the ring bandwidth in the form of a single ring while maintaining cache coherency between clusters in a snooping manner.

Description

SHARED MEMORY MULTI-PROCESSOR SYSTEM BY EMPLOYING A DIRECTION SEPARATED DUAL RING ARCHITECTURE}

The present invention relates to a multi-processor system, and more particularly to a multi-processor system of a direction separation double ring structure.

In general, multiprocessor systems share a memory with a distributed-memory architecture that implements interprocessor communication using explicit message-passing, providing a single system image. The most popular technology among the interconnection networks of shared memory multiprocessor systems is the shared bus. Shared buses are widely used for their low implementation complexity and low cost, but they do not keep up with the speed of processors that are rapidly improving performance. In addition, there is a problem in bus bandwidth due to scalability due to the physical characteristics of the bus and increase in bus usage.

Several attempts have been made to overcome these limitations of the bus structure. Among them, IEEE SCI using a unidirectional point-to-point link has been established as a standard. Up to four processors are clustered in the form of UMA (Uniform Memory Access) by a snooping bus in a one-way ring structure using SCI links, and commercialized systems using directory-based cache protocols are Tom Lovett and Russell. Clapp's STNG: A CC-NUMA Computer System for the Commercial Marketplace (In Proceedings of the 23th International Symposium on Computer Architecture, pp. 308-317, May 1996).

As a further improvement of the above-described system, as shown in FIG. A multiprocessor system implemented using the cache protocol was developed by Jung Sung-woo, Jang Sung-tae, and Jeon-Sik's 'PANDA: Ring-Based Multiprocessor System using New Snooping Protocol' (In The Proceeding of ICPADS '98, pp. 10-17, Dec. 1998) ( (See Patent Application No. 97-40083, filed Aug. 22, 1997), and the system shown in FIG. 1 performs as compared to prior art systems using the directory cache coherence method as described above. Much superior has been announced.

However, as the clock speeds of processors and local buses continue to improve, the existing SCI-based one-way point-to-point links described in FIG. Due to the performance and scalability problems, the single point-to-point link bandwidth expansion is required in the system of FIG.

There may be a simpler way to use a link with twice the bandwidth, but it is currently impossible to develop a new link with twice the bandwidth and apply its commercialized product in a short time. The need arises to transmit the amount of traffic over both links.

Therefore, the present invention provides a distributed shared memory multiprocessor system in a direction-separated double ring structure that can achieve better performance than simply doubling the ring bandwidth in the form of a single ring while maintaining cache coherency between clusters in a snooping manner. To provide that purpose.

A multiprocessor system of distributed shared memory architecture according to the present invention for achieving the above object includes: a plurality of clusters and a point-to-point bidirectional split double ring that connects the plurality of clusters to each other and supports snooping;

Each of the clusters snoops whether a data block containing instructions or data corresponding to a data request signal generated from a neighboring cluster in the preceding stage is stored in a valid state in its cluster, and the data block is stored in a valid state. Provide the data block to the data request cluster, when the requested data block is not stored in a valid state in its cluster, and forward the data request signal to a subsequent neighboring cluster;

The direction-separated double ring may include a first direction and a second direction ring for selectively transmitting the data request signal to the neighboring cluster at the rear end in a first direction or a second direction according to an attribute of the data block. It features.

Each said cluster according to a preferred embodiment of the present invention comprises: a plurality of processors; Local shared memory; Remote cache; In response to a data request signal from a processor in the cluster, if the data block is stored in the remote cache or the local shared memory in a valid state, and is stored in the remote cache or the local shared memory in a valid state. A node controller for delivering the corresponding data block retrieved therefrom to the processor and providing the data request signal to the next neighboring cluster when it is not stored in the remote cache or local shared memory in a valid state; Interworking between the node controller and the directional detached double ring to serve as a data path connecting each of the clusters to a directional detached double ring, the data request signal from the processor being transmitted through the node controller to the data block. A link controller that selectively passes the first or second directional ring to the next neighboring cluster and provides the data block to the node controller according to an attribute; And a local system bus that interconnects the processor with a local shared memory and a node controller.

1 is a block diagram of a distributed shared memory multiprocessor system using a single ring of a prior art snooping method.

Figure 2 is an overall configuration diagram showing an embodiment of a distributed shared memory multiprocessor system using a direction-oriented double ring in accordance with the present invention

3A and 3B are views for explaining the operation of an embodiment of the present invention of the multiprocessor system according to the present invention shown in FIG.

4A, 4B, 4C, and 4D are schematic diagrams illustrating another embodiment of a cluster of distributed shared memory multiprocessor systems using directional split dual rings of the present invention.

<Explanation of symbols for the main parts of the drawings>

100A, 100B: Processor 130: Link Bus

140: local system bus 150: node controller

160A, 160B: Link Controller 170: Remote Cache

172A, 172B: Remote Tag Cache 176: Remote Data Cache

180: I / O bridge 300: local shared memory

310: data memory 320A, 320B: memory directory

500A to 500H: Cluster 510A, 510B: Directional split double ring

Hereinafter, the present invention will be described in detail with reference to the accompanying drawings.

Referring to FIG. 2, shown is a multiprocessor system of distributed shared memory architecture coupled with point-to-point directional split dual rings that support snooping in accordance with one embodiment of the present invention.

The multiprocessor system of the present invention includes a plurality of clusters 500A-500H, each cluster 500A-500H being connected to a point-to-point split double ring 510A, 510B that supports snooping. In the present invention, the term directional split double ring is bidirectional configured to transmit a data request signal from a cluster or a corresponding retrieved data block in a first direction having a closest path or in a second direction opposite to the first direction. Means a detachable double ring. The direction-separated double rings 510A and 510B transmit data blocks retrieved from the cluster according to the data request signal of the cluster and the data request signal in the first direction or the second direction according to the attributes of the data blocks, respectively. It consists of a one-way ring 510A and a second directional ring 510B. The attribute of the data block that is the classification criterion of the first directional ring 510A or the second directional ring 510B is whether the data block containing the data requested from the cluster is a data block stored at an even memory address, or as described below. This is determined by the data block stored in the odd memory address.

Referring to the left side of FIG. 2, the configuration of any one cluster among clusters 500A to 500H having the same configuration as each other, for example, the cluster 500A is illustrated in more detail. As shown, the cluster 500A includes a plurality of processors (100A to 100B) having a cache, a local shared memory (300), a plurality of I / O bridges (180), a node controller (150), a link controller ( 160 and Remote Access Cache (RAC) 170, wherein the processors 100A to 100B and local shared memory 300, I / O bridge 180, and node controller 150 are local system buses. Connected via 140. In addition, the link controller 160 composed of a pair of link controllers 160A and 160B is connected to the node controller 150 through the link bus 130, and each cluster 500A to 500H is directionally separated from the double ring 510A. , 510B).

The node controller 150 may include a remote cache 170 or a cluster 500A including a block (hereinafter, referred to as a data block) that includes instructions or data corresponding to a data request signal from the processors 100A to 100B of the cluster 500A. Search whether it is stored in the local shared memory 300 in the valid state. As a result of the search, if it is stored in the remote cache 170 in a valid state, the node controller 150 provides the corresponding data block stored in the remote cache 170 to the processors 100A to 100B, but not to the remote cache 170. When not stored and stored in the local shared memory 300 in a valid state, the local shared memory 300 causes the data block to be provided. If the data block is not stored in the remote cache 170 or the local shared memory 300 in a valid state, if the block including the requested data is an odd block, the request is transmitted through the first link controller 160A. Transmit to first directional ring 510A. If the block containing the requested data is an even block, a request for the even block is transmitted to the second directional ring 510B through the second link controller 160B (hereinafter, referred to as a ring for transmitting a request for odd blocks). A link controller for interfacing a first directional ring or an odd ring 510A, a ring for transmitting a request for an even block with a second directional ring or an even ring 510B, an odd ring 510A, or a first or odd link controller ( 160A), the link controller that interfaces with the even ring 510B is referred to as a second or even link controller 160B.) The node controller 150 is thus connected via the odd link controller 160A and the even link controller 160B. Other clusters 500B-500H serve to send a request signal for that block.

In other words, when the node controller 150 receives the data block request signal from the other clusters 500B to 500H through the odd link controller 160A or the even link controller 160B, the data block corresponding to the request signal is received. Search whether it is stored in its remote cache 170 or local shared memory 300 in a valid state. At this time, if the search result is stored in the valid state in the remote cache 170, the request signal through the odd ring 510A or even ring 510B having the path closest to the cluster (500B to 500H) requesting the block. The corresponding data block stored in the remote cache 170 is transmitted to the other clusters 500B to 500H. If it is found that valid data is stored in the local shared memory 300, the node controller 150 transmits a request for the block through the local system bus 140 to the corresponding node from the local shared memory 300. The data block is provided to the other clusters 500B to 500H that have received the request signal through the odd ring 510A or the even ring 510B having the path closest to the clusters 500B to 500H that requested the block. To be transmitted.

In addition, according to the present invention, each cluster 500A to 500H further includes a memory directory 320 that stores state information about data blocks stored in the local shared memory 300. The memory directory 320 allows the node controller 150 to effectively retrieve the state in which the data blocks requested from the processors 100A to 100B are stored in the local shared memory 300 and from other clusters 500B to 500H. It effectively searches for the state in which the requested data block is stored in its local shared memory 300. More preferably, memory directory 320 is comprised of two independent memory directories 320A, 320B, as shown in FIG. 2, to provide locality from processors 100A to 100B connected via local system bus 140. The shared memory 300 access request and the link controllers 160A and 160B may process the local shared memory 300 access request from neighbor clusters 500B to 500H in parallel.

Each link controller 160A, 160B performs a data path function that connects the cluster 500A to directional split dual rings 510A, 520B. The link controllers 160A and 160B construct a request signal or data block from the node controller 150 into packets and transmit the packets to the other clusters 500B to 500H through the odd ring 510A or the even ring 510B. Through the odd ring 510A or the even ring 510B, not only the request signal or data block transmitted from the other clusters 500B to 500H is selected and transmitted to the node controller 150, but also all the flow control necessary for packet transmission is transmitted. Responsible. In addition, if the request signal being transmitted is a broadcast packet, the link controllers 160A and 160B not only transmit the request signal to the node controller 150 for snooping but also bypass the received packet to the neighbor cluster 500B or 500H. It bypasses the role. More specifically, the link controllers 160A and 160B bypass the broadcast request transmitted from the neighbor cluster 500H through the odd ring 510A to another neighbor cluster 500B through the odd ring 510A. The broadcast request transmitted from the neighbor cluster 500B through the even ring 510B is bypassed to another neighbor cluster 500H through the even ring 510B.

Meanwhile, the remote cache 170 in the cluster 500A is a cache that caches only data blocks corresponding to an area of local shared memory (hereinafter referred to as remote shared memory) in the other clusters 500B to 500H except itself. In the case of a request for a data block corresponding to a remote shared memory area from the processors 100A and 100B connected to the local system bus 140, the block is allocated to the remote cache 170 and the local shared memory 300 is allocated. Blocks in the area are not cached. The remote cache 170 of the cluster 500A can be configured to operate relatively small and fast by caching only data blocks corresponding to the remote shared memory area in the other clusters 500B to 500H.

The remote cache 170 applies MLI property (Multi-Level Inclusion Property) to the caches in the processors 100A to 100B in the cluster 500A and the memory area of the remote shared memory portion in the other clusters 500B to 500H. As it satisfies, it has the function of Snoop filtering on the remote shared memory reference request signal from other clusters 500B to 500H. In this case, the MLI property means that a data block stored in the cache of the lower layer is always stored in the cache of the upper layer. Therefore, when the cache block of the upper layer is replaced, the corresponding block is replaced. You must ensure that no cache in any of these lower layers is present in a valid state.

Accordingly, the remote cache 170 stores the remote data blocks stored in a valid state in the internal cache of the processors 100A to 100B of the cluster 500A, and the remote shared memory reference request signal from the other clusters 500B to 500H. If the data block is not stored in the remote cache 170 in a valid state, the local system bus 140 is responsible for the snooping filtering function that does not need to send a request for the data block.

In this case, the remote cache 170 preferably stores the contents of the data block as shown in FIG. 2, and the remote tag cache 172 stores a part of the state and address of the data block. In this case, the data block stored in the remote data cache 176 may be updated, or the data block may be easily provided if necessary. More preferably, the remote tag cache 172 storing the address and the state for the remote data block is comprised of two independent remote tag caches 172A and 172B, which are connected to the local system bus 140 by a processor ( Remote cache 170 access requests from 100A to 100B and remote cache 170 access requests from neighboring clusters 500B to 500H may be handled in parallel via link controllers 160A and 160B.

The operation of the distributed shared memory multiprocessor system of the direction-separated dual ring structure of the present invention configured as described above is described in detail as follows with reference to FIG. In describing the operation of the multi-processor system of the directional split dual ring structure according to the present invention, the data block stored in the remote cache 170 has the following four states: 'Modified' and 'Modified'. -Shared ',' Shared ',' Invalid 'state.

* Update: The data block is valid and updated, the only valid copy.

Update-Shared: The data block is valid and updated, and another remote cache may be sharing the data block.

* Share: The data block is valid and another remote cache may be sharing the data block.

* Invalid: The data block is invalid.

In addition, in describing the operation of the multiprocessor system according to the present invention, the cache coherency traffic for the local shared memory 300 access request transmitted through the local system bus 140 is minimized and the dual ring 510A, 510B is transferred to the dual ring 510A, 510B. Memory directories 320A, 320B are C, S, G to reduce unnecessary transactions, handle requests from local system bus 140, and generate snooping results for snooping requests from dual rings 510A, 510B. It describes the case of maintaining three states of.

* C (Clean): The data block is not stored in a valid state in the remote cache of another cluster.

* S (Shared): The data block is valid and may be stored in a valid state that is not updated in the remote cache of another cluster.

* G (Gone): The data block is not valid and is stored in the updated valid state in the remote cache of another cluster.

On the other hand, all the communication on the direction-separated double ring (510A, 510B) connecting each cluster (500A to 500H) is made through a packet, the packets are a request packet corresponding to the request signal, a response packet corresponding to the response signal, a recognition signal Can be classified into a recognition packet corresponding to The request packet is a packet sent by a cluster requiring a transaction to the dual rings 510A and 510B. The request packet may be divided into a broadcast packet and a unicast packet. Is snooped by.

A response packet is always sent in a single packet generated by the response cluster that receives the request packet in response to the request, and an acknowledgment packet is generated by the receiving cluster in recognition of the single transmission packet and transmitted to the sending cluster. A cluster that transmits a single transport packet maintains information about the transport packet after the packet is transmitted until an acknowledgment packet arrives. If a request for the same block is received from another cluster before the acknowledgment packet arrives, Therefore, a single retry request packet is sent to the cluster.

3A and 3B, for a memory read reference request from one processor 100A of cluster 500A, the corresponding data block corresponds to the remote shared memory region and is not stored in the remote cache 170 in a valid state. In the case, cluster 500A broadcasts a read request packet for that block to other clusters 500B through 500H via directional split dual ring 510A or 510B. In addition, even if the corresponding data block corresponds to the area of the local shared memory 300 of the cluster 500A, but is not stored in the valid state of the local shared memory 300, the cluster 500A may use the direction-separated double ring 510A, 510B broadcasts the read request packet for that block to other clusters 500B-500H. At this time, if the requested block is an odd block, a read broadcast request for the block is transmitted through the odd ring controller 510A via the odd link controller 160A (see FIG. 2). In the case of the even block, the even ring controller 160B is used. A read broadcast request for the block is transmitted through the even ring 510B via (see FIG. 2).

Accordingly, the read broadcast request packet for the odd block is sequentially traversed from the cluster 500B to the cluster 500H side along the odd ring 510A as shown in FIG. The read broadcast request packet is sequentially traversed from the cluster 500H to the cluster 500B along the even ring 510B (in the present invention, to the right). While the request packet traverses the odd ring 510A or even ring 510B, each cluster 500B through 500H examines the internal remote tag cache or memory directory for this read broadcast request packet so It snoops on whether it is stored in a state, and at the same time bypasses the read broadcast request packet to an adjacent neighbor cluster as described above.

For example, if the result of snooping inside the cluster 500D is that data block is stored in the remote cache in a modified state (for example, 'update' or 'update-shared') (in this case, There is no cluster that stores the block in the local shared memory in a valid state.), The cluster 500D determines that it is responsible for the response to the request packet, and sends the response packet including the requested data block to the request. A single packet is transmitted to the cluster 500A that generates the packet, and at the same time, the state of the remote cache of the block is converted into a 'update-shared' or an unupdated valid state (for example, a 'shared' state). If the data block is stored in the local shared memory in a valid state, the cluster 500D determines that it is responsible for the response to the request packet, and generates a request packet with the response packet including the requested data block. Single transmission to cluster 500A. Thus, the cluster 500D (hereinafter referred to as a cluster having ownership) which is determined to be responsible for the response to the request packet is an odd ring (510A) or an even ring (which has the path closest to the cluster 500A that requested the response packet). 510B). In the case of FIG. 3A, the cluster 500D transmits a response packet through an even ring 510B having a close path, and in FIG. 3B, the cluster 500D transmits a response packet through an even ring 510B having a close path. send.

At this time, the preceding read broadcast request packet is removed by the cluster 500A after iterating through the double ring 510A or 510B. On the other hand, when the cluster 500A receives the response packet from the cluster 500D, the cluster 500A transmits a single recognition packet through a double ring 510A or 510B having a path closest to the cluster 500D that transmitted the response packet again (FIG. 3A). And a single transmission through the odd ring 510A) and the corresponding data block to the processor 100A that generated the request via the local system bus 140 of the cluster 500A. In addition, if the data block corresponding to the request signal corresponds to the memory area of the remote shared memory unit, the data block is stored in the remote cache 170 in a valid state, and if the data block corresponds to the memory area of the local shared memory 300 of the local area, The block is stored in the shared memory 300 and the state of the memory directory is updated to a state (for example, an 'S' state) that means that another cluster is sharing the block.

Meanwhile, in FIGS. 3A and 3B, for a memory write reference request from one processor 100A of the cluster 500A, the cluster 500A applies the data block to the remote cache 170 or the local shared memory 300. If not storing in state, cluster 500A broadcasts a write request packet for that block to other clusters 500B through 500H via directional split dual ring 510A or 510B. At this time, if the requested block is an odd block, a write broadcast request for the block is transmitted through the odd ring 510A as shown in FIG. 3A. If the even block is an even block, write broadcast for the block is shown through the even ring 510B as shown in FIG. 3B. Send the request. While the write broadcast request packet traverses the ring bus, each cluster 500B-500H examines the remote tag cache or memory directory for this request packet, while snooping as to how the data block is stored, etc. The request packet is bypassed to the neighbor cluster as described above.

For example, as a result of snooping inside the cluster 500D, the data block is stored in the remote cache in a modified state (eg, 'update' or 'update-shared') (in this case, the block). No cluster exists in the local shared memory), and if the data block is stored in the local shared memory in a valid state, the cluster 500D determines that it is responsible for responding to the request packet. A response packet including the requested data block is transmitted through an odd ring 510A or an even ring 510B having a path closest to the requested cluster 500A. In the case of FIG. 3A, the cluster 500D transmits a response packet through an even ring 510B having a close path, and even in FIG. 3B, the cluster 500D transmits a response packet through an even ring 510B having a close path. send. At this time, the cluster 500D may invalidate the state of the remote cache storing the corresponding data block (eg, 'invalid') or invalidate the state of the memory directory (eg, the 'G' state). ), The preceding write broadcast request packet is traversed through the dual ring (510A or 510B) and then removed by the cluster 500A, and the snooping resulted in a valid state in which the data block was not modified in the remote cache (e.g. " A cluster storing a "shared" state changes the block's remote cache state to an invalid state (for example, a 'invalid' state).

When the cluster 500A receives the response packet from the cluster 500D, the cluster 500A transmits a single acknowledgment packet through the double ring 510A or 510B having the path closest to the cluster 500D that transmitted the response packet again (FIGS. 3A and 3A). In 3b, the data block is transmitted to the processor 100A which generated the request through the local system bus 140 of the cluster 500A while performing a single transmission through the odd ring 510A. In addition, if the requested data block corresponds to a memory area of the remote shared memory unit, the block is stored in the remote cache 170 in a modified valid state (eg, an 'update' state), and the memory area of the local shared memory 300 is stored. In this case, the block is stored in the local shared memory 300 and the status of the memory directory 320 is not changed by the remote cache 170 of the cluster 500A. , 'C' state).

Meanwhile, in FIG. 3, in a memory write reference request or invalidation request from one processor 100A of the cluster 500A, the cluster 500A does not have ownership of the block in the remote cache 170 (for example, In the case of storing in the 'shared' state, the cluster 500A is operated in the same manner as the case in which the corresponding data block is not stored in the remote cache 170 or the local shared memory 300 in a valid state.

Meanwhile, in FIG. 3, for a memory write reference request or invalidation request from one processor 100A of the cluster 500A, the cluster 500A stores the block in the local shared memory 300 in a valid state or stores the block. If the remote cache 170 is stored in an 'update' or 'update-shared' state, that is, if it has ownership of the block, then the cluster 500A is oriented to neighbor clusters 500B to 500H. The invalidation request packet is broadcast through the double ring 510A or 510B. At this time, if the requested block is an odd block, the invalidation request for the block is broadcast through the odd ring 510A as shown in FIG. 3A. If the even block is an even block, the invalidation request for the block is performed through the even ring 510B as shown in FIG. 3B. Broadcast. While the request packet traverses the ring, each cluster 500B-500H examines the internal remote tag cache or memory directory for this request packet, while snooping as to how the data block is stored, and so on. Bypass request packets to adjacent neighbor clusters in the manner described above. At this time, the preceding broadcast request packet is removed by the cluster 500A after iterating through the ring bus, and the cluster storing the data block in a valid state (for example, 'shared' state) in the remote cache as a result of snooping. Change the remote cache state of the data block to an invalid state (eg, an 'invalid' state). The cluster 500A converts the state of the block stored in the remote cache 170 into a modified state (for example, an 'update' state) when the data block corresponds to a memory area of the remote shared memory unit. If it corresponds to a memory area of shared memory, it updates the state of the block's memory directory to a state (eg, a 'C' state) that means that the remote cache of another cluster does not share the block.

If the state of the data block to be evicted due to data block replacement in the remote cache 170 of the cluster 500A is in a modified state (eg, 'update' or 'update-shared' state), the cluster 500A A single packet containing a block evicted through a double ring 510A or 510B having a path closest to the cluster 500D, for example a cluster with a shared memory area in which the data block to be evicted should be originally stored send. The cluster 500D then updates its data memory and memory directory for that request packet, and a double ring having a path closest to the acknowledgment packet for the data block eviction request to the cluster 500A that generated the request packet. Single transmission over 510A or 510B.

4A, 4B, 4C, and 4D, different embodiments of clusters used in a multi-processor system of directional split dual ring structures according to the present invention are shown.

The clusters 500A-500H, or some of the clusters, shown in FIG. 4A have an odd link controller 160A and even link controller 160B described in FIG. 2 connected to the node controller 150 via the link bus 130. The overall configuration and operation are substantially the same as those of FIG. 2 except that each link controller 160A, 160B is directly connected to the node controller 150, and thus detailed description thereof will be omitted.

Similarly, clusters 500A-500H or some of the clusters shown in FIG. 4B, unlike the clusters shown in FIG. 2, exclude directory cache 320 and local shared memory 300, and include one or more processors and remote caches. Has a configuration containing only bays; The clusters 500A-500H or some of the clusters shown in FIG. 4C have a configuration that includes only the local shared memory module 300 instead of the remote cache 170, unlike the cluster shown in FIG. 2; Each cluster 500A-500H shown in FIG. 4D has a configuration that is connected to any interconnect network 190, such as a ring, crossbar switch, etc., rather than the local system bus 140, unlike FIG. In this regard, the overall configuration and operation of the clusters shown in FIGS. 4A-4D are substantially the same as those shown in FIG. 2 and described in connection with them, and thus detailed descriptions thereof will be omitted.

In the above-described embodiment of the present invention, a case in which the remote cache has 'update' and 'update-share', 'share', and 'invalid' has been described, but the present invention has a different state in which the remote cache is modified. The same may be applied to various cases including the case. In the exemplary embodiment of the present invention, the case where the directory for the local shared memory maintains the states of 'C', 'S', and 'G' has been described. It is to be understood that the same applies if the directory has various other states that are modified.

In the above-described embodiment of the present invention, the case in which the response packet and the acknowledgment packet to the broadcast request packet are transmitted through the odd ring 160A or the even ring 160B having the shortest path has been described. The response packet and the acknowledgment packet for the broadcast request transmitted through the 160A are transmitted to the odd ring 160A, and the response packet and the acknowledgment packet for the broadcast request transmitted through the even ring 160B are transmitted to the even ring 160B. It is apparent that the same operation may be performed with the case and transmitted in any sequence of odd ring 160A or even ring 160B.

In addition, in the above-described embodiment of the present invention, a case has been described in which all clusters use a plurality of processors, an I / O system, and a single system bus, but some or all of the clusters are shown in FIG. 4B. When only the processor and the remote cache are included or as shown in FIG. 4C, only the local shared memory module is included, it is obvious that the present invention can be equally applied to the case of FIG. 4D in which the cluster is connected to any interconnection network.

As described above, the present invention has the effect of providing better performance than the method of simply doubling the ring bandwidth in the form of a single ring while maintaining cache coherency between clusters by a snooping method.

Claims (13)

In a multiprocessor system with a distributed shared memory structure, Multiple clusters; Connecting the plurality of clusters to each other and including a point-to-point split double ring supporting snooping; Each of the clusters snoops whether a data block containing instructions or data corresponding to a data request signal generated from a neighboring cluster in the preceding stage is stored in a valid state in its cluster, and the data block is stored in a valid state. Provide the data block to the data request cluster, when the requested data block is not stored in a valid state in its cluster, and forward the data request signal to a subsequent neighboring cluster; The direction-separated double ring may include a first direction and a second direction ring for selectively transmitting the data request signal to the neighboring cluster at the rear end in a first direction or a second direction according to an attribute of the data block. A multiprocessor system with distributed shared memory architecture using directional split double rings. The method of claim 1, wherein each of said clusters is: A plurality of processors; Local shared memory; Responsive to the data request signal from the processor in the cluster, searching whether the data block is stored in the local shared memory in a valid state, and when the data block is stored in the local shared memory in a valid state, the corresponding data block retrieved therefrom A node controller for delivering a data request signal to a neighboring cluster at a later stage when it is not stored in a valid state in the remote cache or a local shared memory; Interworking between the node controller and the directional detached double ring to serve as a data path connecting each of the clusters to a directional detached double ring, the data request signal from the processor being transmitted through the node controller to the data block. A link controller for selectively passing the first and second directional rings to the neighboring cluster at the rear end according to an attribute and providing the node controller with a data block retrieved by the node controller according to the data request signal; And a interconnection network interconnecting the processor, a local shared memory, and a node controller. The method of claim 1, wherein each of said clusters is: A plurality of processors; Remote cache; Responsive to a data request signal from a processor in the cluster, searching whether the data block is stored in the remote cache in a valid state, and when the data block is stored in the remote cache in a valid state, retrieves the corresponding data block retrieved therefrom. A node controller for delivering to said processor and providing said data request signal to said next neighboring cluster when it is not stored in said remote cache in a valid state; Interworking between the node controller and the directional detached double ring to serve as a data path connecting each of the clusters to a directional detached double ring, the data request signal from the processor being transmitted through the node controller to the data block. A link controller for selectively passing the first and second directional rings to the neighboring cluster at the rear end according to an attribute and providing the node controller with a data block retrieved by the node controller according to the data request signal; And a interconnection network interconnecting the processor, a local shared memory, and a node controller. The method of claim 1, wherein each of said clusters is: A plurality of processors; Local shared memory; Remote cache; In response to a data request signal from a processor in the cluster, if the data block is stored in the remote cache or the local shared memory in a valid state, and is stored in the remote cache or the local shared memory in a valid state. A node controller for delivering the corresponding data block retrieved therefrom to the processor and providing the data request signal to the next neighboring cluster when it is not stored in the remote cache or local shared memory in a valid state; Interworking between the node controller and the directional detached double ring to serve as a data path connecting each of the clusters to a directional detached double ring, the data request signal from the processor being transmitted through the node controller to the data block. A link controller for selectively passing the first and second directional rings to the neighboring cluster at the rear end according to an attribute and providing the node controller with a data block retrieved by the node controller according to the data request signal; And a interconnection network interconnecting the processor, a local shared memory, and a node controller. The method of claim 2 or 4, wherein the cluster is: So that the node controller retrieves in what state the data block requested from the processor is stored in the local shared memory and in what state the requested data block from other clusters is stored in its local shared memory, And a memory directory for storing state information about data blocks stored in the local shared memory. 6. The memory directory of claim 5, wherein the memory directory processes in parallel a request for access to a local shared memory from a processor connected through the interconnect network and a request for access to a local shared memory from neighboring clusters through the link controller. A multiprocessor system with a distributed shared memory structure using directional split double rings, characterized by two independent memory directories. The method of claim 3 or 4, wherein the remote cache is: A remote data cache for storing the contents of the data block; And a remote tag cache for storing a portion of the state and address of the data block so that the node controller can easily update the state of the data block stored in the remote data cache or provide the data block if necessary. Multiprocessor system with distributed shared memory structure using directional split double ring. 8. The remote tag cache of claim 7, wherein the remote tag cache is independent of the remote cache access request from the processors connected through the interconnection network and the remote cache access request from neighboring clusters through the link controller. Multi-processor system of a distributed shared memory structure using a direction-separated double ring, characterized in that consisting of a remote tag cache. 5. The distributed shared memory structure of claim 2, 3 or 4, wherein the cluster further comprises a link bus for interfacing the node controller with the link controller. Processor system. 10. The apparatus of claim 9, wherein the link controller includes first and second link controllers, respectively, connected to first and second directional rings of the directional split double ring, Each of the first and second link controllers transmits the data request signal to corresponding first and second directional rings according to attributes of the data block. Multiprocessor system. 12. The apparatus of claim 10, wherein each of the first and second link controllers configures a data request signal from the node controller and the data block into packets to transmit to the neighbor clusters through the direction separation double ring. Distributed shared memory using a directional split double ring to select and send a request signal or data block transmitted from other clusters to the node controller through a split double ring, and to be responsible for all flow control required for the transmission of the packet. Multiprocessor system of architecture. 11. The method according to any one of claims 1, 2, 3, 4 or 10, wherein an attribute of the data block is an odd data address or even data of the cache or local shared memory in which the data block is stored. A multiprocessor system with a distributed shared memory structure using directional separation double rings, characterized in that the address. 5. The multiprocessor system of claim 2, 3 or 4, wherein the interconnection network is a local system bus, a ring or a cross bar switch.