KR0154573B1 - Inter-process communication method in chill simultation environment - Google Patents

Abstract

The present invention relates to an interprocess communication method in a CHILL simulation environment, and provides an interprocess communication method in a general computing environment in order to provide an intermodule or intraprocess communication method for simulating a switch software in a host. A method, comprising: a first step of allocating a common shared memory and semaphore and then executing a module by allocating a local shared memory and semaphore for the executing module upon receiving an execution instruction for the module; The executing module executes an execution statement after attaching the allocated shared memories to use its own address space; The chill simulation kernel comprises: a third step of supporting functions on events, buffers, and signals for communication between processes; And a fourth step of recovering the allocated shared memory and the resource after the execution of the execution module is completed, thereby reducing the development time of the communication software.

Description

Interprocess Communication Method in CHILL Simulation Environment

1 is an exemplary configuration diagram of hardware to which the present invention is applied.

2 is a conceptual diagram of interprocess communication according to the present invention;

3 is a flow diagram of an embodiment of an interprocess communication method in a CHILL simulation environment in accordance with the present invention.

* Explanation of symbols for main parts of the drawings

101: main memory board 102: central processing board

103: UNIX operating system 104: auxiliary storage

105: input / output device 106: system bus

The present invention relates to an inter-process communication method in a chill (CCITT High Level Language) simulation environment.

If you define an independently executable CHILL program as a module, several processes can be created and executed simultaneously when one module is executed. In CHILL, the basic unit for parallel processing is a process. The synchronization and communication functions between processes are events, buffers, and signals.

Among these functions, events and buffers are used only for synchronization and communication between processes in an execution module, and inter-module communication is only possible via signals. In order to simulate the exchange software on the host, it is necessary to be able to support inter-process synchronization and communication functions. In order to support these functions, the Chill shell and Chill simulation kernel have been developed.

Communication between processes in one module or between modules is via shared memory under the UNIX environment. Communication between modules is through a common shared memory shared by several modules, and synchronization and communication between processes within a module is through a local shared memory allocated to that module.

The CHILL shell executes commands given by the user as a command processor, and the user can run modules only on the CHILL shell. The CHILL shell allocates semaphores and waits for user commands to provide common shared memory and shared memory mutual exclusion for use in intermodule communication.

The Chill shell accepts and executes commands given by the user and displays the information to the user if necessary. Commands handled by the Chill shell include commands to execute, commands to send signals, and commands to show the user the status of current processes. Among these commands, the send signal command allows the user to send signals and messages directly to the process, and the command to inform the status of the process is to inform the user of the status of the currently running processes. When the user sends a signal, the user inputs the signal and the message in text form. However, the running process can only recognize the binary data. Therefore, the text data cannot be understood. In addition, when a command that informs the user of the status of a process that is currently running, a user may not understand the process related information in binary data.

As such, in order to transfer information between a currently running process and a user, the information must be converted into a form that can be understood by each other. In order to solve this problem, the present invention provides a function of converting text information received from the user into binary data and a function of converting process related binary data into text data.

To implement this data conversion function, the Chill shell performs the following steps. First, it reads information about signals and processes used in the chill program, parses the information, and builds a symbol table. Next, we analyze the symbol table to complement the contents of the symbol table. The next command that accepts a user command and sends a signal converts the received signal and message information into text into binary data that the process can understand by referring to the information in the symbol table. This command shows the status of processes to the user after converting binary data about the status of processes currently in the shell to text data by referring to the symbol table.

In order to support the functions for interprocess synchronization and communication, shared memory should be shared between processes. The chill shell allocates a common shared memory space that can be shared by different executable modules, and then allocates local shared memory for the modules that are executed each time the module execute command is executed. The chill simulation kernel, included as a library in the executable module, attaches the shared and local shared memory allocated by the chill shell to make these shared memories available. The common shared memory and the local shared memory area allocated by the chill shell may be sized as needed, and the present invention allocates the size to about 1 megabyte. In the UNIX system to which the present invention is applied, the number of allocating the shared memory and the size of the shared memory that can be allocated at one time are limited. Therefore, efficient management of the shared memory is essential to support inter-process communication through the shared memory. If the shared memory space is insufficient, there is a problem that cannot execute parallel programs that frequently cause communication between processes.

In order to solve this problem, the chilled simulation kernel of the present invention allocates the allocated shared memory area as needed whenever necessary and uses it for inter-process communication. Manage for use.

Like this, shared memory management is done in Chill simulation kernel. In the process of interprocess synchronization and communication, communication using the signal is performed through the common shared memory. When the signal is transmitted, the memory required for the signal and the message to be transmitted is allocated in the common shared memory area. The transmitted signal is stored in the process control block of the receiving process until another process receives the signal information. When the signal-receiving process receives a signal, the chill simulation kernel manages to reclaim all the memory space allocated for the signal and its messages in the shared memory area for reuse. Among the interprocess communication functions, events and buffers are made through the local shared memory. In case of event delay or buffer transmission, the chill simulation kernel allocates as much memory as necessary in the local shared memory area and continues the event or buffer receiving operation. After that, the memory allocated to them is collected and reused in the local shared memory area.

Functions for synchronization and communication between seven processes include signals, buffers, and events. Dual signals support synchronization and communication between different modules, and buffers and events support synchronization and communication between processors in one execution module. do. When a process is created and executed, each process is executed in a separate memory area. Therefore, in order to communicate and transfer messages between processes, a shared memory area that can be accessed in parallel by the processes running in parallel is designated. Message transmission and communication through. However, there is a problem in that an error occurs due to concurrent access to the same memory location or inadvertent modification of data due to simultaneous execution of a process sharing a shared memory area.

Therefore, semaphores are used as a method of controlling simultaneous access to this shared area. Semaphores have two states: locked and open. When they are open, shared memory is available, and locked states are not available because other processes are using shared memory. A semaphore has semaphores for the common shared memory area and one semaphore for each local shared memory area.

Operations that can communicate between processes using signals include sending signals and receiving signals. In case of signal transmission, first check the state of semaphore and wait until it is open if it is locked. If it is open, semaphore is locked and necessary memory is allocated from the common shared memory area to receive signals and messages. And the semaphore is left open.

At this time, the method of delivering the signal is as follows. If the process to receive the signal is waiting for the signal to be sent, it wakes up the receiving process after sending the signal. Otherwise, it stores the signal and message in the process control block of the receiving process. When receiving a signal, wait for the semaphore to be open if it is locked, if it is open then lock the semaphore and check if there are already received signals in the process control block of the shared memory area, if any. And receive the message, otherwise leave the semaphore open and wait for another process to signal. When the signal is received, the memory allocated for the signal is retrieved into the shared memory area and the semaphore is left open.

Since interprocess communication through events and buffers is interprocess communication within a single execution module, communication is done through local shared memory. Like communication using signals, this local shared memory can be used by multiple processes at the same time, causing errors due to unintended concurrent access.

Thus, to avoid errors, an exclusive approach is managed with semaphores. An event provides the synchronization capability of a process. Possible operations on an event include the DELAY and CONTINUE operations, and a process that performs an event-delay operation can continue to operate on that event. Until it falls into a delay state. The event continue operation provides the ability to continue the execution of a given event if there is a process that is delayed. Event locations reside in local shared memory and can be shared by all processes in the same module. To perform a delay or continue operation on an event, first check the semaphore state, wait for it to be open if it is locked, then lock the semaphore if it is open, and then perform the given operation on the event location in local shared memory. And leave the semaphore open.

The buffer location provides functionality for interprocess synchronization and message delivery, and the buffer location resides in local shared memory. Operations on buffer locations include buffer send and buffer receive, and processes that want to send or receive messages to the buffer location must wait until the semaphore is locked and open, and if it is open, semaphores are locked. After the message has been sent to or received from the buffer, the semaphore is left open. When sending a message to a buffer location, the memory required for message delivery is allocated from the local shared memory and the message is sent to the buffer. When receiving a message from the buffer, the allocated memory is recovered to the local shared memory.

Accordingly, an object of the present invention is to provide a method for inter-module or inter-process communication within a module to simulate the exchange software in a host.

In order to achieve the above object, the present invention, in the inter-process communication method applied to the computing environment, after allocating the common shared memory and semaphore and receiving the execution instruction for the module, by assigning a local shared memory and semaphore for the execution module A first step of performing a module; The executing module executes an execution statement after attaching the allocated shared memories to use its own address space; The CHILL simulation kernel comprises: a third step of supporting functions relating to events, buffers, and signals for communication between processes; And recovering the allocated shared memory and resources after the execution of the execution module is completed.

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

FIG. 1 is a diagram illustrating a configuration of hardware to which the present invention is applied. Referring to the functions of the blocks illustrated in the drawing, the main memory board 101 is a board on which a chill shell, an execution module, and the like are mounted. The board 102 is a board that executes a file mounted in the main memory. The auxiliary memory device 104 stores files, data, and the like, and stores files and tools that are not mounted on the main memory board 101. The input / output device 105 is an input / output device for inputting / outputting files and data necessary for performing a simulation and all error messages generated during the execution. The UNIX operating system 103 controls each board and device described above, and is transmitted through a message system bus 106 that exchanges information between boards and devices.

2 is a conceptual diagram of interprocess communication according to the present invention.

When the execution of the CHILL shell is started, it allocates a common shared memory and semaphore to be used for inter-module communication and waits for a command from the user (201). When the user executes a module execution command, the CHILL shell allocates local memory and semaphores necessary for interprocess communication within the module and executes the module (202). Chill Simulation Kernel (CSK) is included in the module to be executed, and Chill Simulation Kernel (CSK) handles signals, buffers, and events, which are functions for interprocess communication.

In the case of interprocess communication using a signal, communication and information transfer are performed through a common shared memory (204), and interprocess communication using an event or a buffer is performed through local shared memory dedicated to each module. Exchange is made (203). 3 is a flow diagram of an embodiment of an interprocess communication method in a CHILL simulation environment in accordance with the present invention.

The CHILL shell allocates common shared memory and semaphores and waits for instructions from the user (301). If the command given by the user is an exit command, the execution of the CHILL shell is terminated (302,303). If the command is not an exit command, the command is examined to determine whether the command is a module execution command. Wait for the command (304, 305, 301). In this case, if the command is a signal transmission command, the text data is converted into binary data and then transmitted to the process. If the command shows the status of the process to the user, the binary information related to the process is converted to text and then displayed to the user.

If the instruction given by the user is a module execution instruction (304), fork the new process (306) to determine whether it is a parent process (307), and if it is a parent process, wait for instructions from the user again (301). If not, the child process allocates local shared memory and semaphores for the given module and executes the module (308).

In the module where execution is started, the shared memory allocated by the CHILL shell is attached to be used as its address space, and the execution statement defined in the module is executed (309). The CHILL simulation kernel, included as a library in the execution module, provides support for events, buffers, and signals for communication between processes. In the case of interprocess communication using a signal, a required memory is allocated from a common shared memory area to store necessary information, and after communicating with a desired process, the allocated memory is recovered to the common shared memory area. In case of communication using an event and a buffer, necessary memory is allocated from the local shared memory area to store necessary information, and after communication with a desired process, the allocated memory is recovered to the local shared memory area (310). When execution of the execution statement in the module is completed, the resources allocated to the module are recovered and the execution of the module is terminated (311, 312).

As described above, the present invention supports a function for interprocessor communication in a CHILL simulation environment, thereby enabling the host to simulate an operation of communication software in which information is exchanged mainly by interprocessor communication. In particular, since communication between different modules is possible through shared memory, the operation of modules operating with mutual correlation at the same time can be analyzed and tested at the host, and most errors can be corrected at the host and mounted on the target system for communication software. There is an effect that can reduce the development time of the.

Claims (3)

An interprocess communication method applied to a computing environment, comprising: a first step of allocating a common shared memory and a semaphore and then executing a module by allocating a local shared memory and a semaphore for the executed module if the execution instruction for the module is easily received; The executing module executes an execution statement after attaching the allocated shared memories to use its own address space; The chill simulation kernel comprises: a third step of supporting functions for events, buffers, and signals and shared memory allocation / retrieval functions for communication between processes; And a fourth step of reclaiming the allocated shared memory and the resource after the execution of the execution module is completed. The method of claim 1, wherein the first step comprises: a fifth step in which a CHILL shell allocates the common shared memory and semaphore and waits for instructions from a user; If the user command is a termination command, terminating the execution of the CHILL shell, and determining whether the user command is a module execution command if the user command is not a termination command; As a result of the judgment in the sixth step, if the command is not a module execution command but a signal transmission command, the text data is converted into binary data and then transmitted to the process. If the command shows the status of the process to the user, the process related binary information is converted into text. A seventh step of repeating the user command waiting process of the fifth step after showing to the user; And as a result of the determination of the sixth step, if the execution command forks a new process and repeats the process of waiting for the user command of the fifth step if the parent process, and if the child process other than the parent process, the local to the given module. An interprocess communication method in a CHILL simulation environment comprising an eighth step of allocating shared memory and semaphores to execute a module. The method of claim 1 or 2, wherein the third step includes, when performing inter-process communication during module execution, in case of inter-process communication using the signal, necessary information is allocated from the common shared memory area to obtain necessary information. After storing and communicating with the desired process, the allocated memory is retrieved into the common shared memory area, and in case of inter-process communication using the event and the buffer, after storing necessary information from the local shared memory area and communicating with the desired process. And recovering the allocated memory into the local shared memory area.