JP2000347881A - Method and device for interprocess communication and information storage medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To confirm a history of transmission and reception messages of an interprocesses communication on a UNIX operating system and to enable a method and a device for interprocess communication to be used in common by other systems. SOLUTION: This communicating method allows a communication among processes 6a to 6c by a library 5 composed of a common memory (shared memory) 2, a FIFO file 3, and the processes 6a to 6c by using a history of transmission and reception messages corresponding to variable message length. At this time, the history of the transmission and reception messages is left corresponding to the variable message length irrelevantly to fork/exec where a master process actuates a slave process and the communication among the processes is carried out by the library where the history is left.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] The present invention relates to a UNIX operating system (OS). The present invention relates to a variable length data storage area (as appropriate for a message variable length) regardless of a parent-child relationship (fork / exec) in which a parent process starts a child process. The history of transmission / reception data is left in accordance with the description, and communication between multiple processes using the library (IPC: interprocess
The present invention relates to an inter-process communication method and apparatus for performing communication, and an information recording medium.

[0002]

2. Description of the Related Art Conventionally, in a UNIX OS, data (appropriately,
Interprocess communication (I
PC). In the UNIX / OS inter-process communication, when the communication data amount is large and the message load is high, the maximum allowable value is limited when the inter-process communication is performed using a FIFO file, a socket (a system that provides an endpoint), or the like. Will be.

Further, when a failure occurs in the UNIX OS, the contents of transmission and reception of the message in the process in which the failure has occurred are important in removing the failure. In a system that performs processing while exchanging messages between a plurality of processes, for example, in a program debug, a history of the exchange of messages is monitored (for example, Japanese Patent Application Laid-Open No. 5-12069, “Debug Method”). Example).

[0004] In the conventional UNIX OS, it is not possible to leave a message history just by transmitting and receiving a message. Further, even during operation, transmission / reception messages between processes cannot be confirmed in real time. Confirmation of transmitted / received messages in communication between a plurality of processes in the UNIX OS has become a particular problem with the opening of the system and the speeding up of processing.
Further, there is a demand for a high-performance interface that can be commonly used in other systems to which UNIX OS is applied.

[0005]

As described above, in the above-mentioned conventional example, the history of transmission / reception messages in communication between a plurality of processes in the UNIX OS cannot be confirmed, and other systems to which the UNIX OS is applied, for example, ,
Since it cannot be used in common with terminals connected to the host device via a local area network (LAN), the UNI
The operation of the X system was difficult.

[0006] The present invention solves the above-mentioned problems in the prior art, and it is possible to confirm the history of transmission / reception messages in communication between a plurality of processes in a UNIX operating system and to use another system to which UNIX is applied. However, an object of the present invention is to provide a method for communication between a plurality of processes, an apparatus thereof, and an information recording medium, which can provide a high-performance interface that can be used in common and can easily and reliably operate the UNIX system.

[0007]

In order to achieve the above-mentioned object, a method for communicating between multiple processes according to the present invention comprises the steps of:
A process of communicating between a plurality of processes by using a library consisting of an O file and a process; a process of leaving a history of transmission / reception data corresponding to a variable length of a message; and a process of communicating between a plurality of processes by using the library having the history. And

The step of leaving the history of the transmission / reception data is a parent-child relationship in which a parent process starts a child process, or a non-parent-child relationship.

The shared memory, the FIFO file,
Semaphore access is provided to the user as a library, and common functions are registered for shared memory initialization processing and message transmission / reception processing.

In the initialization process, a pointer for memory access to each of the processes and an identification code corresponding to the number of processes for using the library are defined. And a buffer length are set, and as the initialization process, a process using a library is initialized at the time of startup in a request process. The initialization process of the request process allows the common function process to acquire a shared memory, obtain a FIFO file, Is automatically performed and the initial setting of the acquisition memory is automatically performed, and further, the semaphore is automatically obtained by the initial setting.

In the message transmission / reception processing, at the time of transmission, at least a transmission message and a destination identification code are set based on the occurrence of a message, and transmission is performed. When a reception event occurs, reception is performed by designating a reception buffer. ing.

As a transmission in the message transmission / reception processing, when a message is transmitted to another process through a library, a write request is made to the FIFO file by the requesting process, and the history of the write data in the common function by the write request processing is automatically recorded. It manages and registers the message in the shared memory and sends it to the notification destination process. In writing by the common function, the date and time are set to mse at the time of FIFO tracing.
At the same time, writing is performed up to c units, a transmission serial number is added in the common function when writing the FIFO file, and when the buffer number is set, the trace of the head of the buffer message is simultaneously performed.

As a reception in the message transmission / reception processing, in a request process for receiving a message addressed to the own process, a read request for a FIFO file is made, and the common function acquires the data of the FIFO file by the read request processing. And manages the history, and further acquires the message based on the buffer index. Further, in the FIFO file reading process, the date and time are set to msec at the time of FIFO tracing.
Simultaneous writing is performed up to the unit, and when the buffer number is set, the trace of the head of the buffer message is simultaneously performed.

The shared memory comprises a header section, an index section corresponding to the total number of buffers, and a message section corresponding to the total number of buffers. The index section is used to store the use history in the buffer, the next message buffer number, the last message buffer number, The configuration is made up of a buffer total message length, a current message length, a registration request process identification number, a discard request process identification number, a memory use state, a message identification number, and a message creation state.

The inter-process communication device of the present invention is a UNIX
Shared memory in operating system, F
Communication between a plurality of processes is performed by a library including an IFO file and a process. The first control processing means leaves a history of transmission / reception data corresponding to a variable length of a message, and a history based on the history left by the first control processing means. Second control processing means for performing inter-process communication in a plurality of processes by a library is provided.

According to the information recording medium of the present invention, when a library in a UNIX operating system communicates among a plurality of processes based on a history of transmission / reception data corresponding to a variable length of a message among the plurality of processes, a parent process starts a child process. Regardless of the parent-child relationship, a history of transmission / reception data is stored corresponding to the variable length of a message, and a control program for executing control for performing inter-process communication in a plurality of processes is stored by a library having the history.

The method and apparatus for communication between a plurality of processes according to the present invention as described above, when performing communication between a plurality of processes,
Regardless of the parent-child relationship in which the parent process starts the child process, a history of transmission / reception data is left corresponding to the variable length of the message, and inter-process communication is performed between a plurality of processes by using the library that has left this history.

Therefore, it is possible to confirm the history of transmission / reception messages in communication between a plurality of processes in the UNIX OS. Further, a high-performance interface can be obtained which can be commonly used in other systems to which UNIX is applied. As a result, the operation of the UNIX system can be performed easily and reliably.

The detailed operation in this case is described in the following (1) to (6). (1) The library can be used as an interface in another system to which UNIX is applied. (2) Messages between processes can be confirmed in real time. (3) Since the index is managed, the maximum length of one message is not limited (variable length / possible up to the acquisition range in the shared memory / changeable by setting). (4) Even when the history of the transmission / reception data is not at the time of failure, it is possible to confirm. (5) Even if there is no knowledge of inter-process communication at the time of application development, it becomes possible to cope with the problem. (6) High-speed processing can be achieved by using a low-level layer function.

The information recording medium of the present invention generally uses a control program of a processing procedure for performing communication between processes in a plurality of processes by keeping a history of transmission / reception data corresponding to the above-mentioned variable length of the message and using a library having the history. Provided as generic package software.

As a result, it is possible to easily implement the present invention on a small general-purpose computer (a procedure for performing the inter-process communication in a plurality of processes by using the library that retains the history of the transmission / reception data described above and retains the history). Become.

[0022]

BRIEF DESCRIPTION OF THE DRAWINGS FIG. 1 is a block diagram showing an embodiment of the present invention; FIG. 1 is a diagram showing a configuration of an embodiment of a method for communication between multiple processes, its apparatus, and an information recording medium according to the present invention. FIG. 1 (a)
1 shows the hardware configuration of the UNIX system (keyboard and coordinate input device are not shown), and FIG.
FIG. 2 is a block diagram showing only the functional configuration of the UNIX system shown in FIG. 1A corresponding to the present invention.

In the example of FIG. 1B, in a UNIX operating system (OS) 1 which is a basic program, a shared memory 2 for simultaneous access in multitasking, etc., and a FIF for first-in first-out of files.
A semaphore 4 that synchronizes between the O-file 3 and a plurality of programs, performs message control and interrupt processing, and performs processing without confusion; a semaphore 4 that performs exclusive control from a plurality of processes 6a to 6c; And a process 6 which is a unit of execution of a program.
a, 6b and 6c.

The library 5 described above is a UNIX
-Shared memory used by the OS (shared memory)
2, FIFO (named) file 3 and process 6a
~ 6c.

Next, the operation of this embodiment will be described. In the embodiment of the present invention, regardless of the parent-child relationship (fork / exec) in which the parent process starts the child process (the parent process starts the child process because the file descriptor is acquired based on the common initialization process) Even between processes having no parent-child relationship, communication between the processes can be performed), a history of transmission / reception data is left corresponding to the variable length of the message, and the library 5 that has left the history of the transmission / reception data performs a plurality of processes 6a to 6c. Communication between processes (IP
C).

Therefore, as shown in FIG. 1B, access to the shared memory 2, FIFO file 3, semaphore 4, etc. is provided to the user in a form surrounded by the library 5. Actually, another function (a common function described later) is registered so that knowledge is not individually required for the initialization processing (1) and the message transmission / reception processing (2) described below.

(1) Initialization process When the library 5 is used, a pointer for memory access is required in each process (in the program) 6a to 6c, and the number of processes (6a to 6c) depends on the number of processes (6a to 6c). The definition of the identification code (ID) is given by, for example, a serial number. For this reason, the number of buffers and the buffer length are set in consideration of the message load of the system as an initial setting.

(2) Message transmission / reception processing Transmission is performed by setting a transmission message, a destination identification code (ID), and the like in accordance with the occurrence of the message. The reception is performed by specifying a reception buffer when this reception event occurs.

Next, the (1) initialization processing and (2) message transmission / reception processing will be described in detail. FIG. 2 is a diagram for explaining the structure of the shared memory 2. In FIG.
The structure of the shared memory 2 includes a header part, an index part for the total number of buffers, and a message part for the total number of buffers.

The header part is A / shared memory current history, B
/ Buffer total number, C / 1 message buffer length, D / free buffer number, E / semaphore ID, and F / FIFO
It consists of file descriptors (for the number of FIFO files). Also, the index part includes G / buffer usage history, H /
Next message buffer number, I / Last message buffer number, J / Buffer total message length, K / Current message length, L / Registration request process ID, M / Discard request process ID, N / Memory usage status, O / Message I
D, P / message creation status, Q / spare.

FIG. 3 is a diagram for explaining the initialization processing of the shared memory 2 shown in FIG. In FIG. 3, the processes 6a to 6c that use the library 5 perform initialization processing at the time of startup in the request process (1) (1).
a). By the initialization process (1a) of the request process (1), the common function process (2) acquires the shared memory 2,
The creation of the FIFO file 3 and the initial setting (2a) of the acquisition memory are automatically performed. Further, by acquiring the shared memory 2, creating the FIFO file 3, and initializing the acquired memory (2a) in the common function processing (2),
The semaphore 4 is acquired automatically. That is,
The inter-process communication area (semaphore key acquisition / common to each area), the FIFO trace area, the failure handling area, and the timer management area of the shared memory 2 are acquired.

The common function process (2) notifies a return code to the request process (1) in response to the initialization process of the common memory 2 (2b).

FIG. 4 is a diagram for explaining the writing process of the FIFO file 3 shown in FIG. In FIG. 4, when a message is transmitted to other processes 6a to 6c through the library 5 (message transmission / reception process), a write request process (1-1) to the FIFO file 3 is performed in the request process (1). The history of the write data (2-1) in the common function (2) is automatically managed by the write request processing (1-1), and a message is registered in the shared memory 2 and transmitted to the notification destination process. That is, in the FIFO file 3 (3), writing (2-2) to this is performed.

In the writing process of the FIFO file 3 in this case, the following process is performed. (1) At the time of FIFO tracing, the date and time are simultaneously written up to the unit of msec. (2) At the time of writing the FIFO file 3, a transmission serial number is added in the common function (2). (3) When the buffer number is set, the trace of the head of the buffer message is also performed at the same time. The common function processing (2) is performed in the FIFO file 3
A return code is notified to the request process (1) for the writing process (2-3).

FIG. 5 is a diagram for explaining the reading process of the FIFO file 3 shown in FIG. In FIG. 5, when a message addressed to the own process (6a to 6c) is received (message transmission / reception processing), the request process (1) is received.
, A read request process (1A) for the FIFO file 3 is performed. Request processing of this reading (1A)
Thus, the common function (2) becomes the FIFO file (3)
, The data of the FIFO file 3 is acquired, data history management is performed, and a message is acquired based on the buffer index (2A). The message can be left in the shared memory 2 as it is (2B).

In the reading process of the FIFO file 3 in this case, the following process is also performed. (1) At the time of FIFO tracing, the date and time are simultaneously written up to the unit of msec. (2) If the buffer number is set, the trace at the head of the buffer message is also performed at the same time. In the common function process (2), read data / return code is notified to the request process (1) in response to the read process of the FIFO file 3 (2C).

FIG. 6 is a block diagram for explaining an application example of the UNIX operating system shown in FIG.
The example of FIG. 6 illustrates a host device 10 and a plurality of terminals 11 (FIG. 1).
(UNIX / OS having the configuration and operation shown in FIG. 1) are connected by a local area network (LAN) 12 or the like.

The terminal 11 corresponds to the configuration shown in FIG. 1, and includes a shared memory 11a as first and second control processing means,
It has a FIFO file 11b, a control process 11c, and a communication process 11d. Note that, here, components other than the firmware are not shown.

In this example, the terminal 11 is connected to the UNI shown in FIG.
It operates basically the same as X.OS. That is, the communication process 11d receives data from the host device 10 via the LAN 12. Next, registration is performed from the communication process 11d to the common memory 11a, and the registered buffer number is obtained. Further, the communication process 11d is the control process 1
1c is notified (notification of the registered buffer number). Then, the control process 11c acquires data from the FIFO file 11b. Next, the control process 11c
The message is acquired from the common memory 11a based on the registered buffer number acquired from the FO file 11b.

In FIGS. 1 and 6, it is also possible to display the communication history in real time on a display device (not shown). For example, a screen can be displayed on a standard X window of a workstation operating on UNIX.

The processing procedure of the operation of the present invention in the configuration of FIGS. 1 and 6, that is, its application can be provided by general-purpose package software such as a floppy disk (FD), CD-ROM or MO. .

Thus, regardless of the parent-child relationship,
A history of transmitted / received data is left corresponding to the message variable length, and inter-process communication (IP
Perform C). In this case, the following (1) (2) (3) (4)
The processing of (5) is performed.

(1) Message management unit in initial setting
The number can be changed (index). One feature of the embodiment of the present invention is that the shared memory 2 has an index. In this case, FIFO file 3
In addition, the above-described processing can be performed by using a socket and a message queue (message data string).

(2) The functions related to the creation (the common functions described above) do not depend on the individual OS (UNIX). That is, the library 5 includes a shared memory (shared memory) 2, a FIFO (named) file 3, and a semaphore 4 for performing exclusive control from the processes 6a to 6c used in the UNIX OS. However, the library 5 can be handled without knowledge of the shared memory 2, the FIFO file 3, the semaphore 4, and the like.

(3) The shared memory 2 has an index file and manages registration and discard of messages (see FIG. 2). Note that a trace area is separately secured. (4) Since messages are managed in the shared memory 2, one message can be created by registering a plurality of times.

(5) In the conventional UNIX OS, when transmission / reception is performed, the history of transmission / reception data does not remain. However, in the embodiment of the present invention, since the past history is stored, a system failure occurs. When the process terminates abnormally, it is possible to check what messages were sent and received between the processes at the time of termination.

(6) The communication history is also automatically set to the time m
It is managed up to the second. (7) The transmission / reception message is displayed on the screen in real time. (8) As shown in FIG. 3, since the file descriptor is obtained based on the common initialization process, even when there is no parent-child relationship in which the parent process starts the child process,
The inter-process communication can be performed.

(9) In a system in which the load of communication between processes is high (a message is large), the maximum allowable capacity of a file descriptor (for example, 5120 bytes or 81
If it exceeds 92 bytes, an error occurs. However, in the embodiment of the present invention, since the message is managed by giving an index to the shared memory 2, the allowable range of directly transmitting and receiving by the FIFO file 3 or the like is used. The above messages can be registered. That is, the message is saved on the shared memory 2.

(10) As shown in FIG. 6, it is possible to obtain a high-performance interface that can be commonly used by another system to which UNIX is applied, that is, a terminal connected to a host device via a local area network (LAN).

[0050]

As is apparent from the above description, according to the method and the apparatus for communication between a plurality of processes of the present invention, when a communication is made between a plurality of processes, the parent process starts a child process. Regardless, the history of transmission / reception data is left corresponding to the variable length of the message, and inter-process communication between a plurality of processes is performed by the library that has left this history.

As a result, it is possible to confirm the history of transmission / reception messages in communication between a plurality of processes in the UNIX OS, and to obtain a high-performance interface that can be commonly used in other systems to which UNIX is applied. The operation of the UNIX system can be performed easily and reliably.

According to the information recording medium of the present invention, a history of transmission / reception data corresponding to the above-mentioned message variable length is left, and a process library for carrying out inter-process communication in a plurality of processes by using the library having the history is stored. The control program can be provided as general-purpose package software.

As a result, it is possible to easily implement the present invention on a small general-purpose computer (processing procedure for performing inter-process communication in a plurality of processes by using the library that retains the history of the transmission and reception data described above and retains the history). Become.

[Brief description of the drawings]

FIG. 1 is a diagram showing a configuration of an embodiment of a method and apparatus for communicating between multiple processes and an information recording medium according to the present invention.

FIG. 2 is a diagram illustrating a structure of a shared memory according to the embodiment;

FIG. 3 is a diagram illustrating an initialization process of a shared memory according to the embodiment;

FIG. 4 is a diagram for explaining a FIFO file writing process according to the embodiment;

FIG. 5 is a diagram illustrating a reading process of a FIFO file according to the embodiment.

FIG. 6 is a block diagram for explaining an example of receiving data from a host device and notifying other processes according to the embodiment;

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 UNIX / OS 2 Shared memory 3 FIFO file 4 Semaphore 5 Library 6a-6c process 10 Host device 11 Terminal 11a Shared memory 11b FIFO file 11c Control process 11d Communication process 12 LAN

Claims (14)

[Claims] 1. A method for performing communication between a plurality of processes using a shared memory, a FIFO file, and a library comprising a process in a UNIX operating system, wherein a history of transmission / reception data corresponding to a variable length of a message is left; Performing a communication between a plurality of processes by using a library having the following. 2. The method according to claim 1, wherein the step of leaving the history of the transmission / reception data is a parent-child relationship in which a parent process starts a child process or a non-parent-child relationship. . 3. The shared memory, FIFO file, and semaphore access is provided to a user as a library, and a common function is registered for initialization processing of the shared memory and message transmission / reception processing. 2. The method for communication between multiple processes according to 1. 4. The initialization process defines a memory access pointer for each of the processes and an identification code according to the number of processes for using the library, and takes into account the message load of the system. 4. The method according to claim 3, wherein the number of buffers and the buffer length are set. 5. The initialization process is performed when a process using a library is initialized in a request process at the time of startup. The initialization process of the request process allows the common function process to acquire a shared memory, create a FIFO file, and execute 5. The communication method between multiple processes according to claim 4, wherein the initialization is automatically performed, and the semaphore is automatically acquired according to the initialization. 6. The message transmission / reception processing includes: at the time of transmission, setting at least a transmission message and a destination identification code based on the occurrence of a message and performing transmission; and at the time of a reception event, specifying a reception buffer and performing reception. 4. The method for communication between a plurality of processes according to claim 3, wherein: 7. As a transmission in the message transmission / reception processing, when a message is transmitted to another process through a library, a write request to a FIFO file is made by a requesting process, and the history of write data in a common function by the write request processing is automatically set. 7. The communication method between a plurality of processes according to claim 6, wherein the communication is managed in a shared memory, and the message is registered in a shared memory and transmitted to a notification destination process. 8. In the writing by the common function, date and time are simultaneously written up to the msec unit at the time of FIFO tracing, a transmission serial number is added in the common function at the time of writing the FIFO file, and the buffer is set when the buffer number is set. The method according to claim 7, wherein tracing of the head of the message is performed simultaneously. 9. A request for reading a FIFO file in a request process for receiving a message addressed to the own process as reception in the message transmission / reception process, and the common function is executed by the FIFO request process by the read request process.
7. The communication method between multiple processes according to claim 6, further comprising: acquiring file data, managing a history, and acquiring a message based on a buffer index. 10. The reading process of the FIFO file, wherein at the time of FIFO tracing, a date and time are simultaneously written up to a unit of msec, and when a buffer number is set, tracing of a head portion of a buffer message is performed at the same time. The communication method between a plurality of processes according to claim 9. 11. The method according to claim 1, wherein the shared memory comprises a header section, an index section for the total number of buffers, and a message section for the total number of buffers. 12. The index section includes: a buffer use history, a next message buffer number, a last message buffer number, a buffer total message length, a current message length, a registration request process identification number, a discard request process identification number, and a memory use state. 12. The method according to claim 11, comprising a message identification number and a message creation state. 13. An inter-process communication apparatus for performing communication between a plurality of processes by using a shared memory, a FIFO file, and a library of processes in a UNIX operating system, wherein a first history of transmission / reception data corresponding to a variable length of a message is recorded. An inter-process communication apparatus comprising: a control processing unit; and a second control processing unit that performs inter-process communication in a plurality of processes by using a library based on a history left by the first control processing unit. 14. When a library in the UNIX operating system performs communication between a plurality of processes based on a history of transmission / reception data corresponding to a variable message length between the plurality of processes, regardless of a parent-child relationship in which a parent process starts a child process. An information recording medium characterized by storing a history of transmission / reception data corresponding to a variable length of a message, and storing a control program for executing control for performing inter-process communication in a plurality of processes by a library having the history.