Abstract:
A method for communicating between processes in a data processing system comprising a plurality of processor hosts each coupled to a network and a plurality of processes resident on different ones of said processor hosts, wherein messages are transmitted from one process to another in a logical ring. A message-holding queue is maintained at any host originating a message transmission, and it contains a copy of the message, an identifier of the initiating processor host, and an identifier of the target processor host. A forward notification message is returned to the originating host from a forwarding host when the forwarding host relays the message to another host, and an identical forward notification message is returned to the originating host by the target host when it receives the message. If the host on which the message currently resides becomes separated from the initiating host or terminates operation, or if any process becomes inactive after receiving the message and before relaying it to the next host or is unable to relay the message, flags may be set in the message, and, if necessary, the originating host retransmits the message into the logical ring.

Description:
This application is a continuation of prior application Ser. No. 07/892,715 , filed on May 29, 1992, now abandoned, which is a continuation of prior application Ser. No. 07/402,199, filed Aug. 31, 1989, now abandoned. 
    
    
     A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever. 
     RELATED INVENTIONS 
     The present invention is related to the following inventions, all filed on May 6, 1985 and assigned to the assignee of the present invention: 
     1. U.S. Pat. No. 4,754,395, &#34;Network Interface Module With Minimized Data Paths&#34; Bernhard Weisshaar, Michael Barnea 
     2. U.S. Pat. No. 4,694,396, &#34;Method of InterProcess Communication in a Distributed Data Processing System&#34; Bernhard Weisshaar, Andrew Kun, Frank Kolnick, Bruce Mansfield 
     3. U.S. Pat. No. 5,047,925 &#34;Logical Ring in a Virtual Single Machine&#34;, Andrew Kun, Frank Kolnick, Bruce Mansfield 
     TECHNICAL FIELD 
     This invention relates generally to digital data processing, and, in particular, to an improved method for communicating in a logical ring between processes in a message-based data processing system. 
     BACKGROUND OF THE INVENTION 
     The present invention is implemented in a distributed data processing system--that is, two or more data processing systems which are capable of functioning independently but which are so coupled as to send and receive messages to and from one another. 
     A Local Area Network (LAN) is an example of a distributed data processing system. A typical LAN comprises a number of autonomous data processing &#34;nodes&#34;, each comprising at least a processor and memory. 
     Each node is capable of conducting data processing operations independently. In addition, each node is coupled by appropriate means to a network of other nodes. 
     As mentioned above, the present invention finds utility in such a distributed data processing system, since there is a need in such a system for processes which are executing or which are to be executed in the individual nodes to share data and to communicate data among themselves via messages. 
     A &#34;process&#34;, as used within the present invention, is defined as a self-contained package of data and executable procedures which operate on that data, comparable to a &#34;task&#34; in other known systems. 
     Every process in the distributed data processing system of the present invention has a unique identifier (Connector) by which it can be referenced. The Connector is assigned by the system when the process is created, and it is used by the system to physically locate the process. A Connector comprises both a Process I.D. (PID) and a network node address, which together form a unique systemwide identifier. 
     Every process also has a non-unique, symbolic &#34;name&#34;, which is a variable-length string of characters. In general, the name of a process is known system-wide. 
     A &#34;message&#34; is a buffer containing data which tells a process what to do and/or supplies it with information it needs to carry out its operation. Each message buffer can have a different length. By convention, the first field in the message buffer defines the type of message. 
     Within the present invention, messages are the only way for two processes to exchange data. Messages are also the only form of dynamic memory that the system handles. A request to allocate memory therefore returns a block of memory which can be used locally by the process but can also be transmitted to another process. 
     Messages provide the mechanism by which hardware transparency is achieved. A process located anywhere in the system may send a message to any other process anywhere else in the system (even on another processor) if it knows the process name. This means that processes can be dynamically distributed across the system at any time to gain optimal throughput without changing the processes which reference them. Resolution of destinations is done by searching the process name space. 
     In this system, a process may designate that a message be sent in Logical Ring Mode, meaning that the message will be sent around a logical ring of processes each with the same symbolic name until the message returns to the originating process. The logical ring is dynamic, as new processes with the designated name may be created and old processes with the name may be deleted. No one process need know how large the logical ring is at any time. When a message is sent in Logical Ring Mode, each process of the logical ring will receive the message before any process in the logical ring receives it a second time. 
     A system implemented in accordance with the foregoing concepts is described, for example, in Related Inventions Nos. 1-3. 
     However, in an implementation of the foregoing distributed message-based data processing system at least two significant problems may occur. The first is when a process originates a Logical Ring Message which is sent to a process on another node, and the node on which the Logical Ring Message resides becomes inaccessible from the node of the Initiating Process. The second is when the process holding the Logical Ring Message for some reason becomes terminally inactive (i.e. it faults or terminates) before retransmitting the Logical Ring Message to the next process in the logical ring. In a prior art system, the Initiating Process would have to wait indefinitely or until a time-out notification. 
     The present invention solves these problems by ensuring that in either case the Initiating Process receives the Logical Ring Message back with an indication that the logical ring has been broken. 
     BRIEF SUMMARY OF INVENTION 
     Accordingly, it is an object of the present invention to provide an improved method for communicating in a logical ring between processes in a message-based data processing system 
     It is also an object of the present invention to provide an improved method for communicating in a logical ring between processes in a data processing system, wherein an originating node is kept informed of the progress of a transmitted message as it traverses the logical ring consisting of processes receiving the message. 
     It is another object of the present invention to provide an improved method for communicating in a logical ring between processes in a data processing system, wherein if a node or process fault prevents a message from traversing the logical ring of processes, the originating node is notified, and it retransmits the message into the logical ring. 
     These and other objects are achieved in accordance with a preferred embodiment of the invention by providing a method for communicating between processes in a data processing system comprising a plurality of processor nodes each coupled to a network and a plurality of processes resident on different ones of the processor nodes, the method comprising the steps of (a) transmitting a first message from a first process resident on a first of the processor nodes to a second process resident on a second of the processor nodes; and (b) providing at the first processor node a message-holding queue and storing in an entry thereof a copy of the first message, a first identifier identifying the first process, and a second identifier identifying the second processor node. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The invention is pointed out with particularity in the appended claims. However, other features of the invention will become more apparent and the invention will be best understood by referring to the following detailed description in conjunction with the accompanying drawings in which: 
     FIG. 1 shows a representational illustration of a single network, distributed message-based data processing system of the type incorporating the present invention. 
     FIG. 2 shows a representational illustration of a node as used in the present invention. 
     FIG. 3 shows a representation of the significant portions of a message header as used in the present invention. 
     FIG. 4 shows a representation of the significant portions of a Forward Notification Message structure as used in the present invention. 
     FIG. 5 shows a representation of the significant portion of a Flush Message structure as used in the present invention. 
     FIG. 6 shows a conceptual representation of a Logical Ring Message-Holding Queue associated with a node. 
     FIG. 7 shows a flowchart illustrating how an entry is made into the RLR Holding Queue according to the present invention. 
     FIG. 8 shows a flowchart illustrating how an entry is deleted from the RLR Holding Queue upon normal completion of an RLR Mode transmission according to the present invention. 
     FIG. 9 shows a flowchart illustrating how the NIM process of the Initiating Host is informed of the current location of an RLR Message by means of a Forward Notification Message from the target process according to the present invention. 
     FIG. 10 shows a flowchart illustrating how a reply to a called RLR Message is handled according to the present invention. 
     FIG. 11 shows a flowchart illustrating how a Forward Notification Message is handled according to the present invention. 
     FIG. 12 shows a flowchart illustrating how a notification to flush an RLR Message is handled according to the present invention. 
     FIG. 13 shows a flowchart illustrating how an Initiating Process identifier is generated according to the present invention. 
     FIG. 14 shows a flowchart illustrating how an RLR Message Forward Notification Message is generated according to the present invention. 
     FIG. 15 shows a flowchart illustrating the retransmission of an RLR forward or flush message according to the present invention. 
     FIG. 16 shows a flowchart illustrating how a Forward Notification Message is handled according to the present invention. 
     FIG. 17 shows a flowchart illustrating how an RLR Message is dequeued from the RLR Holding Queue according to the present invention, in the event of the death of the host currently holding the RLR Message. 
     FIG. 18 shows a flowchart illustrating how the Network Interface Module (NIM) process is informed whether or not to monitor an RLR Message according to the present invention. 
     FIG. 19 shows a flowchart illustrating how a message to flush an RLR Message is generated and transmitted to the Initiating Process according to the present invention. 
     FIG. 20 shows a flowchart illustrating how the NIM process is informed of the freeing of an RLR Message according to the present invention. 
    
    
     OVERVIEW OF COMPUTER SYSTEM 
     With reference to FIG. 1, a distributed computer configuration is shown comprising multiple nodes or hosts 2-7 loosely coupled by a local area network (LAN) 1. The number of hosts which may be connected to the network is arbitrary and depends upon the user application. Each host comprises at least a processor and memory, as will be discussed in greater detail with reference to FIG. 2 below. In addition, each host may also include other units, such as a printer 8, operator display module (ODM) 9, mass memory module 13, and other I/O device 10. 
     With reference now to FIG. 2, a representational illustration of a host as used in the present invention is shown. A local area network (LAN) 1 comprises several hosts only one of which (Host N) is illustrated. 
     Representative host N (7, FIG. 2) comprises a processor 24 which, in a preferred embodiment, is a processor from the Motorola 68000 family of processors, such as the commercially available MC68030 32-bit microprocessor. 
     Each host further includes a read only memory (ROM) 28 and a random access memory (RAM) 26. In addition, each host includes a Network Interface Module (NIM) 21, which connects the host to the LAN, and a Bus Interface 29, which couples the host to additional devices within a host. 
     A host is capable of supporting several peripheral devices, such as an Operator Display Module (ODM) 41 and an I/O Module 44. Additional processors, such as processor 27, can be provided within a host. Other additional devices may comprise, for example, a printer 42, and a mass-storage module 43 which supports a hard disk and a back-up device (floppy disk or streaming tape drive). 
     The Operator Display Module 41 provides a keyboard and screen to enable an operator to input information and receive visual information. 
     The system is particularly designed to provide an integrated solution for factory automation, data acquisition, and other real-time applications. As such, it includes a full complement of services, such as a graphical output, windows, menus, icons, dynamic displays, electronic mail, event recording, and file management. 
     While a single host may comprise all of the above units, in the typical user application individual hosts will normally be dedicated to specialized functions. For example, one or more mass storage hosts may be set up to function as data base servers. There may also be several operator consoles and at least one host for generating hard-copy printed output. Either these same hosts, or separate dedicated hosts, may execute particular application programs. 
     As shown in FIG. 2, a host may comprise two or more processors, also referred to herein as &#34;hosts&#34;. Each host is assigned a unique identification comprising a Host I.D. and a CPU I.D. The Host I.D. is identical for all hosts within the same host, while the CPU I.D. is unique for each host within the host. 
     DETAILED DESCRIPTION 
     ROBUST LOGICAL RING TRANSMISSION MODE 
     Robust Logical Ring (RLR) Transmission Mode is a special type of message transmission mode. It enables a process (Initiating Process) which has originated a Logical Ring Message to be notified if a process (Receiving Process) receiving such message dies before retransmitting it or if the host on which the Receiving Process resides becomes disconnected from the Initiating Host. 
     Each host maintains a Logical Ring Message-Holding Queue for storing a copy of each RLR Message initiated by processes resident on such host. An RLR Message is enqueued in this Logical Ring Message-Holding Queue when such message is successfully transmitted to the first off-host process in the Logical Ring. 
     Each entry in the RLR Message-Holding Queue includes an Initiating Process identifier portion which identifies Q the Initiating Process. This Initiating Process identifier portion is assigned to the RLR Message by the NIM process of the host containing the Initiating Process (i.e. the Initiating Host). The Initiating Process identifier is stored in the &#34;channel field&#34; of the Logical Ring connector in the message header. The Initiating Process identifier is preserved as the RLR Message is FORWARDed around the Logical Ring. 
     Each entry also includes a Current Host identifier portion which identifies the host on which the RLR Message currently resides. 
     MESSAGE STRUCTURES 
     To provide messaging within the present invention, the kernel defines and maintains several data structures which define to it the concept of a message. 
     FIG. 3 shows a representation of a message header as used in the present invention. The message header comprises a portion 51 for indicating which process, if any, currently owns the message; portion 52 which provides the virtual address of the message body; portion 53 providing the size of the message; portion 54 providing the connector of the process which initiated the logical ring transmission; portion 55 which provides the connector of the process sending the message; portion 56 which provides the connector of the process which is to receive the message; portion 57 providing one or more flags, (e.g. a ROBUST flag, indicating whether the message was sent using RLR Mode or not); portion 58 indicating what transmission mode the message is being sent in; and portion 59 indicating certain status conditions of the transmission of the message. 
     FIG. 4 shows a more detailed representation of a portion of a Forward Notification Message structure, including the message header portion, as used in the present invention. As further explained below, the Forward Notification Message is sent to the Initiating Host by both the forwarding host and the receiving host. 
     The RLR Forward Notification Message comprises a portion 342 representing the header size; portion 343 representing the header version; and a portion 344 representing the message type. The message type portion 344 is significant regarding the present invention. It determines, for example, whether the message is a Forward Notification Message (FIG. 4) or a Flush RLR Message (FIG. 
     The message header shown in FIG. 4 also comprises portion 345 indicating alignment padding; portion 346 representing the host identifier of the message source; portion 347 representing the host identifier of the message destination; portion 348 representing the host identifier of the message originator; portion 349 representing the message length; and portion 350 representing a message identifier. 
     The Forward Notification Message shown in FIG. 4 also comprises portion 351 representing the connector of the RLR Initiating Process and portion 352 representing the connector of the host currently holding the RLR Message (i.e. the Current Host). 
     FIG. 5 shows a representation of the significant portion of a Flush Message structure, including the message header portion, as used in the present invention. As explained in greater detail below, the Flush Message is sent to the NIM process of the Initiating Host to terminate monitoring of the specified RLR Message as a result of its being freed or taken out of RLR Mode. 
     The Flush Message structure comprises a header portion essentially identical to that illustrated in FIG. 4 and described above regarding the Forward Notification Message, except in FIG. 5 the Message Type portion 344 indicates that the message is a Flush RLR Message. 
     The Flush Message structure shown in FIG. 5 also comprises portion 353 representing the channel field of the connector of the RLR Initiating Process. 
     LOGICAL RING MESSAGE-HOLDING QUEUE 
     FIG. 6 shows a conceptual representation of a Robust Logical Ring (RLR) Message-Holding Queue 300 associated with a host. RLR Message-Holding Queue 300 may be implemented within the random access memory (e.g. RAM 26, FIG. 2) of the corresponding host. 
     The RLR Message-Holding Queue 300 comprises a number of entries (e.g. 305, 315, 325) each containing information about an RLR Message. 
     As shown in FIG. 6, the upper portion of each entry contains the Message Descriptor, whereas the lower portion contains the Message Header. 
     The Message Descriptor portion comprises an entry (303, 313, 323) pointing to the next RLR Message in the RLR Message-Holding Queue 300 and an entry (304, 314, 324) pointing to the previous RLR Message in the queue. The Message Descriptor portion also contain an entry (306, 316, 326) indicating the Message Destination and an entry (307, 317, and 327) providing the Message Address, which points to the corresponding Message Header portion. 
     The Message Header portion comprises an entry (308, 318, 328) containing the Logical Ring Initiator Connector (i.e. the connector of the Initiating Process). FIG. 3 shows additional detail concerning the Message Header structure. 
     The RLR Message-Holding Queue 300 also comprises a pointer 301 (RLR LIST.HEAD) to the RLR Message at the top of the list of RLR Messages and a pointer 302 (RLR LIST.TAIL) to the RLR Message at the end of the list of RLR Messages. 
     FIG. 7 shows a flowchart illustrating how an entry is made into the RLR Holding Queue according to the present invention. (In flow diagrams illustrated in FIGS. 7-20 the numbers adjacent to the various blocks correspond to line numbers in the associated code listings.) 
     In block 116 an acceptance notification is received. Next, in decision block 118 a determination is made whether the message is an RLR Message that was initiated on the local host and whether it was accepted. If NO, the routine exits. If YES, in block 120 the message is placed on the RLR Holding Queue and the routine returns. 
     FIG. 8 shows a flowchart illustrating how an entry is deleted from the RLR Holding Queue upon normal completion of an RLR Mode transmission according to the present invention. 
     In decision block 122, if the RLR Message is not returned to the Initiating Process, the routine exits; but if it is returned to the Initiating Process, the routine proceeds to block 124 where a pointer is set at the next message in the RLR Holding Queue. From block 124 the routine proceeds to decision block 126, where if the end of the Holding Queue has been reached, the routine exits; if it has not been reached, the routine proceeds to decision block 128. 
     In decision block 128, if the returned message matches, the routine proceeds to block 130; if it does not match, the routine returns to block 124. In block 130, the message is dequeued from the RLR Holding Queue and is freed. From block 130, the routine exits. 
     MONITORING LOCATION OF ROBUST LOGICAL RING MESSAGE 
     FIG. 9 shows a flowchart illustrating how the NIM process of the Initiating Host is informed of the current location of an RLR Message by means of a Forward Notification Message from the target process according to the present invention. 
     In decision block 132, if a received message is an RLR Message, the routine proceeds to decision block 134; if not the routine exits. In decision block 134, a determination is made whether the received message was initiated on another host besides the predecessor; if so, the routine proceeds to block 136, where an RLR FORWARD message is sent to the NIM process of the Initiating Host identifying the current host as the new message holder; if not, the routine exits. 
     FIG. 10 shows a flowchart illustrating how a reply to a called RLR Message is handled according to the present invention. 
     In block 138, a reply message is received, and the routine proceeds to block 140, where a pointer is set to the next message in the call Holding Queue. From block 140 the routine proceeds to decision block 142, where, if the end of the Holding Queue has been reached, the routine exits; if not, it proceeds to decision block 144. 
     In decision block 144, a determination is made whether the received reply message matches the message in the call Holding Queue; if so, the routine proceeds to block 146, where the message is dequeued from the Holding Queue, and the CALLED flag is cleared; if the messages did not match, the routine returns to block 140. 
     From block 146 the routine proceeds to block 148, where the dequeued message is placed on the RLR Holding Queue if it is an RLR Message; otherwise it is freed. From block 148, the routine exits. 
     FIG. 11 shows a flowchart illustrating how the receipt of a Forward Notification Message is handled according to the present invention. 
     In block 150, a received RLR FORWARD message is received, and the routine proceeds to block 152, where the RLR Holding Queue is searched for the corresponding message. 
     From block 152, the routine proceeds to decision block 154, where, if a match is found, the routine proceeds to block 168; if a match is not found, the routine proceeds to block 156, where the message return time-out queue is searched for the corresponding message. 
     From block 156, the routine proceeds to decision block 158, where, if a match is found, the routine proceeds to block 166; if a match is not found, the routine proceeds to block 160, where the transmission queues are searched for the corresponding message. 
     From block 160, the routine proceeds to decision block 162, where, if a match is found, it proceeds to block 166; if not found, it proceeds to block 164, where the routine is returned to the caller. 
     In block 166, the message is moved from the queue in which it is found to the RLR Holding Queue, and the routine proceeds to block 168, where the identification number of the host currently holding the RLR Message is recorded. 
     FIG. 12 shows a flowchart illustrating how a notification to flush an RLR Message is handled according to the present invention. 
     In block 170, a FLUSH --  RLRING message is received, and the routine proceeds to block 172, where the RLR Holding Queue is searched for the corresponding message. From block 172 the routine proceeds to decision block 174, where, if a match is found, it proceeds to block 176, where the message is dequeued, freed, and returned to the caller; if no match is found, the routine proceeds to block 178, where the call queue is searched for the corresponding message. 
     From block 178, the routine proceeds to decision block 180, where, if a match is found, it proceeds to block 182, where the RLR flags are turned off, and a return is made to the caller; but if a match is not found in decision block 180, the routine proceeds to block 184, where the message return time-out queue is searched for the corresponding message. 
     From block 184, the routine proceeds to decision block 186, where, if a match is found, the routine proceeds to block 194; but if no match is found, the routine proceeds to block 188, where the transmission queues are searched for the corresponding message. 
     From block 188, the routine proceeds to decision block 190, where, if a match is found, the routine continues to block 194; but if not found it proceeds to block 192, where a return to the caller is made. 
     In block 194, RLR flags are turned off, the message is dequeued, and the routine proceeds to block 196. In block 196, the message is moved to the call holding queue if the message is a called message; otherwise it is freed. From block 196, the routine proceeds to block 198, where a return to the caller is made. 
     FIG. 13 shows a flowchart illustrating how an Initiating Process Identifier is generated according to the present invention. 
     If a message is symbolically addressed, the routine proceeds to decision block 202; if not, it exits. In decision block 202, if the message is an RLR Message initiated on a local host, the routine proceeds to block 204, where the message is tagged with a unique identifier; if not, the routine exits. 
     From block 204, the routine proceeds to block 206, where the identifier for the next message is incremented, and the routine then proceeds to block 208, where the message is transmitted to the next host in the Logical Ring, and the routine is returned to the caller. 
     FIG. 14 shows a flowchart illustrating how an RLR Message Forward Notification Message is generated in the event of the death of the host currently holding the RLR Message, according to the present invention. 
     In block 210, a message descriptor is obtained, and the routine proceeds to block 212, where an RLR --  FORWARD message is created containing the connector of the RLR Initiating Process and the identifier of the host currently holding the RLR Message. From block 212, the routine proceeds to block 214, where the RLR --  FORWARD message is sent to the Initiating Host. 
     FIG. 15 shows a flowchart illustrating the retransmission of an RLR forward or flush message according to the present invention. 
     In block 216, a transmission error has occurred. In decision block 218 a determination is made whether to retry the transmission, and, if YES, the routine proceeds to decision block 220; if NO, the routine proceeds to decision block 224. 
     In decision block 220, if the failed transmission was the transmission of an RLR --  FORWARD or FLUSH --  RLRING message, the routine proceeds to block 222, where the message is retransmitted, and a return is made to the caller; if not, the routine exits. 
     In decision block 224, if the failed transmission was the transmission of an RLR --  FORWARD or FLUSH --  RLRING message, the routine proceeds to block 226, where the message is freed, and a return is made to the caller; if not, the routine exits. 
     FIG. 16 shows a flowchart illustrating how a Forward Notification Message is handled according to the present invention. 
     In block 228, the message transmission was successful. From block 228 the routine proceeds to decision block 230. In decision block 230, if the message was an RLR Message which was initiated on another host and not sent to the Initiating Host, the routine proceeds to block 232; if not, the routine proceeds to decision block 236. 
     In block 232, the Initiating Host is informed of the Current Host identifier, and the routine proceeds to block 234, where a return to the caller is made. In decision block 236, if the message was an RLR --  FORWARD or FLUSH --  RLRING message, the routine proceeds to block 238, where the message is freed, and a return to the caller is made; if not, the routine exits. 
     FIG. 17 shows a flowchart illustrating how an RLR Message is dequeued from the RLR Holding Queue according to the present invention, in the event of the death of the host currently holding the RLR Message. 
     In block 240, a pointer is set at the next message in the RLR Holding Queue, and the routine proceeds to decision block 242. In decision block 242, if a message is marked as residing on a host that died, the routine proceeds to block 244, where the message is dequeued from the Holding Queue, and the error status is set; if not, the routine returns to block 240. From block 244, the routine proceeds to block 246, where the message is sent back to the Initiating Process, and the routine returns to block 240. 
     OPERATING SYSTEM KERNAL 
     The operating system kernel is responsible for supporting Robust Logical Ring operations by (1) recording that a Logical Ring Message is being transmitted in LRING mode, so that the NIM process will begin monitoring it; (2) notifying the NIM process when an RLR Message it is monitoring is freed; (3) notifying the NIM process when an RLR Message it is monitoring is sent to a process which is not a member of the Logical Ring or is sent to a process identified by other than its symbolic name. 
     FIG. 18 shows a flowchart illustrating how the Network Interface Module (NIM) process is informed whether or not to monitor an RLR Message according to the present invention. In the present invention, once an RLR Message is traversing the Logical Ring of processes, it is sent to the next process in the Logical Ring using the NEXT transmission mode (for further discussion of NEXT transmission mode, see description under &#34;Determination of Initiating Process&#34; below). 
     In block 248, if the message was sent in any mode except NEXT Transmission Mode, the routine proceeds to decision block 250. However, if the message was sent in NEXT Transmission Mode, the routine proceeds from block 258 to block 260. In decision block 250, if the message was previously sent as a Logical Ring message, the routine proceeds to block 252, where the NIM process is notified; if not, the routine proceeds to decision block 254. 
     In decision block 254, if the message is being sent in Logical Ring mode, the routine proceeds to block 256, where an indicator is set in its header; if not, the routine proceeds to block 260, where the message is transmitted. 
     FIG. 19 shows a flowchart illustrating how a message to flush an RLR Message is generated and transmitted to the Initiating Host according to the present invention. 
     In block 262, a message is received. From block 262 the routine proceeds to decision block 264, where if a FLUSH --  RLR message is received from the kernel, the routine proceeds to block 266, where a message descriptor is obtained; if not, the routine exits. 
     From block 266 the routine proceeds to block 268, where a FLUSH --  RLRING message is created containing the unique Logical Ring Identifier, and such message is addressed to the Initiating Host. From block 268 the routine proceeds to block 270, where the FLUSH --  RLRING message is sent to the Initiating Host. From block 270 the routine returns to block 262. 
     FIG. 20 shows a flowchart illustrating how the NIM process is informed of the freeing of an RLR Message according to the present invention. 
     In decision block 272, if the message is currently being monitored, the routine proceeds to block 274, where the NIM process is notified that the RLR Message is to be freed, and the routine proceeds to block 276; if not, the routine proceeds directly to block 276. In block 276, the RLR Message is freed. 
     OPERATION OF PREFERRED EMBODIMENT 
     UPDATING LOGICAL RING MESSAGE HOLDING QUEUE 
     As explained in greater detail in Related Inventions #1 and #2, the system of the present invention utilizes a kernel primitive known as FORWARD, which may be used by a process to transmit a message which has been received from another process. In the FORWARD primitive, the source connector (i.e. from the originating process) is not modified by the FORWARDing process. 
     If an RLR Message is FORWARDed from the process where it most recently was received to a process on another host (Target Process), a Forward Notification Message is transmitted to the Initiating Host by the NIM process of the host containing the FORWARDing process. 
     The purpose of the Forward Notification Message is to inform the Initiating Host that the RLR Message has been FORWARDed to another host. The Forward Notification Message includes the connector of the Initiating Process and the I.D. of the host currently holding the RLR Message (i.e. the Current Host). 
     When the RLR Message is actually received by the Target Process, a Forward Notification Message is transmitted from the NIM process on the host where the Target Process resides to the NIM process of the Initiating Host to inform it of the current location of the RLR Message. The Forward Notification Messages sent by the NIM process of the host containing the FORWARDing process and by the NIM process of the host containing the Target Process are identical. 
     Upon receiving the Forward Notification Message, the NIM process on the Initiating Host locates the corresponding RLR Message in the RLR Message-Holding Queue, using the Initiating Process connector, and updates the Current Host I.D. to reflect the identity of the new Current Host. 
     If the RLR Message circulates successfully through the Logical Ring and returns to the Initiating Host, the copy of the RLR Message stored in the RLR Message-Holding Queue is dequeued and deleted. 
     Several cases will now be discussed in which the RLR Message fails to circulate successfully through the Logical Ring and return to the Initiating Process. 
     One such case may occur when the host of the Initiating Process and the host on which the RLR Message is currently residing become disconnected from one other. In this case, the Transmission Status field of the message header of the RLR Message is set to BROKEN --  RING (refer to FIG. 3). In addition, the Flags field of the message header is set to indicate LRING --  NODE --  DEATH. 
     The NIM process on the Initiating Host reintroduces the copy of the RLR Message stored in the RLR Message-Holding Queue back into the Logical Ring. The RLR Message is thus retransmitted around the Logical Ring, until it returns to the Initiating Process. 
     Another such case may occur when one of the processes in the Logical Ring for some reason terminates after receiving the RLR Message but before retransmitting it to the next process. In general, an attempt is made to continue the transmission of the RLR Message if possible. 
     In the system of the present invention, messages which are delivered to a process are placed in its Input Queue. By performing the GET kernel primitive, the process dequeues a message from its Input Queue on a first-in-first-out basis, moving the message to its Owned Queue, where the message is handled, which includes possible modification of the contents. 
     Thus a message left on the Input Queue of a terminating process is in the same state as when it was received, but a message left in the Owned Queue may have been modified. 
     If the terminating process is holding the RLR Message in its Owned Queue, the RLR Message is FORWARDed to the next member of the Logical Ring. The Transmission Status field of the message header of the RLR Message is set to BROKEN --  RING and the Flags field of the message header is set to indicate LRING --  PROC --  DEATH. 
     If the terminating process is holding the RLR Message in its Input Queue, the RLR Message is simply FORWARDed to the next member of the Logical Ring. 
     A process in the Logical Ring may REPLY () the message at any time. REPLYING an RLR Message takes the message out of RLR Mode and sends it to the Message Initiator. Note that the Message Originator is not necessarily the same as the RLR Initiator. In either case, the NIM process on the Initiating Process&#39; host is sent a Flush Message to stop monitoring the message. 
     Any process holding the RLR Message may remove it from the Logical Ring, by FREEing it, or by sending it to a process which is not a member of the Logical Ring, or by sending it to a process within the Logical Ring using a transmission mode other than NEXT. 
     If a process uses the DIRECT, EXPRESS, or SELF Transmission Modes to transmit the RLR Message, then the RLR Message is considered to have left the Logical Ring, even if the target host is a member of the Logical Ring. If the Logical Ring spans multiple hosts, the NIM process on the Initiating Host is notified, by means of a flush notification, that the RLR Message is no longer to be monitored. 
     If the Logical Ring spans multiple hosts, and the NIM process of the Current Host is unable to transmit the RLR Message to the next host on the LAN, the Transmission Status field of the message header of the RLR Message is set to BROKEN --  RING, and the Flags field is set to indicate LRING --  FAILED --  DELIVERY. The RLR Message is returned to the Initiating Host, where the NIM process of the Initiating Host dequeues and frees the corresponding message from the RLR Message-Holding Queue and injects the received RLR Message back into the Logical Ring. 
     If the Initiating Process terminates before the RLR Message returns to it, and no other member of the Logical Ring recognizes and deals with the situation, then the Transmission Status field of the message header of the RLR Message is set to BROKEN --  RING, and RING --  COMPLETE is reported in the Flags field (in addition to any other status indications). 
     DETERMINATION OF INITIATING PROCESS 
     In the system of the present invention, the PUT kernel primitive is used by a process to send a message to a given destination. The sending process resumes execution immediately after sending the message. The CALL kernel primitive is used by a process to send a message and then wait for a reply. 
     In the present invention, if a process does a PUT, FORWARD, or CALL of a message, such process becomes the Initiating Process regarding the Logical Ring transmission. If the Logical Ring spans multiple hosts, and the RLR Message is given to the NIM process to transmit it to a Logical Ring member not on the host of the Initiating Process, the NIM will begin monitoring the RLR Message, as described in the section above entitled &#34;Updating Logical Ring Message-Holding Queue&#34;. 
     In the system of the present invention, the NEXT transmission mode is a mode by which a process may send a message to the next process, if any, with the same symbolic name in the same context as the sending process; otherwise the process searches upwards through all parent contexts until it finds a process, if any, with the same name. 
     In the system of the present invention, there are two message transmission modes by which a process may send a message to a process identified by its symbolic name: NEXT and LRING transmission modes. If a process sends a message using the LRING transmission mode, such process becomes the Initiating Process regarding the Logical Ring message transmission, and the flags field of the message header is marked to indicate the message is being monitored. 
     If a process sends a message using the NEXT transmission mode and no Initiating Process has been set for this message, such process becomes the Initiating Process but the flags field of the message header is not marked. 
     That is, once an RLR Message is circulating in the Logical Ring, if it is transferred to the next process in the Logical Ring using NEXT Transmission Mode, the Initiating Process is preserved. But if Robust Logical Ring Transmission Mode is used, the executing process becomes the Initiating Process for the RLR Message. And the NIM process on the former Initiating Process&#39; host is not notified of further progress of the RLR Message in the Logical Ring. 
     If the process holding the RLR Message transmits it using Robust Logical Ring Transmission Mode after the Initiating Process has been set, and the Logical Ring spans multiple hosts, the NIM on the host of the existing Initiating Process is notified that it is no longer to monitor the RLR Message. The NIM process on the host of the new Initiating Process will do so. 
     DESCRIPTION OF PROGRAM LISTINGS 
     Appendices A-I contain &#34;C&#34; language program listings implementing the concepts relating to the transmission of RLR Messages as described hereinabove. 
     Appendix A (mcinim.h) is a header file which includes various definitions, message identifiers, and global data structures. Appendix A contains the structure of the message to notify the Initiating Process that the RLR Message has been FORWARDed (lines 154-157). Appendix A also contains the structure for the message which notifies the NIM process of the Initiating Host that the RLR Message is no longer in Robust Logical Ring Mode and should be flushed from the RLR Message-Holding Queue (lines 159-161). Appendix A also contains a macro to determine if a specified message is an RLR Message (lines 189-191). 
     The program listing of Appendix B (rcvd --  msg.c) serves to place the RLR Message on the RLR Message-Holding Queue (rlr --  list) (lines 107-109). The code of Appendix B also removes an RLR Message from the RLR Message-Holding Queue upon its return to the Initiating Host (lines 168-177). In addition, upon receipt of a FORWARDed RLR Message, the NIM process of the Initiating Host is notified of the current residence of such RLR Message (lines 193-198). 
     Further in Appendix B, upon receipt of a reply to a called RLR Message, such message is moved to the RLR Message-Holding Queue (lines 211-212). Code is also provided for receiving a notification message regarding the FORWARDing of the RLR Message (lines 436-481). In addition, code is provided for a notification regarding the flushing of an RLR Message (lines 482-548). 
     Appendix C (snd --  fcns.c) provides code for tagging an RLR Message with a unique Initiating Process identifier portion which identifies the Initiating Process (lines 88-89). It also provides code for sending notification regarding a Forward Notification Message which is transmitted from a FORWARDing process to the NIM process of the Initiating Host to inform it that the RLR Message has been received by another process in the Logical Ring (lines 641-667). 
     Appendix D (tx --  status.c) handles the retransmission of Robust Logical Ring forward and flush notifications (lines 82-83). It also handles the unsuccessful transmission of Robust Logical Ring forward and flush notifications (lines 138-139). In addition, upon the successful FORWARDing of an RLR Message, it notifies the NIM process of the Initiating Host of the current residence of the RLR Message (lines 166-169, 179-182, and 205-206). 
     Appendix E (next --  cell.c) dequeues RLR Messages upon the disconnection or death of a host currently holding the RLR Message. Appendix E also provides a function which is called upon the death of the host on which the RLR Message is resident and which determines which RLR Messages resided on such host (lines 165, 245-285). Such RLR Messages are sent to the NIM process of the Initiating Host with BROKEN --  LRING status. 
     Appendix F (putfor.m4), Appendix G (nim.c), Appendix H (mcinim.c), and Appendix I (kentry.s) provide Robust Logical Ring support from the operating system kernel. 
     In Appendix F (putfor.m4) the function chk --  robust (lines 776-801) is used to decide whether or not to notify the NIM process that an RLR Message is no longer to be monitored. Calls to chk --  robust are provided in appropriate places (e.g. lines 201, 331, 372, 723, 751, and 767). Appendix F also provides the maintenance of the information by which the NIM process recognizes that an RLR Message is or should be monitored (lines 565-566 and 608). 
     In Appendix G (nim.c) the function xmit --  rlr --  flush (lines 204-220) is used to notify the NIM process that an RLR Message is no longer to be monitored. 
     Appendix H (mcinim.c) provides code which accepts the notification message from the local kernel that a specified message is no longer an RLR Message and so informs the NIM process of the Initiating Host (lines 292-311). 
     Appendix I (kentry.s) provides the code for determining, during the freeing of an RLR Message, whether or not the NIM process must be notified and to do so if necessary (lines 639-647). 
     It will be apparent to those skilled in the art that the disclosed invention may be modified in numerous ways and may assume many embodiments other than the preferred form specifically set out and described above. 
     Accordingly, it is intended by the appended claims to cover all modifications of the invention which fall within the true spirit and scope of the invention. ##SPC1##