JPH02281361A - Interprocessor communication mechanism operating method and multiprocess computer system - Google Patents

Abstract

PURPOSE: To make inter-processor communication mechanism operation flexible by providing an internal queue linked with a start point node at the time of the shortage of memories at a destination mode in a multi-processor computer to be operated as a parallel machine. CONSTITUTION: This method and system consists of a multiprocessor computer system bus 20 and plural nodes 22, 24, 26 and 28 connected to this. At the time of constituting the system and transferring signals between transmission and reception sides, the transmission side queues 34 a message to transmit a signal 36 showing a destination that the message is usable. A destination processor is independently operated and whenever information provided from outside is necessary, makes it wait at an incoming stand-by 38 on the receiving side. When a signal showing to be usable is inputted alter, a desired message 40 is dequeued and an obtained signal acceptance 42 is sent back to the transmission side.

Description

DETAILED DESCRIPTION OF THE INVENTION BACKGROUND OF THE INVENTION The present invention relates to a multiprocessor computer system having distributed memory and interprocessor communication facilities and operating as a parallel machine. Its characteristics are that it has up to 1000 or more processing elements (nodes), that it is connected by a message switching network (not completely connected), and that the network moves from the origin to the destination without intervening processors. It forwards messages, has only distributed memory and no shared memory, external communication is done through gateways, and internal communication is not limited to standardized protocols.

All the terms mentioned above are standard and no further definitions are given.

Examples of prior art The architecture of such a system is described in Springer Requilaire Hoop in Computer Science, 1.
W, J, H. 987, pp. 227-269.

“The Architecture” by J.P.
DOOM, I Proc, ESPRIT-415 Summer School, 1986. Because of distributed memory, two processes running on different nodes must communicate by copying information from the origin node into the memory allocated to the destination node.

DETAILED DESCRIPTION OF THE INVENTION Such copying is performed by message transfer between a source node and a destination node, which are controlled by two communication primitives: Each such primitive has the following meaning:

a. Send message m to process R.

m is supplied to R, and the executing process (sender)
is delayed until it is accepted. Here, m and r are parameters of the primitip.

b. Accept the message.

Extracts a message from the queue of the executing process (receiver).

If there is no message, the receiver is delayed until the message arrives.

If there are more messages, it will be on a first-come, first-served basis.

This primitive has no parameters. Access to the 1111 consecutive queues is included in the process that executes the "accept" primitive.

In the following description, entities and statements that appear in a program are printed in typewriter font,
Other characters are printed in 0-man typeface (the latter especially allows for free spacing of character fields).

In the first case, each sender may be such that it sends only a single message and only sends a subsequent message after the previous message has been accepted.

However, a generalization will be explained below. Meanwhile, each receiver has a number of messages waiting for further processing.

The object of the invention is, in particular, to provide a computer system as described above.
The objective is to provide an improved and flexible communications organization that can withstand memory shortages at the destination node and that requires only the minimum network transactions considered reasonable. The present invention uses an internal queue linking to the destination node that is only selectively supplemented by an external queue linking to the origin node only in case of memory shortage at the destination node. In other words, the above-mentioned supplements are to be carried out only as an emergency measure. The internal queue link and external queue link will be described later. According to the invention, the object is a method for operating an interprocessor communication mechanism in a multiprocessor computer system with distributed memory for transmitting a message from a sending node to a receiving side, comprising: 1. a first local communication; at a transmitting node having a process, sending a message by the transmitting process to a second local communication process in the receiving node with a queue request for queuing the message; In the communication process, detecting a queue request and checking a first local memory function as to whether it is possible or not to store said message; and if storing said message is possible, receiving said message and checking said first local memory function; queue to a local location in a waiting queue in the local memory facility of the message receiving node to sustain the sending process by signaling the arrival of the receiving process at the receiving node; postponing and holding said message in a non-local second location of a waiting queue in a second local memory capacity of the sending node, signaling pendingness in the receiving process of said message: storage of the message; The first applicable local communications program of the node holding the most recent pending message in the queue, whether possible or not, signals a link indicator specifying the node holding the next subsequent message in the queue. a) at a receiving node, after waiting for the arrival or pending signal by the receiving process, accessing the least recently activated message in the waiting queue to detect its locality or non-locality; In the case of locality, the message is dequeued and accepted from the waiting queue to be processed by the receiving process, and in the case of non-locality, the message is dequeued and the message that was previously pending in the queue is accepted. A second applicable communication process of the possessing node is caused to output the latter message, and upon its output it accepts the output message for processing by said receiving process while in this way deactivating the message received from; re-accessing the queue until it is empty after said processing; This is achieved by providing a method of operating an inter-processor communication mechanism comprising the steps of: transmitting an acknowledge signal to persist.

Such a method includes a multi-process computer system having a distributed memory and inter-processor communication mechanism in a multi-processor computer system, the system transmitting a message from a sending node to a receiving node, the system comprising: 1. a first local communication process means; a transmitting process means for transmitting a message at a transmitting node, said transmitting node having a key x- for queuing said message;
and address means for addressing a second local communication process means in the receiving node by requesting: 2 the queue ! ! first detection means for detecting a request for a message; testing means for testing a first local memory function of the receiving node as to whether it is possible or impossible to store said message; receiving said message if storage is possible and queuing it to a local location of a waiting queue means in said first local message function and generating an arrival signal of said message to receiving processing means of said receiving node; local queue control means for sending an acknowledge signal to said sending node to sustain the dispatching process means; provided by said checking means to block said message and to cause the sending node's non-local queue control means for queuing to a non-local location of the waiting queue means in the local memory function of 2 and generating a signal of incompletion to the receiving processing means for the latter message; any output signal of said detection means; v of
chaining means for sending a link indication signal designating the node holding the next succeeding message in the queue to the first applicable local communication process means of any node holding the nearest preceding message in the queue in response to III. and: a accessing the most previously activated position of the waiting queue means after waiting for said arrival or said pending signal generation in the receiving processing means of said receiving node, and determining whether it is local or non-local; a second detecting means for detecting: detecting the most previously activated position from the waiting queue means for processing in the receiving processing means if locally supplied from the second detecting means; a first dequeue means for dequeuing and accepting a message at the most previously activated location if supplied from the second detection means;
controlling the second applicable local communication processing means of any node holding the oldest pending message in the queue to output the latter message, which upon output is output for processing by said receiving processing means; second dequeuing means for accepting messages while deactivating messages thus received from 4-1- and reactivating said second detection means until said queue is empty after processing; 4. , in the receiving node, for transmitting an acknowledge signal to a second applicable local communication process means such that the sender process means of the node persists after said acceptance. is advantageous.

Description of the Hardware Environment FIG. 1 is a simplified block diagram of a multiprocessor computer system in accordance with the present invention. The network operates as a bus 20 connecting stations or nodes 22...28. Other network systems may be used insofar as the present invention does not concern the limitations imposed on communication buses.

Therefore, for simplicity, voltage level, bit shape.

No details are given regarding word formats, arbiter protocols, message formats such as preambles, postambles, etc., error handling protocols, or message handshaking at any level below the full functionality of the message itself. Communication with the outside world is not detailed either.

All stations are connected to the network by communication process 8. The functions of the station controller other than the communication itself are represented by process B. The characteristics of process B will not be described in detail. The stations may be equal to each other or different. A station may have corresponding functionality and may be specialized, such as in an array computer. A station computer may be one processor in a multi-process organization, or it may itself be a multi-process entity.
). In the latter case, each illustrated process is assigned to a separate processor. In addition to processor hardware, each node or station includes:
It has a blipy memory that cannot be directly accessed by any other system. For simplicity, the station hardware will not be described in further detail if implemented with standard components. For example, message buff? can be easily realized in RAM.

DESCRIPTION OF LANGUAGE COMMUNICATION PROTOCOL The communication protocol provides programming language communication primitives in conjunction with the communication primitives provided by the device.

In the present invention, the basic primitives of the language model provide synchronous message passing between processes. For communication with other processes, -5end- primitive and -a
Only the ccept-primitives are used, and they are expressed in Pascalian notation as follows. In this specification, the general concept of the combinator language Pascal will be explained as m-quasi knowledge in the field of computer science.

Proc 5end(ref prc, ref
l5O) Proc Accept□:ref isg where -5end-primitive is an operation with two parameters. The first parameter refers to or specifies a particular process, and the second l< parameter specifies a particular message.

The -accept- primitive causes the specification of a message. This message is not a parameter value of the -accept- primitive. Typically -ref- indicates the type of term that follows.

- Before executing the 5end-primitive, the process stores the message buffer F which holds the data of the message.
(-rer l5 (referenced by 1-, see the "Process and Message Representation" section)). The primitive -5end(d -m)- transfers the message buffer to the destination process. Send it to -d-,
Exits when the message is accepted by the destination process. A process location is implied in a process specification. A message queuing mechanism is necessary because communication is a many-to-many operation, since various sending processes may send to a single destination process simultaneously.

The -aCCe9t- primitive returns to the executing process a reference to the buffer holding the messages that have arrived to this process. Messages will be accepted on a first-come, first-served basis. If no message is available, the process is delayed until message III.

No. 251 shows a sequence of steps for communication execution.

The sender queues the message (34) and signals the destination that the message is available (36).
). The destination process can operate autonomously and starts listening for externally supplied information whenever it needs it (
38). Sooner or later during the waiting, and possibly soon after the waiting has begun, the destination will dequeue the destination message (4(1)) by receiving a signal that it is available, which will be signaled to the sender ( 42), the sender knows that it does not have to wait any longer.

The above description has been made for reference when shared memory is actually available. However, ii*, which will be described below, does not have a shared memory but only a distributed memory. Also, in the device model, unlike the language model, communication is asynchronous, and the sending process indicates the destination node and sends the message to the network, and the process can continue. The network arranges the route of the message and sends the message to the destination node. In order to make a message accessible to a destination process, a copy of the original message must be provided to the node of the destination process.

The primitives used in the protocol to abstract from the basic communication primitives of a device are described in the "Device Abstraction" section. The accompanying language protocol is shown in FIG. In FIG. 3, various steps that correspond to steps in FIG. 2 are given the same reference numerals. The push button 46 is connected to the local process 5e on the origin side.
under- and a communication process -8vfitel-. Block 48 wraps around to the destination side and local process-re
ceiver- and communication process-5yste-1. First the message -18g- is sent to the destination (5(1)) where it is placed in a queue 52. This is signaled to the local process (54) by waiting vIII (38). The arriving message is then removed from the destination queue (4(1)). This is signaled as an acknowledgment to the origin's communication process (58), and the origin's special state ends (44).
). After that, a new task will begin.

Process and Message Representation The protocol description uses the following process and message buffer representations (same for all protocols).

Process expression: type prc- eCOrd head:rer msa: tail:ref 1811: burcnt:semaphore((1); cont
1nue: semaphore ((1); nd -head-, -tail- and -bUfcnt- fields are used to set up a message queue for messages sent to the process -head-
and -tail- are used to build a singly linked list of message buffers, and -burcnt- is used for synchronization on the queue. semaphore conti
nue − is used to synchronize with other events,
In principle, it is not relevant to the present invention. Operations on semaphores are standard in the field of communication processes -wait and -.
s&gnal- (also referred to as P and V). The initial value of a semaphore is determined by its declaration.

Message expression: type +esg stripes ecard owner:rerprc data: data; src:ref msg.

next:ref msg; nd The owner field identifies the owner process.

Its owner process resides on the node where this message buffer is located. The -data- field holds message data. Other fields are used by the communication protocol; next- is used to build a linked list of message buffers; -5rc- is used to build a linked list of message buffers;
relates to the buffer of the copy's original message.

Functions -claim-msg-bun□- and -allo
c-i+sg buffer□- is used to allocate a message buffer to the node on which it is executed. The first function blocks the execution process until a buffer can be allocated, and the twenty-first function returns -nil- if a message buffer is not available.

The function -node of(ref)- sends out an indication of the node where the referenced term remains (-ref- is -re
must be of type f-en-sg- and -rer-prc-).

The function -is 1ocal(ref)- returns true if the referenced term remains in the same node as the one on which the function is being called. Function - current pro
cessO- returns a reference to the process executing this function.

Device AbstractionTo abstract from low-level device details, remote asynchronous calls (Res+oteA
An archaic structure called usCall-RAC is used.

The structure of the water ring is briefly described below.

The syntax of RAC is as follows.

rac<procedure Cat)>at<n
ode eXpr>: When RAC is executed, the parameter expression of the procedure call is first evaluated. The node representation is then evaluated and an asynchronous message with parameters and procedure name is constructed and sent to that node. The destination node executes the called procedure. The process that performs RAC continues to operate immediately after the message is sent.

For effective configuration of RAC, it is important to avoid dynamic process creation and dynamic message buffer allocation at the destination node. Then, one system process per node will receive RAs that come directly from the network.
Accept all C messages and proceed to the next RAC.
It can be made to run before the 7th cept of the message.

The efficiency and excellence of the call is that the called procedure has 10 calling statements (-wa + - and -cla
im wsgbuffer-).

Abstracting from composition, therefore, the effect of executing a RAC statement is that the indicated procedure call is executed on the node that ultimately results from the at-expression. The process of executing RAC statements may persist until the indicated procedure is executed.

As an example of the use of RAC, it is used in the protocol.
The configuration of the ut-operation is shown. The -put- operation adds message M to processor R's message key 1-. The message is placed in a linked list and its presence is signaled to the semaphore -bufcnt-. First, R.A.C.
A procedure that does not use -put 1ntern is shown. −
put 1nter'n- assumes that both R and the latest message in processor R's queue remain at the same node (N) and are executed on that node.

proc put 1ntern(r:ref
prc):ref ssg) beg in if r→ taimouth=nil then r-+head neem; else 1ink(r-*rai1.m);f
:; r −+rail m; signal(r−* bufcnt); nd 1) rOc 1ink(t, s:ref l5IJ
) be in t - + next: 11s; nd Assume that the procedure - put extern - is executed at node N, where R remains, and that the message buffer of II of Gi 1 - remains at one other node. . This means that since the last message buffer in the queue cannot be accessed by node N (this is because the memory is distributed), the preordering in the -1ink- procedure cannot be performed on node N. means. −
e 1nk-procedure is the last message buffer? (−
``→tail-'' must be executed on the node where it stays.

proc put extern (r:rer a
rc, merer n+sg) egin; "→tail-nil then r4hf! ad knee 1: 1se rac 1ink (r→tail, *) at node
−of(r−+tail); “i; It must be used for all interactions and the algorithm depends on it.These design constraints will not be explicitly stated below.

To simplify the following explanation, it is assumed that process switching is performed using synchronous scheduling, which is a limited set of procedure calls. In this way, mutual exclusion of procedure calls (scheduling points) is automatically performed.

Also, scheduling is done using -wait- and -claim.
msg butter - Occurs only within the operation.

Destination Buffer 7 One method of buffering messages is to have buffer space available at the node of the receiving process. That is, the message data is sent to the destination and buffered in the destination process.

The sender allocates and initializes a message buffer in the destination process's node and waits for an acknowledgment of its semaphore to continue in the destination's queue.

ElrOC5end(r:ref prC, l:rof
l5(1)begingi -*owner current process
ss□;rac buRer dest(r, w+, m
-*data) at node-of(r); Wait(140Wner -+C0ntinue)
;nd proc buffer dest(rarer pr
c, m:ref msg, d:data) local b:ref Iso: begin b knee at+oc-wag-butter□;b -*
owner knee r; b → src: wealth -: b - + data: = d; 1) Assume that the buffer allocation using tlt 1ntern (r, b): nd -alloc asgbutter- is successful. Procedure - put tnt
ern- is explained in the section "Explosive Abstraction".

The accepting process waits for the message on the semaphore -burcnt-. When a message arrives, this process retrieves the message from the queue and signals that the sender of the message has received the message.

proc Accept□:rer m5g1ocal
g+:ref msg;r:rer prc;egin r:=current process□;wait(
r-+ bu4cnt); @:=Qet 1ntern(r):raCackn
owledae (m −'>5rC) at nod
e-or(m-+5rc); return(m); nd proc get 1ntern(r:ref pr
c):reflocal m:ref msg;e
gin 1:=”→head; if r-+head=re tailthen
r-+tail:=nil; else r-+hea
d:=--*next; f:; retLlrn(1): SQ nd proc acknowledge(m:ref ms
g)beg i n 5iQnal(II-+ owner→cont;n
ue);nd Evaluation Destination Buffer 7 The protocol is shown in Figure 4, which consists of two RAs (corresponding to the sending of two messages).
It only requires C, and is the minimum synchronous communication action.

On the downside, does the protocol buffer messages? It may be assumed that there is sufficient memory available at the receiving node to do so. The number of messages that must be buffered at a node is variable and memory overflow occurs. That is, the memory capacity may be smaller than necessary.

In principle, the circumstances of excellence cannot be determined. In such cases, the destination buffer 7 protocol cannot be used and another buffering method is required.

Distributed Buffer 7 Another method is to buffer the message on the load of the sending process, and the sender only communicates the request to send the message to the destination without sending the message.

proc 5end(r:rat prc, m:ref
■Sa )egin s −+owner:=current-process
s□;rac put external(r,m)at
node or (r); wait(g+-+ ow
ner→continue);nd For the procedure -put extern-, use "@time abstraction"
It is explained in the section.

The accepting process waits for the message to arrive on semaphore burcnt-. When the sender signals the presence of a message, the receiver allocates and initializes a message buffer, retrieves the message representation from the queue, requests the associated message transmission, and returns -cont 1nu.
The e-semaphore waits for a message to arrive.

In this way the queue information (-next- field)
is distributed to the nodes. Therefore, when sending a message, the associated next-field is also sent to the destination (
First procedure! 1let data-). But the message buffer for the last message (-tail-) in the queue?
No cue information is stored in . In that case, the transmitted queue information will be ignored. If the last message was retrieved from the queue (-iS tail-hold),
Key 1- will be emptied before the next schedule point (
This is necessary because the next message may arrive during this wait statement (the message must be newly queued as the first message, and the requested message (must not be contacted).

When a message arrives, it is stored in a message buffer allocated by the destination and then activated. The destination updates the queue information and signals to the sender that it has accepted the message.

proc Accept□: rat ss.

1ocal l:ref 130 r:ref prs; egin r:=current-process□;Wait(
r-4burcnt); (1-)SrC) a
t node-of(■→5rc); nd proc get exturn(r:ref prc
): reflocal l, rat asg;i
s tail: boot: egin b knee claim *sg-buffer(); m knee r-+head; b-+src: father-; b -sowner knee r; is tail knee (r→head-r-+tail
); if is tail then r -*tai
l nee nil;fi;raCget date(1
,b) at node-of(m):Waguchi(r-*
cont 1nue); it not 1s-t
ail then r-head knee b-4neXt:C1
; return(b): nd proc get data(s+, b:re
f m5a) egin raCptlt data (b, I-) data, l-
+neXt)at node of(b); nd OrOc Out data(b:r(if l
sO, d: data, n: ref 18G) egin b-+data need d; b-+next need n; signal(b-sowner −+continue
e);nd The evaluation protocol is shown in FIG. 5, which is more resistant to memory overflows since the message buffer is allocated by the destination buffer. During a memory overflow, the accept process is blocked in the -claim no sg-buffer- function until the overflow condition is resolved by the underlying operating system.

The disadvantage of this distributed buffer protocol is that at least four RACs, twice as many as the destination buffer protocol, are required for synchronous communication.

In some cases, one more ink external-
You need to perform network operations. This operation is not performed if the receiver's queue is empty.

Optimal Buffer An improved buffer protocol is described below that combines the advantages of both FIGS. 4 and 5. It almost always requires only two network operations per transmitted message, while being sufficiently resistant to memory overflows. The protocol is designed to first attempt to buffer the message (destination buffer) at the receiving end. If this is not possible, buffering of the message is performed at the sender (Distribution Bara 27).

A buffer executing 15end always transmits a message to the receiver and waits for an acknowledgement. If a message buffer can be allocated at the destination, the message is buffered at the destination. If that is not possible, distribute buffer 1
will be carried out. In that case, each message is locally buffered? consists of both buffered and non-locally buffered messages. The quality of a part of a cucumber is inherently unspecified. 1 for non-locally buffered messages
It can exist in one node or in several different nodes.

proc 5end(r:ref prc, meeting:r
ef 5so)egin t-sowner knee current processes
s□;rac buHer-obp(r, (m->d
ata)atnode of(r); wait(m-+owner-*continue)
;nd proc buHer obp(r:ref pr
c):ref ssg.

d:data) local b:ref msg;egin b:=alloc msg buyer□;
Hb=nil then put(r, m)H else b-+src:=m; b-*owner:=r; b→data:smell; put(r, b); fi; nd proc put(r:reg prc ,＋＊
ref msg)beg in if is 1ocal(r-+tail)th
en put 1ntern(r, m); else
put extern (r, m): f:; nd The receiving side sends the message to V with the -bufcnt- semaphore.
i machine. If the queue is not empty, it is checked whether the first element of -tx- is locally buffered. If locally buffered, the BCl protocol works according to the destination Buffer7 protocol, otherwise the distributed Buffer7 protocol is adopted.

proc Accept□:ref m5g10Cal
l:rlJ IsQ; r:ref prc; egin rnee current process□; wait(
r-+ bufcnt); ■: tan get(r); rac acknowledge(g+ -+5rc)
at node of(-→5rc); return(s): nd proc get(r:ref prc):ref m
sgbeg in if is 1ocal(r-4head)th
en return(get 1ntern(r))
;else return(oet extern(r
));fi; nd As long as the evaluation receiver node has sufficient memory, the destination buffer 7 protocol is adopted. In that case the protocol causes a minimum number of network transfers (ie two per message).

Is the memory of the receiver node a message buffer? is insufficient, the protocol works according to the distributed buffer protocol. The number of network transfers is therefore increased (to 4 per message).

When a protocol starts to behave like a distributed buffer 7 protocol, the efficiency of inter-node communication decreases. However, after a sufficiently long period of time - the message arrival rate does not exceed the message consumption rate to service the non-local portion of its query queue - the system reverts to its previous state using the Destination Buffer 7 protocol. The protocol is shown in FIG. The hatched portions indicate the characteristics of the "distributed buffer."

Configuration Details The communication system described above can be configured on a variety of hardware. In particular, certain scale computer systems may need to implement one or more of the following enhancements, which do not diminish the principles of the invention.

However, these are what the inventor considers to be the best mode in view of other requirements and degrees of freedom specific to the network.

Non-Order Preserving Networks In such networks, the order in which RAC statements are executed at a node is not necessarily the same as the order in which the corresponding procedures are executed. In OBP -1ink-
and -get-data- may be swapped, requiring additional synchronization.

For simplicity, this synchronization will not be described in detail.

Packet-switched network This network only passes packets, which are messages of limited size. If the data size exceeds the limit, additional R to C will be required.

At the destination, the RAC call must reconstruct or reassemble the original data. Because of the risk of memory overflow, memory for reassembly management must be pre-allocated, requiring distributed management.

The non-order preserving nature of the network means that calls to procedures corresponding to a single message can occur in any order.

7 Crusade of ADA language-like rendezvous mechanism messages is deferred until the rendezvous is completed. -acknowledge- The parameter list is extended with a data parameter containing the result of the rendezvous sent to the sender.

An asynchronous message passing rate initial mechanism with a production rate υIWa assumes that the number of messages sent and not accepted by the destination is (m of buffer space tX:I
jl!・To ensure that it does not exceed a certain limit. The configuration increments when a message is sent,
A counter is used that is decremented when a message is accepted. If a process attempts to send asynchronously and the counter exceeds the limit, the process is blocked until either the counter becomes less than the limit or the blocking period exceeds a certain maximum value. In the resulting OBP variant (not required for asynchronous communication) -acknowl
The edg-procedure is replaced by a counter decrement procedure.

Selective Acceptance In various computer languages, particularly object-oriented languages, messages are typed and the receiving process selectively reveals what type of message it currently wishes to accept. This means that the process has a message queue in the message type box, and a parameter that specifies the keys under which the message can be accepted.
t-〇〇 number means that it is added and must be considered. If a message is not available, the -get- function blocks until a suitable message arrives.

Conclusion As can be seen from the above, it is possible to use programming languages that can be used in distributed systems, from simple standard protocols to out-of-order preserving, packet-switched networks, with advanced primitives such as asynchronous or synchronous message sending, and selective transmission of messages through an accept process. Communication protocols that perform consumption can be designed.

According to the Optimum Buffer 7 protocol, message passing is very efficient when there is sufficient memory, and the program can continue uninterrupted even if message passing causes a memory overflow. The negative impact of memory overflow on execution performance disappears once the overflow condition is resolved.

[Brief explanation of drawings]

1 is a simplified block diagram of a multiprocessor computer system according to the present invention; FIG. 2 is a diagram representing the language protocol; FIG. 3 is a diagram representing the language protocol of FIG. 2; and FIG. 4 is a diagram representing the destination buffer 1 protocol. FIG. 5 is a diagram showing the distributed buffer 7 protocol, and FIG. 6 is a diagram showing the combined buffer 1 protocol. 20-...Bus, 22,24.26.28...Node, 34.36.38.40.42.44...Step, 46.48...Block.

Claims (7)

[Claims] (1) A method of operating an interprocessor communication mechanism in a multiprocessor computer system having distributed memory to transmit a message from a sending node to a receiving node, the method comprising: (a) a first local communication process;
sending a message by the sending process to address a second local communication process in the receiving node with a queue request for queuing the message; (b) in the second local communication process of the receiving node;
detecting a queue request and testing the first local memory capability as to whether it is capable of storing the message; receiving the message and checking the first local memory capability if storing the message is possible; queuing the message to a local location in a waiting queue in the receiving node to signal the arrival of the receiving process at the receiving node to sustain the sending process, but postponing said receiving if storage of the message is not possible. retaining the message in a non-local second location of a waiting queue in a second local memory facility of the sending node, signaling pendingness in the receiving process of the message; even if storage of the message is possible; signaling a link indication specifying the node holding the next subsequent message in the queue to the first applicable local communication process of the node holding the most recent pending message in the queue if this is not possible; c) At the receiving node, after waiting for the arrival or pending signal by the receiving process, access the earliest activated message 1 in the waiting queue to detect its locality or non-locality; If so, the node dequeues and accepts the message from the waiting queue for processing by the receiving process, and if it is nonlocal, dequeues the message and holds the most previously pending message in the queue. controlling a second applicable communication process to output the latter message;
deactivating messages thus received from the queue while accepting output messages for processing by the receiving process upon their output; re-accessing the queue until empty after said processing; (d) transmitting an acknowledge signal at a receiving node to a second applicable local communication process so that the transmission process of that node continues after said acceptance. (2) The sending process sends the original message to the first
2. The inter-processor communication mechanism operating method according to claim 1, wherein the first local communication process performs the addressing. 3. A method for operating an interprocessor communication mechanism according to claim 1 or 2, characterized in that, if message storage is possible, two network operations are involved in the queuing/accepting. 4. The interprocessor communication mechanism operating circuit of claim 3, wherein: (4) four network operations are involved in said queuing/accepting if message storage is not possible. (5) The inter-processor communication mechanism operating method according to claim 1 or 2, wherein the queuing preserves order. (6) The inter-processor communication mechanism operating method according to claim 1 or 2, wherein the receiving node has at least two queue mechanisms for each message type. (7) A multiprocess computer having a distributed memory and interprocessor communication mechanism, the system comprising: (a) transmitting a message at the transmitting node having a first local communication process means; (b) the second local communication process means in the receiving node; (b) the second local communication process means; first detection means for detecting said queue request at said message; testing means for testing said first local memory capability of said receiving node as to whether said message can be stored; , receiving the message and queuing it to a local location of a waiting queue means in the first local memory function, if storage of the message is possible, and signaling the arrival of the message to the receiving processing means of the receiving node. local queue control means for sending an acknowledgment signal to the sending node to cause the sending process means to persist; and being supplied by the checking means to block the message if storage of the message is not possible; non-local queue control means for queuing to a non-local location of a waiting queue means in a second local memory function of the latter and generating a signal of pendingness to the receiving process means for the latter message; any output of said detection means; sending a link indication signal specifying the node holding the next succeeding message in the queue to the first applicable local communication process means of any node holding the nearest preceding message in the queue under control of the signal; (c) after waiting for said arrival or said pending signal generation in said receiving node's receiving processing means, accessing the most previously activated position of the waiting queue means, whether it is local or non-local; a second detecting means for detecting a local; a second detecting means for detecting the most recently activated signal from the waiting queue means for processing in the receiving processing means if the second detecting means is local; a first dequeuing means for dequeuing and accepting a location message; a first dequeuing means for dequeuing and accepting the most previously activated location message if provided by the second detection means; , controlling the second applicable local communication process means of any node holding the oldest pending message in the queue to output the latter message, which upon output is output for processing by the receiving process means; (d) second dequeuing means for accepting messages received from the queue while deactivating messages thus received from the queue and reactivating said second detection means after said processing until the queue is empty; is in the receiving node and sends an acknowledge signal to a second node so that the transmitting process means of the node continues after the acceptance.
an acknowledgment means for transmitting to an applicable local communication process means.