JP3974078B2 - Interprocess communication method using distributed shared memory - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to an interprocess communication system using a distributed shared memory. In particular, the present invention temporarily suspends message transmission of a scale corresponding to a process or transfer message in a local buffer provided in the OS or AP (Application) layer, and transmits a process having a high transmission priority level to a low level. Inter-process communication using distributed shared memory that performs priority control to transmit messages with high real-time characteristics without being interrupted by messages with low real-time characteristics in the message transfer between nodes by scheduling to interrupt process transmission It is about the system.
Furthermore, the present invention relates to a data processing apparatus having a communication function used for interprocess communication using a distributed shared memory.
[0002]
[Prior art]
In the inter-node network, hardware built-in communication means with a small software load attract attention, and a communication method using a distributed shared memory is also effective because of its low latency. By the way, a high-speed communication method for connecting processors is often designed according to the characteristics of a process (or AP), and another high-speed communication system is used for a process (or AP) having different characteristics. . That is, each communication method has a relatively limited application area. For example, in a high-speed communication method using a distributed shared memory, when a message with high real-time characteristics is being transmitted and mixed with large-scale message transmission, the large-scale message transmission is completed because the network becomes a bottleneck. In the meantime, transmission of a message with high real-time characteristics is awaited, and transmission of a message with high real-time characteristics may be prevented. Also, in the case of a message transfer-dedicated communication method for transferring a large-scale message, it is generally not intended for real-time message transmission, and the entire message delivered to a normal transmission device is temporarily stored in a buffer, so that buffering time Therefore, it has been difficult to use a large-scale message transfer system for high-frequency real-time message communication.
[0003]
Therefore, the route from the process to the device or system that performs high-speed data transfer differs depending on the characteristics of the process (or AP), and it can be dealt with by using different high-speed communication methods for each process (or AP). Inevitably, there is a burden such as an increase in cost due to the introduction of a program or device for switching, and an increase in use of host processor resources.
[0004]
[Problems to be solved by the invention]
As described above, in the conventional internode data transfer technology, when a large-scale message transmitted in a batch using a high-speed communication device and a transmission of a message having high real-time characteristics are mixed, the network becomes a bottleneck. While large-scale message transmission continued, there was a problem that transmission of messages with high real-time characteristics was hindered. In particular, if a device dedicated to large-scale transfer such as file transfer is used, it is difficult to send a message with a high real-time property, and it is possible to send a message with a high real-time property and a large-scale message using the same communication device. There is a problem that it is difficult to do together. In a high-speed communication method using a distributed shared memory, high speed is required not only for small messages such as control information originally targeted, but also for large messages.
[0005]
The object of the present invention is to solve the problem that it is generally difficult to perform message transmission with high real-time characteristics and large-scale messages with relatively low real-time characteristics by using only a high-speed communication method using a distributed shared memory. When sending a process that generates messages with various real-time characteristics and various data scales that can be solved only by a small modification, multiple high-speed communication devices can be installed and used, or replaced with other communication methods. Therefore, it is an object of the present invention to provide a high-speed communication method using a distributed shared memory that can be transmitted without impairing the process characteristics, particularly the real-time property of a transfer message.
Furthermore, an object of the present invention is to preferentially transfer data or messages that require real-time performance in a data processing apparatus used in an interprocess communication system having a plurality of processes and using a distributed shared memory. It is to realize a data processing device that can be used.
Furthermore, another object of the present invention is to provide a high-speed communication system using a distributed shared memory as a wider range of distributed real-time communication functions.
[0006]
[Means for Solving the Problems]
In order to achieve the above object, a communication system using a distributed shared memory according to the present invention has a plurality of nodes interconnected via a network, and each node has one or more processes for generating data or messages. , A memory having a distributed shared memory used to share data with other nodes, and data to the distributed shared memory Control writing Control means and distributed shared memory Written Each node comprising a data transfer device for transmitting data to the network and receiving data sent from the network In Data in its own distributed shared memory Once written, its own data transfer device The data is automatically transferred to the distributed shared memory of the destination node Forward In an interprocess communication method using distributed shared memory,
Each node has a local buffer for temporarily storing data generated by the process, and the control means stores the data in the distributed shared memory when the data size of the data generated by the process is equal to or less than a predetermined data length. When the data size of directly written and generated data exceeds the predetermined data length, the data is temporarily written in the local buffer and then written in the distributed shared memory.
[0007]
In the present invention, the write control means compares the processing message received from the process with a predetermined message length or data length, writes the data or message below the predetermined data length or the message length directly into the distributed shared memory, When the message length is exceeded, the processing message is controlled to be written in a local buffer provided in the OS or AP layer and then written in the distributed shared memory. By this control, a message having a high real-time property level is preferentially written in the distributed shared memory. As a result, even when various messages having different message lengths are mixed, a message with high real-time property can be preferentially transmitted without providing a complicated priority control mechanism. In this specification, “node” means a data processing apparatus having a communication function, and is understood to include not only a case where a process as an application is included but also a PM (processor module) and a processor.
[0008]
Also, by assigning a virtual address to the local buffer and providing an address conversion function with the real distributed shared memory, the OS or AP layer can use the high-speed communication method in the same process as if accessing the real distributed shared memory. it can. Also, when allocating a local buffer, it is assigned for each batch transfer unit whose scale is determined by the OS according to the real-time property or message size of the process or message, and the message hold size or hold time required for the process or message is set. It is possible to facilitate the transmission of a high priority process or message in advance. As a result, priority control of message transfer between nodes in inter-process communication using a distributed shared memory can be realized by simply changing or correcting the mounting form. Here, the batch transfer unit means that when a message is temporarily stored in a local buffer, the message is divided into predetermined data sizes and stored from the local buffer to the distributed shared memory in units of the data size. Although written, it means a unit of data having a certain data size.
[0009]
Also, when sending when all the area units (MB) in the batch transfer unit are accessed, the contents of the real shared memory are overwritten in the batch transfer unit (in the case of reception, the local buffer contents are overwritten in the real shared memory). By overwriting), transfer is performed without the process being aware of it. Note that MB (Message Buffer) means an area unit in the distributed shared memory where data is written.
[0010]
In addition, by forcibly starting the overwriting from the process side and synchronizing the local buffer and the real shared memory, the latest message can be read and written at any time, that is, communicate with the transfer destination node. Can do.
[0011]
In addition, by indicating the priority given by the OS using the scale of the batch transfer unit, both the hold time until the message is sent to the network and the OS priority are controlled with one parameter, and the process The process itself can control these priorities by determining the value of this parameter indirectly.
[0012]
DETAILED DESCRIPTION OF THE INVENTION
In the present invention, as to how to efficiently provide a high-speed communication method using a distributed shared memory according to the characteristics of a process (particularly, the message size to be transmitted and received and the real-time property required for the message), (The process can be either within the AP or the OS).
That is, in inter-process communication connected via a network, when using the high-speed communication method as a more general communication means, the process that is the source does not always request transmission of a message with similar characteristics. Messages that do not always have similar characteristics. That is, it is necessary to change the form of providing the high-speed communication method and the type of method according to the characteristics of the message. However, the method of providing a plurality of communication methods and switching the communication methods according to the message characteristics has a disadvantage that the device scale is enlarged. Therefore, in the present invention, a local buffer is provided in the OS or AP layer in the node, and a combination of temporary hold of a large-scale or low real-time message and write priority assignment to the distributed shared memory by the OS, OS-based local buffer control and forced operation from the process, setting of the area to be allocated in the local buffer according to the characteristics of the process or message, that is, the size of the batch transfer unit, local buffer and distributed shared memory by virtual address Equally ensure the local buffer size by notifying the OS of the message size. As a result, it is possible to absorb a difference in performance due to message characteristics that often occurs in a high-speed communication system, and to always communicate various messages in the same high-speed communication system. In addition, by providing this function in the OS or AP layer, the features of conventional communication devices using distributed shared memory, such as the ability to communicate messages with a small delay without burdening the application or OS, are achieved. can do.
[0013]
Note that the present invention can also be applied to communication between processes in each node connected by a network. Therefore, a node is applied not only to a case where it is composed of one PM but also to a case where it is composed of a plurality of PMs, and one or a plurality of processes may operate within each PM. In other words, inter-process communication targeted by the present invention is not only communication between processes in different nodes, but also communication between processes in different PMs in one node and processes in one PM in one node. The operation is the same including communication between each other. Although PM and nodes are collectively referred to as nodes in claim 1, the processes that are targeted in this way have several forms, but perform the same operations for all these forms.
[0014]
【Example】
Embodiments of the present invention will be described below in detail with reference to the drawings. FIG. 1 is a diagram illustrating an arrangement of a network model configuration using a general high-speed communication method to which the present invention is applied and a related example. In Figure 1, the communication device using the distributed shared memory (DSM), which is a high-speed communication device, is 11A, the OS included in the host processor is 12A, and the processes that mainly communicate small messages are 13A, large-scale message transfer The device is 11B, the OS included in the host processor is 12B, and the processes for communicating large-scale messages are 13B. High-speed communication devices are often applied depending on the AP, and the communication device is designed or implemented according to the message characteristics of the process in the AP, so communication from APs that generally communicate relatively short messages. Device access is 14A, and communication device access from APs that communicate large files is 14B. By introducing a local buffer (in 16C), both small message communication and large message transfer are mainly implemented. Communication is performed by accessing the DSM communication device 11C. FIG. 1 shows two types of APs, APs that communicate small messages and APs that communicate large messages, but the same is true when there are three or more types. In other words, efficient communication is provided by the same communication apparatus to a wide range of APs from a short message transmission to a large-scale file transmission without depending on the AP. In this specification, “node” means a data processing apparatus having a communication function and generating data by one or more processes, and one or more processor modules (PM: Processor) Module). That is, according to the present invention, when the writing of data or messages to the distributed shared memory among a plurality of nodes competes, and when writing of data generated by a plurality of processes in the same node to the distributed shared memory competes. Applies to both.
[0015]
FIG. 2 is a configuration diagram of a node and a network having a communication apparatus using a distributed shared memory to which the present invention is applied. Although two nodes 26A and 26B are illustrated in FIG. 2, even if the number is three or more, the same is true. The main body of each node is a host processor 25A, 25B, local memory 23A, 23B, distributed shared memory 21A, 21B, and a device for transferring messages between distributed shared memories such as distributed memory couplers (distributed memory) 22A and 22B). The host processor is assumed to have a plurality of processes. Local buffers 24A and 24B are placed in the local memories 23A and 23B. Reference numerals 27A and 27B are common paths between the process and the distributed shared memory of the communication system using the distributed shared memory, which is a target whose priority is controlled by the effect of the local buffer.
[0016]
2 to 221D in FIG. 2 are diagrams for explaining the communication apparatus using the distributed shared memory of the present invention, focusing on the transmission operation from the viewpoint of software. 21D is a node, 22D is a software part constituting the node, 23D is a device constituting the node, each AP (a plurality of processes as part of this AP) 24D, OS is 25D, local memory 26D local Buffer 27D, batch transfer unit 221D that can be variably allocated according to the process or message, OS function 222D that manages the local buffer, distributed shared memory 28D, and element area that is divided at a certain scale that is allocated for each message transmission An MB210D, a distributed memory coupler 29D, and a network 211D connecting the nodes are shown.
[0017]
Conventionally, when the message 213D generated in the process 24D is written to the distributed shared memory 28D (215D), the distributed memory coupler 29D simultaneously detects and automatically captures it (216D) (in this case, MB: 210D unit is used) To the network 211D. For example, when using for IP communication, the destination node can be determined for each IP by a method such as using an ARP server of IPoverATM, and it is only necessary to assign the VC, so the applicability to high-speed IP communication is also possible. is assumed.
[0018]
When the local buffer of the present invention is introduced, the message 214D generated in the process 24D is written to the batch transfer unit 221D allocated in the local buffer 27D depending on the process or message characteristics, such as when the real time property is small. (217D) When all the areas in the batch transfer unit 221D are accessed (the batch transfer unit corresponds to the MB of the distributed shared memory 210D), it is written to the distributed shared memory 28D, and at the same time the distributed memory coupler 29D Is automatically captured (219D) (MB: used in 210D units) and sent to the network 211D.
[0019]
FIG. 3 shows configurations 21E to 28E of an example of a memory according to the present invention. A node having this memory configuration is referred to as node A. Reference numeral 21E indicates a range used in the present invention on the local memory, 22E indicates a local buffer, and 23E indicates a distributed shared memory. The distributed shared memory 23E is divided for each MB indicated by reference numeral 26E, and each MB is classified from its own node to all nodes (or communication targets) in all networks, for example, node A> node When a message is written in B's MB (s), the message is sent from this node to node B by the distributed shared memory coupler. Since the same memory structure is adopted in the node B, the message is written in the node A> node B in the node B. 27E indicates an outgoing MB, and 26E indicates an incoming MB. This MB structure is an example of communication using a distributed shared memory and is not a technical matter essential to the present invention, but is described as a reference. The local buffer indicated by reference numeral 22E is divided into batch transfer units, and at least one batch transfer unit is used in each transmission process via the local buffer. It is used while updating sequentially like a line. Based on the message size notified from the AP to the control means at the time of transmission request from the AP, the control means (local buffer management function) determines the capacity of the local buffer used in the transmission, for example, within the range of the double line in the figure ( 25E), the capacity of the entire local buffer 28E can be suppressed without being wasted.
[0020]
FIG. 4 is a diagram for explaining the message communication method on the transmission side of the communication apparatus using the distributed shared memory of the present invention as time elapses. Reference numerals 31A and 31E indicate nodes, 32A and 32E indicate AP layers, and 33A and 33E indicate distributed shared memory and distributed memory coupler layers. Further, reference numerals 34A and 34E denote networks, 31B denotes a local buffer, 32B denotes a distributed memory coupler when the local buffer is used, and 33B denotes a network when the local buffer is used. First, conventional transmission will be described. Prior to sending the message, the process secures MB, which is the write area of the distributed shared memory (notified to the OS and secured, and the address is returned). A message generated in the process is written in an MB indicated by an approximate address in the distributed shared memory, and the distributed memory coupler takes it in parallel and sends it to the network. After the reception of the message is completed on the reception side, a reception completion notification is returned to the transmission side for each MB, and the MB is released for both transmission and reception.
[0021]
By the way, the message 36E having high real-time property generated in the process cannot be written to the distributed shared memory (37E) while the message 36E is written to the distributed shared memory when the large-scale message transmission 35E is mixed, and the message 37E Is written after is written (38E). As a result, it is transmitted on the network at time 311E (310E). When OS interrupts are introduced, when 36E, which has a higher priority than 35E, writes to the distributed shared memory, 35E is interrupted by an interrupt, and 36E is written preferentially. This case is shown in a large-scale message divided into 31D and 32D, and a highly real-time message (31C) is immediately written to the distributed shared memory as 32C.
[0022]
The following shows how local buffers are used in this situation. When the process is activated, it notifies the local buffer management function (in FIG. 2, the OS function 222D that manages the local buffer, which is an extension of the distributed shared memory management function). This may be performed at any time, not during process activation. Prior to writing to the distributed shared memory for transmission from the process, MB is notified to the OS, but the OS reserves a batch transfer unit in the local buffer instead of the conventional MB reserved on the distributed shared memory (within the OS This conventional function is a local buffer management function). The size of the batch transfer unit is determined according to the message size notified in advance by the local buffer management function, and the address is returned. When the real time is high, it is actually a case of a small message, but the batch transfer unit size is set to 0, and the message buffer area is not used as in the conventional route, and is directly written to the distributed shared memory ( The local buffer management function or the address returned by the OS is the MB address on the distributed shared memory as before). A message 31C having a high real time property generated in the process is processed by the distributed shared memory and the distributed memory coupler layer of 33A and 33E in parallel with the generation and sent to the network 34A. When a series of messages 31D and 32D, which are large-scale message transmissions, are mixed, they are processed by the distributed shared memory and distributed memory coupler layers of 33A and 33E and sent to the network 34A in parallel. 36A is a bottleneck network that prevents the transmission of a message generated from 31C and sent to the network, and the message from 31C is sent from time 38A to the network, but is sent from time 39A (message 37A). Since this delay is eliminated by the next operation of the local buffer, the method will be described. The time 310A is the time until the batch transfer unit assigned to the local buffer assigned for the series of messages 31D and 32D is satisfied.
[0023]
When real-time message 31C and large message transmission 31D and 32D are mixed, large message transmission 31D and 32D are held in local buffer 31B for time 310A and sent over the network from time 39A The real-time message 31C can be transmitted on the network at the original transmission time 38A without being interrupted by the large-scale message transmission 31D and 32D network transmission (35A). This is because when a large message is allocated to the MB, the process obtains the address of the batch transfer unit in the local buffer, so it writes to that address, and when the batch transfer unit becomes full, the OS detects this (for example, the distributed memory coupler) The MB write length counting function is expanded to count the local buffer write length, and when the batch transfer unit becomes full, the OS detects it by an interrupt), and small messages waiting for writing to the distributed shared memory, that is, the batch transfer unit Determine if there is a message with a scale of 0, and if so, suspend local buffer writing for large messages, write distributed shared memory for small messages first, and resume local buffer writing for large messages after completion Doing (If you have already written all large messages, start writing other messages) A. If the batch transfer unit size is set large, the time until a large message is written to the distributed shared memory becomes longer, that is, a larger number of real-time messages are preceded by a question that is pending transmission of a large message. Can be sent.
[0024]
Outlines of examples including buffer management and operations of the distributed shared memory coupler are shown in 31F to 319F. Reference numeral 31F indicates a processor module, 32F indicates an application layer (process for transmitting a message), 33F indicates a local buffer management node, 34F local buffer, 35F indicates a distributed shared memory, 36F indicates a distributed memory coupler, and 37F indicates a network. A case is shown where the large-scale message (318F) requests transmission first, and the real-time message (319F) requests transmission during the processing. After a transmission request is made for a large message, the address of the local buffer is indicated and written to the local buffer (38F). At this time, when the area defined in the batch transfer unit becomes full, the distributed memory coupler detects it (312F), notifies the local buffer management function (313F), and if there is a request for transmitting a real-time message, the distributed memory coupler. The real-time message is started to be written into the distributed shared memory from the process instructing to write to the distributed shared memory (39F). When this writing is completed, the distributed memory coupler detects the completion (314F) and notifies the local buffer management function. The local buffer management function starts writing a large-scale message (by 38F) held in the local buffer to the distributed shared memory (315F). When the write is started (310F) and the distributed memory coupler detects the completion of the write (316F), the write completion is notified to the local buffer management function. The local buffer management function instructs management to a local buffer if a new message is large even if there is a continuation of a large message or not (317F), and the message is written to the local buffer. (311F). On the other hand, if it is a small message, the direct write to the distributed shared memory is instructed. As a result, the real-time message is immediately transmitted to the network without being interrupted by the transmission process of the large-scale message from the start of the transmission process.
[0025]
FIG. 5 is a diagram for explaining a message communication method on the receiving side of a communication apparatus using a distributed shared memory when the present invention is applied. In this figure, the flow and direction of information are indicated by arrow lines, the message to be communicated is indicated by a solid line, and the signal is indicated by a broken line. Portions denoted by reference numerals 41B to 46B in the upper stage are diagrams for explaining a message communication system on the receiving side of a communication apparatus using a conventional distributed shared memory that does not use the present invention. 43B indicates a distributed memory coupler, 44B indicates a process, and 41B indicates the arrival of a message from the network. When a large-scale message is sent to the network, the transfer unit to the network side is subdivided into the transmission unit of the distributed memory coupler and sent, so that the large-scale message arrives after being subdivided as in 41B. As soon as the subdivided message arrives, the process can be read and written to the area allocated as the distributed shared memory in the memory in the node. The process recognizes the arrival (45B), and the process reads or manages the process in order. Reading such as transfer to an area is performed (46B). At this time, the process reading process is performed at the time interval 42B, but it corresponds to the transfer unit on the network side or the transmission unit of the distributed memory coupler, that is, to handle the unit subdivided into units unrelated to the process side. Processing of the process is required at intervals of 42B.
[0026]
The diagram indicated by reference numerals 41A to 47A in the lower part of FIG. 5 is a diagram for explaining a message communication system on the receiving side of a communication apparatus using a distributed shared memory when the present invention is used. Reference numeral 43A denotes a distributed memory coupler, 44 denotes a local buffer (a batch transfer unit therein), 45A denotes a process, and 41A denotes arrival of a message from the network. When a large-scale message is transmitted to the network, the message is divided into transmission units on the network side or a transmission unit of the distributed memory coupler, and therefore, the large-scale message arrives after being divided as in 41A. As soon as the subdivided message arrives, it is written into the area allocated as the distributed shared memory of the memory in the node (48A), but once read into the local buffer (the batch transfer unit in it) instead of the process. When the batch transfer unit is full (written to all the areas corresponding to the corresponding MB in the distributed shared memory), the process is notified of message arrival for the first time (46A), and the process reads (47A). The size of the batch transfer unit is determined according to the process (or message characteristics), and is not a sub-unit depending on the network or distributed memory coupler. (42A) process reads in (assuming scale). Therefore, it is not necessary to start the process at an interval according to the sub-unit unit dependent on the network or the distributed memory coupler in the sub-unit interval (42B) depending on the network or the distributed memory coupler as in the conventional method. The start of processing is performed at intervals (42A) that are determined by process-side characteristics such as message processing time within the process (assuming a scale in which a large-scale message is divided into several parts) (ie, at intervals wider than 42B). ), That is, depending on the process-dependent subdivision unit. This is because the size of the batch transfer unit is allocated by the OS according to the size of the message that the process notifies the OS to ensure the security prior to communication, so this size (reading interval from the viewpoint of time) is indirectly set. This is because the process is determined.
[0027]
The local buffer (in 16C, 24A, 24B, 31B, 44B) is given a virtual address corresponding to the distributed shared memory (23A, 23B), and the local buffer management function 222D has a virtual-real address conversion function and local A message direct access command for the buffer is provided. The message buffer area is accessed from the application program / OS as if it were a distributed shared memory by the virtual address. When a process writes to a certain distributed shared memory area or MB, it writes to the batch transfer unit allocated in the local buffer, and when it writes to all MBs of the batch transfer unit, the distributed memory coupler (22B, 29D ) And OS (25D) related distributed shared memory access function (for example, function [1] etc.), write to the corresponding area of the distributed shared memory with almost the same operation as the process writes to DSM in the conventional system However, if the application program / OS or its process issues a direct write command, the entire area of the distributed shared memory is overwritten by the batch transfer unit even if all MBs of the batch transfer unit are not written. The
[0028]
Here, the “virtual address” is provided so that the same interface is provided regardless of whether the local buffer is used or not when viewed from the process. The local buffer is not used even if the virtual address is not used. Although the processing related to the prior transmission of the real-time message by the introduction is performed without change, when the virtual address is used, the memory write address designated by the buffer management function or the process from the OS is designated as a virtual address instead of a real address. The On the other hand, when the process writes, the address specified as the write destination is converted to the address of the local buffer when the buffer management function or the OS passes the buffer, and to the address of the distributed shared memory when the buffer is not passed. And write a message at that address. Furthermore, when the distributed shared memory is designated, there is an application method in which the virtual address is the same as the real address. In this case, only the address designation of the local buffer is performed at the virtual address. If the distributed shared memory has the same address shared by all nodes, the virtual address is used instead of the actual address in each node. Even if the actual address is different in each node, it is as if the same from the process side. It is also possible to make it appear to share a street address. This virtual address assigning means can be easily used for the virtual address assigning means of the present invention if the local buffer and the distributed shared memory are taken on the same local memory. It can be easily unified regardless of whether or not.
[0029]
Similarly, in the case of reading, when the process reads the distributed shared memory area, that is, the MB, the contents of the batch transfer unit allocated in the local buffer are read, but the application program / OS confusion is that the process directly issues a read command. When issued, the batch transfer unit is overwritten by the corresponding area of the distributed shared memory. This message direct access command can forcibly synchronize the contents of the batch transfer unit with the real distributed shared memory in each write / read, and the local buffer or the real distributed shared memory can be kept up to date at any time. is there. Note that the batch transfer unit is incremented in the local buffer in order to prevent the batch transfer unit from being overwritten by the content of the subsequent message before the message arrives at the other party in synchronization with the distributed shared memory and reception processing is performed. It is used while updating the address. Therefore, the maximum area for a batch transfer unit is to secure an area taken for one node on the distributed shared memory, that is, about an MB area for one node. For example, if there is only one type of process for sending a large-scale message, for example, 256 buffers of 256 sources may be used, and 64 KB is sufficient. However, since it is sufficient to allocate only to a process that sends a large-scale message, and only the number of processes that are simultaneously transmitted, the size may be sufficiently smaller than the distributed shared memory. Therefore, the capacity of the local buffer is smaller than that of the memory and does not affect the application program or the OS.
[0030]
Since one MB is used for a single message transmission request from a process, if the MB size is increased more than necessary compared to the assumed message size, a part of the MB that is wasted is generated, and the distributed shared memory Usage rate decreases. Therefore, the MB size of the distributed shared memory is subdivided into a relatively small size in accordance with the normally assumed message size, and the MB size is the same in order to avoid complicated MB management. Therefore, for example, for large messages and small messages coexisting, large and small MBs are set, large MBs are used for large messages, and small M8s are used for small messages. A method of giving priority to transmission by temporarily waiting for writing to the distributed shared memory when a large MB is selected is not desirable because it leads to complicated MB management. Large-scale message transfer generally does not require large real-time characteristics. When high-speed transfer and small-scale message transfer that require small real-time characteristics, such as inter-node control messages, are mixed, The waiting for transmission in the network that occurs during transfer prevents high-speed transfer that requires real-time performance. In FIG. 3, since the large-scale message 31D requires time 36D for transmission due to a delay in the network, the transmission of the small-size message 31C having high real-time characteristics extends to 37A. If the size of the batch transfer unit is set based on the size of the message to be sent, 31D transmission will wait until the batch transfer unit is satisfied at time 310A, during which time 31C can send and wait at 35A. Sent without. On the receiving side, the batch transfer unit is satisfied by the arrival of a certain part of the message, so that the reading is performed in response to the detection of the OS in accordance with the arrival of the certain part of the message.
[0031]
In FIG. 5, the process 44B needs to run a process for reading a message at 42B intervals in the past, and the read size is a message scale unit that a communication device using a distributed shared memory communicates at one time. According to the present invention, at intervals of 42A, that is, the process 45A only needs to run a single reading process during the arrival of a message, and the communication device using the distributed shared memory communicates at a plurality of times. The scale is the same size.
[0032]
6 to 8 are flowcharts of a shared memory write operation of the priority control method in the inter-process communication using the distributed shared memory according to the embodiment of the present invention, or a transmission operation to the partner node. The system components are described separately for an application program and OS (operation system) that are software, and a local memory and transmission device that are hardware. The application program shows the process of sending a large message and the process of sending a small message. The OS is a local buffer management function (abbreviated as BAM), and the local memory is a local buffer (abbreviated as BA). It is composed of a distributed shared memory (abbreviated as DSM), and the transmission device is assumed to be a distributed memory coupler, for example.
[0033]
6 to 8 show a case where a process in a transmission node first makes a message transmission request. When a small message transmission request is made first, it is immediately transmitted without going through the local buffer. That is, after the determination “message size> boundary”, it becomes * 3, which is almost the same as the transmission mode in the case where there is no mechanism according to the present invention such as the local buffer and its management function. In this case, it is also shown in FIG. In FIG. 6, the transmission request from the process and the queue structure from which the OS (local buffer management function) fetches the request include at least the process name and message size information. “Boundary” means the upper limit of the message scale handled as a real-time message. This upper limit is a value set in the OS (local buffer management function) prior to the start of transmission processing. * 4 The same method may be used.
[0034]
When a process in the application program notifies the local buffer management function of a transmission request for a large message (the process is described as a large message process in FIG. 6), the message size (generated data size or message) is included in this notification. Size) is included, and the local buffer management function that was waiting for a transmission request from the process determines whether the message size exceeds the boundary value. If it exceeds, the message is handled as a large message. The size of the batch transfer unit allocated in the local buffer (predetermined buffer capacity) and the address of the batch transfer unit are determined and notified to the large-scale message process. If the boundary is not exceeded, it is handled as a small message, that is, a real-time message, and the MB address in the distributed shared memory is determined from Fig. 6 * 3 and notified to the process that sent the small message (denoted as a small message process) Then, the process writes the message into the MB, the message is transmitted to the destination process of the partner node in parallel with the writing by the distributed memory coupler, and the local buffer management function returns to the state waiting for the transmission request from the process. The large-scale message process writes the message to the address of the notified batch transfer unit, and continues to store the message in the local buffer until the write fills the batch transfer unit. The batch transfer unit scale is determined based on the data size notified from the process, and the value determined by the local buffer management function is used. In the distributed memory coupler, whether the data length in MB has reached a predetermined scale ( Similarly, in general message transmission devices, there is a function to monitor whether the data length in the buffer corresponding to the transmission buffer has reached a predetermined scale) and to notify the OS when it reaches the scale, and the local buffer management function The determined batch transfer unit scale is set in a memory area that can be referred to by the distributed memory coupler. The distributed memory coupler monitors whether the value of the data written in the local buffer on the local memory as in the distributed shared memory has reached this value, and if it detects that the batch transfer unit is full, the local buffer management function The local buffer management function is transferred to the local buffer management function, and the large-scale message process interrupts writing to the local buffer.
[0035]
Whether or not to transfer via the local buffer is determined based on whether the message size (message size) notified from the process to the local buffer management function exceeds a predetermined data length, that is, a boundary. The process can also notify the local buffer management function of a command or a bit string indicating whether or not the message requested to be transferred from the process to the local buffer management function is handled as a priority message. Furthermore, the means for determining whether or not the generated message size to be transferred exceeds a predetermined data length can be provided not only by the local buffer management function, that is, the control means, but also by the process itself. Therefore, it is possible to determine whether the message generated by the process itself is written in the local buffer or directly transferred to the distributed shared memory.
[0036]
The scale of the batch transfer unit for transferring the data written in the local buffer to the distributed shared memory, that is, the predetermined buffer capacity can be determined based on the message size generated by the local buffer management function (control means). , Takes a value independent of the boundary value (predetermined data length), but can be determined depending on the boundary value (predetermined data length), for example, a value equal to the data boundary value (predetermined data length) It is also possible to set to.
[0037]
The method of * 1 step in FIGS. 6 to 8 differs depending on the function of the OS. FIGS. 5 to 7 describe cases where the display of the operation is easy. After the large-scale message process interrupts the writing, the local buffer management function waits for a process transmission request for a certain period of time. A message whose message size is less than or equal to the boundary value is selected from processes that have requested transmission within this time, that is, the message is treated as a real-time message, and MB in the distributed shared memory is allocated. This MB address is notified to the process that sends the message (small message process in FIG. 5), and the process writes the message to the specified MB in the distributed shared memory, and the message is written in parallel with the distributed memory coupler. Sent to the destination process of the other node. When the message writing from the small message process to the distributed shared memory is completed, the local buffer management function writes the previous large message stored in the batch transfer unit of the local buffer to the distributed shared memory, and the messages are processed in parallel. Sent to the destination process of the partner node. Subsequently, when there are remaining messages of the suspended large-scale message process, the local message write is instructed following the large-scale message process.
[0038]
If there is a local buffer write of a large message, the write is continued until the batch transfer unit is full, and when it is full, the distributed memory coupler detects it, notifies the local buffer management function by an interrupt, and controls the local buffer management function. The large message process ceases writing to the local buffer. That is, it returns to * 2 of FIG. By the way, * 1 of FIG. 6 assumes the following case more than the above-mentioned case. While a process is sending a transmission message to a program or OS for transmission processing, it is assumed that the OS generally has scheduling for accepting transmission requests from other processes by a timer or the like in the OS. obtain. In this case, during the process of writing a message from a large message to the local buffer, that is, in * 2 of FIGS. 6 to 8, a transmission request from another process is accepted by the local buffer management function. A message whose message size is equal to or smaller than the boundary value is selected, that is, the message is treated as a real-time message, and MB in the distributed shared memory is allocated. Thereafter, the operation starts from the location indicated by the above-mentioned “[#]”. Note that the process to be transmitted is not limited to the application process, but the operation is performed in the same manner even if it is a process in the OS.
[0039]
The following (i) to (iii) are also shown as advantages of the present invention from the embodiments shown in FIGS. (I) Once stored for each batch transfer unit of a predetermined data capacity, transmission of a large message waits in the local buffer, and small messages generated during that time are sent prior to the large message. It is done. (Ii) If the size of the batch transfer unit is large, the time until the full transfer unit becomes full increases, and the rate at which small messages precede is increased accordingly. (Iii) The size of the batch transfer unit indicates not only the size but also whether it is zero or not, and it indicates the presence or absence of real-time property, and the priority can be controlled with one parameter. Moreover, since the parameter value is determined by the size of the message transmitted at a time, the priority can be indirectly controlled on the application side.
[0040]
FIG. 9 is a flowchart of the shared memory read operation of the priority control method or the reception operation from the partner node in the process inquiry communication using the distributed shared memory according to an embodiment of the present invention. In this flow, 2 steps of a are related to reading process arrival messages, and 9 steps of b are related to reading into buffers performed by the local buffer management function independent of the process.
[0041]
The message size received from the process is notified in advance to the local buffer management function (222D) in the OS at the time of process activation or transmission start, and the local buffer management function determines the batch transfer unit size based on the value. When a message starts to arrive from the sending node, a message is written to the distributed shared memory in parallel with the arrival, the arrival is notified to the local buffer management function, the local buffer management function reads the message from the distributed shared memory to the local buffer, and batches If the transfer unit size is reduced, the local buffer management function notifies the process that the size has been reached and the MB address corresponding to the distributed shared memory, and the process specifies the MB in which the message is stored, and the specified MB. The contents of the local buffer corresponding to the above, that is, the batch transfer unit, are sent to the process all at once. Although the actual state of the parts sent in a batch may be a repetitive operation as shown in FIG. 7c, the process is regarded as a single transfer operation. When the batch transfer unit is sent, the local buffer management function updates the address of the batch transfer unit in order to read the subsequent message from the distributed shared memory. Until all messages in the MB are read into the local buffer, reading into the local buffer and sending to the process are repeated. However, when all the messages in the MB are read, the reception operation of the local buffer management function ends.
[0042]
In addition to notifying the process from the local buffer management function to the process that the batch transfer unit size has been reached, the process may start a series of operations regardless of the direct call command, that is, the notification from the local buffer management laterality. This makes it possible to autonomously instruct message reading from the process side. A write operation from a process to a distributed shared memory or a transmission operation to a partner process can be said to be almost the reverse operation. Note that the transmission side and the reception side are independent with respect to the local buffer, and can operate even if this function is set only on the transmission example or only on the reception side, and each has an effect. On the sending side, it is possible to avoid the transmission of real-time messages from being disturbed by a large-scale message due to a bottleneck in the network. On the receiving side, a device that transfers messages between distributed shared memories in a similar situation The phenomenon that a large-scale message hinders the reception of a real-time message, which occurs when the reading speed on the process side with respect to the writing speed to the distributed shared memory becomes a bottleneck, can be avoided.
[0043]
The present invention is not limited to the above-described embodiments, and various changes and modifications can be made. For example, the logic for determining that the batch transfer unit scale is 0 may or may not be applied to a large-scale message. It is possible to change the determination as to whether or not the message is a real-time message by changing the determination criterion, and the present invention is not limited to always handling a small message as a real-time message. Is not limited to being treated as a real-time message.
[0044]
【The invention's effect】
As described above, according to the present invention, it is possible to ensure the real-time property of inter-node communication according to the characteristics of a message generated by a process only by designating the use area size of a local buffer. (A) Add buffer (and DSM write command from buffer), (b) Add AP interface to notify batch transfer unit size, (c) Extend DMC transmission message length counting to local buffer With such a simple correction, there is an effect that it is possible to ensure the real-time property of the inter-node communication by the communication device using the same distributed shared memory without depending on the process.
[Brief description of the drawings]
FIG. 1 is a diagram showing an arrangement of a network model configuration using a general high-speed communication method to which the present invention is applied and an example of a relationship, and particularly shows an access mode to an AP or process communication device.
FIG. 2 is a diagram showing a node and network configuration having a communication apparatus using a distributed shared memory according to the present invention.
FIG. 3 is a diagram showing an example of a memory structure.
FIG. 4 is a diagram for explaining a message communication method over time on a transmission side of a communication apparatus using a distributed shared memory according to the present invention.
FIG. 5 is a diagram showing a message communication method on the receiving side of a communication apparatus using a distributed shared memory.
FIG. 6 is a diagram showing a part of a flowchart of a shared memory write operation using a local buffer or a transmission operation to a partner process on the transmission side of a communication apparatus using a distributed shared memory according to the present invention.
FIG. 7 is a diagram showing a part of a flowchart of a shared memory write operation using a local buffer or a transmission operation to a partner process on the transmission side of a communication apparatus using a distributed shared memory according to the present invention.
FIG. 8 is a diagram showing a part of a flowchart of a shared memory write operation using a local buffer or a transmission operation to a partner process on the transmission side of a communication apparatus using a distributed shared memory according to the present invention.
FIG. 9 is a flowchart of a shared memory read operation using a local buffer or a reception operation from a partner process on the reception side of a communication device using a dedicated shared memory according to the present invention.
[Explanation of symbols]
11A, 11B, 11C communication equipment
12A, 12B, 12C OS
13A, 13B, 13C, 15C APs
14A, 14B Conventional access mode
14C Access form according to the present invention
16C local buffer
21A, 21B, 28D Distributed shared memory
21C, 211D network
22A, 22B, 29D Device for transferring messages between distributed shared memories (distributed memory coupler)
23A, 23B local memory
24A, 24B, 27D local buffer
25A, 25B processor
26A, 26B, 21D node (processor module)
27A, 27B common road
22D software layer
23D equipment
24D application program
25D OS
26D local memory
210D Message buffer (MB)
Messages sent to 212D and 220D networks
Messages generated by 213D, 214D 24D
Message written to 215D 28D
213D, 216D Messages automatically detected by the distributed memory coupler
Message written to 213D, 217D 27D
Messages written to 214D, 218D 28D
214D and 219D messages automatically detected by the distributed memory coupler
214D, 221D batch transfer unit
222D OS function to manage local buffers (local buffer management function)
31A, 31E processor module
32A, 32E application layer
33A, 33E Distributed shared memory and distributed memory coupler layer
34A, 34E network
35A Real-time messages that can be sent over the network at the original transmission time
36A, 39E Large messages sent over the network
37A Real-time message with network waiting and waiting
38A Original transmission time of highly real-time messages
39A Highly real-time message transmission time when the network becomes a bottleneck and waits
310A Time when a large message is held in the local buffer
31B local buffer, 32B ... Distributed memory coupler when using local buffer
Network with 33B local buffer
Send real-time messages in 31C, 36E applications
Sending large messages in 31D, 32D, and 35E applications
37E Large message written to distributed shared memory
38E Real-time message written to distributed shared memory
310E A real-time message sent over a network that has been waiting because a large message is written to distributed shared memory
311E Real-time message transmission time when a large message is written to distributed shared memory
41A Message arrival interval from source node
41B Message arrival interval from the source node
42A interval between the first notification of a message and the time it is read by the process
42B interval between message arrival notification and read into process
43A Distributed Shared Memory in Communication Equipment Using Distributed Shared Memory
43B Distributed shared memory in communication devices using distributed shared memory
44A local buffer
44B, 45A process
A 45B message arrival notification sent to a process from a communication device that uses distributed shared memory each time a message arrives
46A Transmission arrival notification sent to a process from a communication device using distributed shared memory when the head of a series of messages arrives
46B Message read into the process from the distributed shared memory in the communication device using the distributed shared memory
47A Message read into process from local buffer

Claims (22)

A plurality of nodes are interconnected via a network, and each node has one or more processes for generating data or messages, and a memory having a distributed shared memory used to share data with other nodes Each node comprising: control means for controlling writing of data to the distributed shared memory; and a data transfer device for transmitting data written to the distributed shared memory to the network and receiving data sent from the network. in, the data in its own distributed shared memory is written, its data transfer device, in inter-process communication method using the distributed shared memory to be transferred respectively to the distributed shared memory of automatically forwarding node the data ,
Each node has a local buffer for temporarily storing data generated by the process, and the control means stores the data in the distributed shared memory when the data size of the data generated by the process is equal to or less than a predetermined data length. When a data size of directly written and generated data exceeds the predetermined data length, the data is temporarily written in the local buffer and then written in the distributed shared memory. Interprocess communication method.   2. The inter-process communication method using a distributed shared memory according to claim 1, wherein the process notifies the control means of the data size of the generated data, and the control means notifies the data size of the predetermined data length. A process for interprocess communication using a distributed shared memory, characterized in that control is performed so that data is written to a local buffer or distributed shared memory based on the determination result.   3. The interprocess communication method using the distributed shared memory according to claim 2, wherein the control means is a predetermined process generated by another process during a period in which data generated by the process is written in a local buffer. A method for interprocess communication using a distributed shared memory, wherein control is performed so that small-scale data having a data size equal to or smaller than the data length is directly written directly to the distributed shared memory.   4. The inter-process communication method using the distributed shared memory according to claim 1, wherein when the data generated by the process exceeds the predetermined data length, the control unit stores data in the local buffer. A distributed control characterized in that when the written data reaches a buffer capacity of a predetermined size, the write control is performed so that the written data of the predetermined buffer capacity is collectively written in the distributed shared memory. An interprocess communication method using a shared memory.   5. The interprocess communication method using a distributed shared memory according to claim 4, wherein the control means determines the size of the predetermined buffer capacity to be transferred in batch according to the data size notified from the process. An interprocess communication method using a distributed distributed memory.   The interprocess communication method using the distributed shared memory according to any one of claims 1 to 5, wherein the control means uses a local write used based on a data size of data to be transferred received from a process. An interprocess communication method using a distributed shared memory, characterized in that a buffer capacity is determined and a write area for a local buffer is secured.   7. The inter-process communication method using the distributed shared memory according to claim 1, wherein when the control unit receives a data write request from a process, the data size of the data is the predetermined value. If the data length is equal to or less than the data length, information specifying the write area to the distributed shared memory is given, and if the data size exceeds the predetermined data length, information specifying the write area to the local buffer is given An interprocess communication method using a shared memory.   The interprocess communication method using the distributed shared memory according to any one of claims 1 to 7, wherein the process has a function of generating a command indicating that the process should be preferentially written to the distributed shared memory. The control means controls the distributed shared memory to directly write the data in the distributed shared memory regardless of the data size for the data designated by the command to be preferentially written. The interprocess communication method used.   9. The interprocess communication method using a distributed shared memory according to any one of claims 1 to 8, wherein the local buffer is provided in an OS or an AP layer. Communication method.   The inter-process communication method using the distributed shared memory according to any one of claims 1 to 9, wherein the control means is provided in an OS or an AP layer. Interprocess communication method.   The interprocess communication method using the distributed shared memory according to any one of claims 1 to 10, wherein the data received by the data transfer device is stored in the local buffer and then transferred to the process. An interprocess communication method using a distributed shared memory. In a data processing apparatus used for a communication system between nodes using a distributed shared memory and having a communication function,
One or more processes that generate data, a memory having a distributed shared memory used to share data with other nodes, a control means for controlling the writing of data to the distributed shared memory, and a distributed shared A data transfer device for transmitting data written in the memory to the network and receiving data sent from the network, and a local buffer for temporarily storing the data generated by the process,
The control means writes the data directly to the distributed shared memory when the data size of the data generated by the process is equal to or smaller than a predetermined data length, and when the data size of the generated data exceeds the predetermined data length, the local data What is claimed is: 1. A data processing apparatus comprising: controlling data to be written in a distributed shared memory after being temporarily written in a buffer.   13. The data processing apparatus according to claim 12, wherein the process notifies the control means of the data size of the generated data, and the control means determines whether or not the notified data size exceeds a predetermined data length. A data processing apparatus that controls to write data to a local buffer or a distributed shared memory based on the determination result.   14. The data processing device according to claim 13, wherein the control means has a data size equal to or smaller than a predetermined data length generated by another process during a period in which the data generated by the process is written in a local buffer. A data processing apparatus that controls to directly write small-scale data directly to the distributed shared memory.   15. The data processing device according to claim 12, wherein when the data generated by the process exceeds the predetermined data length, the control unit writes the control unit to the local buffer. A data processing apparatus, characterized in that, when written data reaches a buffer capacity of a predetermined size, control is performed so that the written data of the predetermined buffer capacity is collectively written in the distributed shared memory.   16. The data processing apparatus according to claim 15, wherein the control means determines a size of the predetermined buffer capacity to be collectively transferred according to a data size notified from a process.   17. The inter-process communication method using the distributed shared memory according to claim 12, wherein the control unit is used for writing based on a data size of data to be transferred received from a process. A data processing apparatus characterized by determining a capacity of a local buffer and securing a write area for the local buffer.   16. The data processing apparatus according to claim 12, wherein when the control means receives a data write request from a process, the control means distributes when the data size of the data is equal to or less than the predetermined data length. A data processing apparatus, characterized in that information specifying a write area to a shared memory is given, and information specifying a write area to a local buffer is given when the data length exceeds a predetermined data capacity.   19. The data processing device according to claim 12, wherein the process has a function of generating a command indicating that the process should be preferentially written to the distributed shared memory, and the control unit includes: A data processing apparatus, wherein the data designated by the command to be preferentially written is controlled so that the data is directly written into the distributed shared memory regardless of the data size.   9. The interprocess communication method using a distributed shared memory according to any one of claims 1 to 8, wherein the local buffer is provided in an OS or an AP layer. Communication method.   21. A data processing apparatus according to claim 12, wherein said control means is provided in an OS or an AP layer.   The data processing device according to any one of claims 12 to 21, wherein the data received by the data transfer device is stored in the local buffer and then transferred to a process.

Images