KR20010010275A - An interprocess communication method utilizing message queue combined with shared memory - Google Patents

Abstract

PURPOSE: A method for performing IPC(Inter-Processor Communication) is provided to pass a message parameter through a shared memory and to pass address information and a message name through a message queue, to couple a message queue system with a shared memory system, so as to increase capacity efficiency of an application in which the IPC is frequently used. CONSTITUTION: An event control block(14) transmitted by a process A(12) is received in a process B(13) by a receiving system call of a message queue of an operating system. The process B(13) firstly obtains a message name(20), an operation variable(21), and a user control block address information(22) from the received event control block(14). The user control block address information(22) is allocated by the process A(12) on a shared memory(11). The process A(12) is capable of accessing a user data block(16) for setting up a message parameter(23) with the allocated user control block address information(22). The process B(13) is capable of obtaining the message parameter(23) on the basis of the user control block address information(22). All information such as the message name(20), the operation variable(21), and the message parameter(23) which the process A(12) attempts to transmit, is exactly transmitted to the process B(13).

Description

An interprocess communication method utilizing message queue combined with shared memory}

The present invention relates to a communication method for supporting when communication between processes occurs frequently in an application composed of several processes, and in particular, a communication that can efficiently communicate between processes by using a message queue and a shared memory in combination. It is about a method.

The communication protocol is generally divided into several layers, and each layer is combined with other layers to perform a whole function. In other words, it receives a request from a lower layer and sends it to a higher layer after performing a layer-specific process, or sends it to a lower layer after processing a request of a higher layer. When implementing a communication protocol, unless all protocol layers are configured as one process, each layer or several layers will be grouped into several independent processes, so the operation of the entire protocol is the mutual cooperation of several processes. Will be done under Therefore, the problem of interprocess communication has emerged as an important problem.

There are several types of interprocess communication mechanisms in the UNIX System V operating system, including Message Queue, Shared Memory, and Semaphore.

Message queuing includes useful features such as message queuing, process synchronization according to message status, and message priority, but the system itself uses system calls because the contents of the data are stored in kernel space. There is a lot of movement of data between user space and kernel space. The reason is that if a user wants to send a message, it is stored in a variable in user space, and then the data is copied from user space into kernel space by the message queue sender system call, and when any process receives it, it receives the message queue. This is because the data is copied from kernel space to user space by the system call. If you want to send / receive long messages, you will spend a lot of time moving data between user space and kernel space.

In the shared memory method, multiple processes can share user space to read or write data. Shared memory only stores its control information in kernel space, and the rest is in user space so that each process can exchange data by writing or reading data to its own variables. However, since shared memory does not provide a synchronization mechanism for sending and receiving data, processes must write some data and read some data. In the context of a communication protocol in which multiple processes send and receive multiple messages simultaneously, a fairly complex control may be required when deciding such protocols, requiring a high cost of control.

The semaphore method supports mutual exclusion, allowing synchronization between multiple processes when accessing a single data at the same time. However, this method only supports synchronization and no data transfer. Since the purpose of communication between communication processes is the movement of data, this method cannot support the transmission and reception of data by itself.

When a process sends a message to another process, the attributes of the message are divided into two major parts. One is the name of the message and one is the parameters of the message. These are specified when defining the interface between both processes. In general, the name of a message is of fixed length, and the parameters in the message vary depending on the message characteristics.

In the present invention, in the interprocess communication, the above two message attributes, that is, message names and message parameters, are divided and communicated using different techniques. That is, information related to the name of the message communicates using the message queue, and parts related to parameters in the message communicate through the shared memory. The shared memory location containing the parameters is passed along when the name of the message is passed by the message queue. If process A wants to deliver a message to process B, process A sets the parameters of the message in shared memory and sets the information associated with the name of the message in the message queue's data structure. In addition, the address information of the shared memory with parameters is set in the data structure of the message queue. The process B receives the message name and the address information of the shared memory from the message queue, and obtains the parameter information set by the process A from the shared memory indicated by the address information.

Accordingly, the present invention relates to a method for achieving efficiency in interprocess communication by combining and using only the advantages of the message queue method and the shared memory method. In the message queue method, message synchronization and message waiting functions are used. By reducing only the fixed short data related to the data, the overhead due to data movement between kernel space and user space is reduced to the maximum. It is to provide a communication method between processes using a message queue and shared memory that can be solved by mixing the message queue method.

The present invention for achieving the above object is a method of inter-process communication, the message parameter of the variable information through the shared memory, the fixed information address information and the message name through the message queue, And a shared memory method.

1 is a conceptual diagram of an interprocess communication method through a message queue and a shared memory according to the present invention;

2 is a structural diagram of an event control block;

3 illustrates mapping between an offset address space and an absolute address space.

4 is a diagram illustrating a procedure of an address translation function.

<Description of Signs of Major Parts of Drawings>

11: shared memory 12: process A

13: Process B 14: Event Control Block

15, 16, 17 and 18: user data blocks

20: Message name 21: Operating variable

22: user control block address information 31: message name field

32: source message queue number field 33: destination message queue number field

34: user instance number field 35: user data block offset field

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

1 conceptually displays the contents of communication between processes through a message queue and a shared memory according to the present invention, and shows a form in which interprocess communication is performed.

Assuming that process A 12 is an originating process to which a message is to be sent, and process B 13 is a destination process that will receive the message sent by process A 12, process A 12 is the message of the message. The contents are separated and divided into a message length (20), an operating variable (21), etc., of which the length is fixed, and a message parameter (23), of the variable length. The fixed part is set in the data structure called the event control block 14, and the variable part is one of the pools 15, 16, 17, 18 of the user control block on the shared memory 11 (16). Gets assigned and sets it there. Thereafter, the address information 22 of the assigned user data block is set in the event control block 14. When the setting of the event control block 14 is completed, the process A 12 transmits the event control block 14 using the message queue transmission system call of the operating system.

The event control block 14 transmitted by the process A 12 is received by the process B 13 by the message queue receiving system call of the operating system. Process B 13 then first obtains the message name 20, operational variables 21, and user control block address information 22 in the received event control block 14. The user control block address information 22 is address information that can be accessed by the user data block 16 in which the process A 12 has been assigned on the shared memory 11 and set the message parameter 23. In this way, the process B 13 can obtain the message parameter 16. This ensures that all information, such as message name 20, operational variable 21, and message parameter 23, that process A 12 is trying to send, is correctly transmitted to process B.

FIG. 2 specifically shows the structure of the event control block 14 mentioned in the description of FIG. 1.

The message name field 31 is a place for storing number information for distinguishing a plurality of messages used for transmission / reception between processes. The definition of this number information is by a predetermined agreement between the processes involved in the communication. This field has an integer value length of 4 bytes. The source message queue number field 32, the destination message queue number field 33, and the user instance number field 34 are places that hold operational variables associated with the message. Source message queue number 32 means the number of the receiving message queue of the process to which to send the message, and destination message queue number 33 means the number of the receiving message queue of the process to receive the message. The reason for running this information is that when you receive and process a message, you can easily find the destination when you want to return the message, and when you need to monitor the interprocess communication for debugging purposes, This is to make it easy to recognize the source and destination of the messages. The message queue number is defined here as an integer length of 4 bytes in the operating system's message queue system call definition.

The user instance number 34 is a number for identifying a case where a message to be transmitted / received is associated with a user's own execution case. If process A requests to send a message to process B while concurrently processing a case of user A and user A, then it assigns a unique user instance number for A and B and the user instance number field of each related message. Send an instance number per user to (34). Receiving this, process B keeps the received user instance number as it is, and sends it as it is when sending the message result so that process A can distinguish the user execution cases related to the received message. The length of this user instance field is also operated as a 4-byte integer value.

Finally, the user data block offset field 35 is a place for the address information of the user data block mentioned in FIG. In this case, the concept of offset does not mean an absolute value of an address, but a relative position that assumes a starting point of a shared memory address as 0. This is because when two processes use shared memory, the absolute address value for that shared memory differs from process to process. This will be described in detail with reference to FIG. 3.

As defined above, since the event control block 14 is composed of five fields having a length of 4 bytes, the event control block 14 has a fixed length of 20 bytes in total.

FIG. 3 shows that the absolute address spaces are different in each process of the shared memory, and shows a mapping relationship with the offset spaces introduced to match them.

When the shared memory 52 is created on the system, it is settled in an area of the operating system. To use the process, the system call attaches the shared memory 52 to the address area of the process. Will be used. When the procedure of attaching the shared memory 52 in the process is successfully performed, the process can use the shared memory 52 as its own area. The address spaces 51 and 53 used by each process are different from each other, so that the address space of one process is valid only for that process and is meaningless to other processes. That is, process A attaches and uses shared memory from 0x10,000 address 64 to 0x19,999 address 67, and process B attaches 0x20,000 address 68 to 0x29,999 address 71. use.

When process A allocates user data block 1 (80) in the shared memory space and sets a message parameter to it and delivers it to process B, 0x11,000, which is the absolute address value on process A of the user control block 1 (80). The address 65 becomes meaningless in Process B. In the present invention, a relative address space called an offset is introduced and corrected.

The offset address space consists of a relative address value representing the increment of the absolute address from that point by setting the starting value of the shared memory absolute address space of each process to zero. Therefore, the start address is 0 and the end address is 1 minus the shared memory size. This offset address space is operated for each process. In FIG. 1, the offset address space 50 of process A is operated in correspondence with the absolute address space 51 of process A, and the offset address space 54 of process B corresponds to the absolute address space 53 of process B. Operate. The start address and the end address of the offset address space 50 of the process A correspond to the 0x10,000 address 64 and 0x19,999 address 67 which are the start address and the end address of the address space 51 of the process A, It is operated as 0 (60) and 9,999 (63), respectively, and the start address and end address of the offset address space 54 of process B are 0x20,000, which is the start address and end address of the address space 53 of process B ( 68 and 0x29,999 address 71, 0 (72) and 9,999 (75), respectively. Therefore, since the address values 60, 63, 72, and 75 of the offset address spaces 50 and 54 of the two processes coincide with each other, they can be utilized as shared memory address information to be exchanged between processes.

To explain this in the case of the transfer of the inter-process user data block 1 (80), for example, after completing the setting of the message parameter in the user data block 1 (81), the address information of the absolute address 0x11,000 Instead of sending the address 65, the address 1000 corresponding to the address 65 is transmitted. The process B receives the address 1000 (73) and the address 0x21,000, which is the absolute address of the process B, and accesses the message parameter transmitted by the process A from the address.

In the operation of the offset address space, the conversion between the absolute address value and the offset address is solved by operating the address conversion functions 55 and 56 for each process. Details of the address translation function are described in detail with reference to FIG. 4.

FIG. 4 illustrates a procedure of an address translation function that converts between an absolute address value and an offset address value in a process in the form of pseudo code.

UDBini () 90 performs shared memory creation and initialization, and UDBreal () 91 and UDBoffset 92 convert the offset address into an absolute address or the absolute address into an offset address, respectively. Processes that want to use shared memory should initially use UDBini () (90) once. After setting the data in the user data block, the source process converts the absolute address of the user data block into an offset address through UDBoffset () 92 and sends the address value to the destination process. After that, the destination process converts the received offset address value into its absolute address value through UDBreal () 91 and then accesses the user data block.

In detail, the UDBini () (90) first creates a shared memory (100) and attaches it to its own address space. The starting address of the shared memory is a static address in the process. Must be stored in ShmStartAddr (101). In UDBreal () (91), an offset address value is received as an input parameter.The offset address value 0 corresponds to ShmStartAddr, which is the start value of the absolute address space. Since it becomes an absolute address value in memory, it is returned (103). On the contrary, UDBoffset () 92 receives an absolute address as an input parameter, and a value obtained by subtracting ShmStartAddr becomes an offset address value corresponding to an absolute address value in shared memory, thereby returning it (104).

The present invention described above is capable of various substitutions, modifications, and changes without departing from the spirit of the present invention for those skilled in the art to which the present invention pertains. It is not limited.

As described above, the interprocess communication method using the message queue and the shared memory in accordance with the present invention has only the advantages of process synchronization of the message queue, message waiting function, and data access that does not require data movement between kernel / user of the shared memory. By utilizing the combined use, there is an advantage that the overall overhead of the application, such as a communication protocol that frequently uses the inter-process communication function is frequently reduced by reducing unnecessary overhead in performing inter-process communication.

Claims (5)

In the method of communication between processes, The message queue is characterized by using a combination of the message queue method and the shared memory method by passing the parameter of the message as variable information through the shared memory and the address information and the message name as the fixed information through the message queue. Communication method between processes using shared memory. The method of claim 1, When communicating with the message queue, a fixed-length data structure called an event control block may be defined and a message name field, source message queue number field, destination message queue number field, user instance number field, and user data block offset field may be specified therein. A method of communication between processes using a combination of message queues and shared memory, characterized in that it uses a scheme to ensure that. The method of claim 1, In setting the address information of the shared memory, a relative address space called an offset address space is defined by resetting the start value of the shared memory absolute address of a process to 0, since the shared memory absolute address value of a process is meaningless to other processes. A method of communication between processes using a message queue and a shared memory, comprising using an address mapping scheme in which offset address information information is meaningful to other processes by introducing a new scheme. The method of claim 3, wherein In order to perform the conversion between the offset address space and the shared memory absolute address space, communication between processes using a message queue and shared memory is performed, using a procedure using three functions of UDBini (), UDBreal, and UDBoffset (). Way. The method of claim 4, wherein The procedure using the three functions of UDBini (), UDBreal, and UDBoffset () comprises the steps of creating and initializing shared memory in UDBini (); Setting data in the user data block in the source process, converting the absolute address of the user data block into an offset address through UDBoffset (), and transmitting the address value to the destination process; Communication between processes using a message queue and shared memory, comprising converting the offset address value received from the destination process to its own absolute address value through UDBreal () and then accessing the user data block. Way.