JPH09101899A - Procedure procedure method - Google Patents

Abstract

(57) Abstract: In a multi-process computer system, when a certain function is provided to a program, a process section that performs actual processing, and a library section that starts this process, sends parameters, and receives return information. To separate and process. SOLUTION: In a multi-process computer system, when a certain function is provided to an arbitrary program, the computer system is provided with a process section 2 for performing actual processing, starting this process, and transmitting parameters to this process. , A library unit 1 for receiving return information from this process and a program using the function is called by using the same library call interface as the interface for calling this function. Perform a function.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a procedure processing method, and in particular, in providing a certain function to a program in a multi-process computer system,
The present invention relates to a program processing system which is separated into a process section which performs actual processing and a library section which starts up this process, transmits parameters, and receives return information.

[0002]

2. Description of the Related Art In a multi-process computer system, when a certain function is provided to an arbitrary program, it is usually provided in the form of a subroutine. In this case, the form of the subroutine takes the form of an object file containing only a single subroutine or a library file in which objects of a plurality of subroutines are archived.

The interface on the source for using these subroutines is a subroutine call, and in order to make the calling source program executable, it is necessary to link the calling source program with the above-mentioned object file. .

FIG. 11 exemplifies the conventional provision of a subroutine in the same host. When a subroutine call of func (a, b, c) is made in the calling source program source, func (in the subroutine source is It has been shown that a, b, c) are linked into an executable form at the stage of compiling and linking.

Further, in the case of providing an arbitrary program to another host via a network, a technique such as a remote shell has been conventionally known. Alternatively, it may be realized by using a communication protocol of an original procedure.

[0006] FIG. 12 shows an example of conventional function provision to another host. Using the remote shell, the host 1 sends a command name and parameters to the host 2 via a communication line such as LAN / WAN / INS, and the server program in the host 2 processes this and processes it. The subroutine YYY is provided by returning the result to the host 1.

[0007]

In the conventional method of providing a subroutine, when the operating system (OS) does not have the dynamic link function in the same host, each calling source program is processed by the process unit. Since it contains a subroutine,
As the memory capacity required for execution increases,
When changing the contents of the subroutine, there was a problem that all processes had to be relinked. These become particularly noticeable when the subroutine is large and the number of concurrently used processes increases.

In the case of providing a subroutine of another host, when a standard interface such as a remote shell is used, the information that can be input / output is limited. For example, passing a memory block as an input or obtaining a memory block as a return value is impossible with a remote shell. In addition, when using a unique interface, it is necessary to design each interface individually, and there is a problem that development efficiency is poor.

The present invention is intended to solve such a problem of the prior art, and in a multi-process computer system, when a certain function is provided to an arbitrary program, the function desired to be provided to the arbitrary program is The purpose is to solve such a problem by separating the process that performs actual processing from the library that performs process startup, parameter transmission, and return information reception.

[0010]

In the present invention, the function to be provided to an arbitrary program is divided into a process for performing actual processing and a library for starting this process, transmitting parameters, and receiving return information.

FIG. 1 shows the operating principle of the present invention, where 1 is a library section and 2 is a process section. FIG. 1 shows a flow of respective operations in the case where the process A processes the library part and the process B processes the process part.

In the system of the present invention, when the subroutine of the conventional system is func (a, b, c), the processing division between the library section and the process section is as follows.

(A) Processing of library section (process A) The process section is started. The parameter information is transmitted to the process section via interprocess communication. The processing result from the process unit is received via interprocess communication. Converts the received information and returns to the caller.

(B) Process of process section (process B) Input information is received from the library section. execute func (a, b, c). The execution result is converted and sent to the library section.

The calling interface of the library func '() is the same as the calling interface of the subroutine func ().

When the above-mentioned structure is adopted, the variable processing part is a part for performing input / output information transmission / reception processing and actual processing. These variable parts are func (a, b, c)
, Which is a part depending on the interface, can supply the interface information to automatically generate the program source code of the variable part.

According to the present invention, since the actual processing part is separated as a separate process, each calling process does not need to include the actual processing part of the same subroutine. In this case, the calling program sees the same as a conventional subroutine call.

That is, since it becomes possible to automatically generate a variable processing part, the designer only has to perform the same subroutine design work as in the conventional case, and the design and creation of interprocess communication etc. are not required. There is an advantage that man-hours due to adopting the structure of (2) hardly occur.

Specific means for solving the problems of the present invention will be given below.

(1) In a multi-process computer system, when a certain function is provided to an arbitrary program, the computer system performs a process section 2 for performing actual processing, starting this process, and sending parameters to this process. And a library unit 1 that receives return information from this process, and a program that uses the function calls this library by using the same library call interface as the interface that calls this function. Perform the function.

(2) In the case of (1), the library unit 1 and the process unit 2 are automatically generated from the subroutine source by giving the interface information of the function concerned, so that an arbitrary subroutine can be generated as a library routine and an actual processing process. It is provided by a program structure consisting of and.

(3) In the case of (1), the process section is placed in another host connected to the library section host via a network to perform actual processing.

(4) A library routine and a process section in the case of (3) are automatically generated from a subroutine source by giving interface information of the function concerned, so that an arbitrary subroutine can be run on one host. And a program structure consisting of an actual processing process running on the other host.

[0024]

BEST MODE FOR CARRYING OUT THE INVENTION Embodiment (1) of the present invention will be described below. For convenience of description, the source code of the process is described in C language.

First, a format for transmitting / receiving the input / output information to / from the subroutine by interprocess communication is defined. FIG. 2 shows conversion of subroutine input / output information in the embodiment (1) of the present invention.

The inputs to the subroutine include passing a value and passing a memory address. In the function func () shown in FIG. 2, p1 indicates passing by value, * P2 and * P3 indicate passing by address, A and B are addresses corresponding to * P2 and * P3, and are of addresses A and B. This is the data size. When the parameter is passed by value, 0 indicating it and the parameter value are input. On the other hand, when the parameter is an address, the data size and its offset are input.

The output from the subroutine is that the processing result is returned as a value like a function value in C language, and that the result is written and restored on the memory address specified at the time of calling the subroutine. There is. FIG.
In, the function value indicates information on the processing result in the subroutine.

These parameters are formed into a memory block in the format shown in FIG. 2 and used as transmission / reception data with the process.

Next, as an embodiment in the case of providing a subroutine in the same host, a program configuration when a socket pair is used for interprocess communication will be described. FIG. 3 shows the program structure when a socket pair is used.

The calling process is a library fun.
Call c '(). func '() has the same call interface as the subroutine func (). After that, the library unit and the process unit each perform the following processing.

(A) Processing of library unit (calling source process) Input information from the calling source program is converted into the above-mentioned format. Start the process part. Create a socket pair, and write the input information from the calling program converted in to the socket pair. The processing result in the process unit is read from the socket pair. It reverses the received information and returns to the caller.

(B) Input information from the processing library section of the process section is read from the socket pair. The received data is converted back to that in (a). execute func (a, b, c). The execution result is converted into the above format and transmitted to the library section.

Next, a method for automatically generating a program having the above-mentioned configuration from the func () source file and the parameter information of func () will be described. The parts that need to be automatically generated, that is, the parts that can be changed by the func () interface are (a)-, (a)-,
(a)-and (b)-, (b)-, (b)-.

First, in order to obtain each parameter information of func (), an HMI for the designer to input the information.
(Human Machine Interface) is provided in the automatic generation tool.

As is clear from the data format, the data required for the mutual conversion between the parameter and the transmission / reception data is the data format of each parameter of func (), and the type of value passing and address passing. . The information necessary for starting the process is the process name, and the information required for calling the subroutine is the subroutine name.

The input value, the number of parameters derived from the input value, and the total number of bytes of the address passing data are recorded in a memory or a file.

FIG. 4 shows an example of parameter information input by the HMI and shows the correspondence between the HMI and the stored contents. In the figure, when 0 is input to each parameter information, passing by value is shown, and when other than 0, passing by address is performed, and the input numerical value is interpreted as the data size.

The automatic program generation tool automatically generates the source code based on the stored information.

(A) Library part The following source code is added to the work file in order. In the following, the description of the fixed processing unit will be omitted.

(A)-FIG. 5 shows an example of a source code generation program, and shows an example of a UNIX sh program and a generation result corresponding thereto. FIG. 6 shows the source code generation result.

A source code (FIG. 5A) for acquiring a memory area required for the transmission / reception format (hereinafter referred to as a transmission memory) based on the total number of bytes of the address passing data of the storage information and the number of parameters. -Source code that sets the number of parameters in the transmission memory (Fig. 5 (a)). -Source code that copies all parameters in a specified format to the transmission memory (Fig. 5 (c)).

In the examples of FIGS. 5 and 6, the information shown in FIG. 4 is used as the parameter information, and the file name in which this information is stored is already stored in the shell variable PARAFILE. In this information, the total number of bytes passed by address is already stored in the shell variable PDATALEN. Also, varargs of C standard library that handles a variable number of parameters is used.

(A) -A source code for starting a process with this name based on the process name in the stored information. (a)-・ Source code that copies the received information to all parameters again.

(B) Process part FIG. 7 shows a template for automatically generating a process part in the embodiment (1) of the present invention, which is used for automatically generating a process part source code. , It consists of a source file with keywords embedded in the variable part.

The keyword is the number of parameters.
SU PARAMETERCOUNT (Fig. 7 (a)), ad
PARAMET indicating the total number of bytes of the non-pass parameter
ERDREN (Fig. 7 (a)) and function call processing
FUNCTION indicating CALL (Fig. 7 (c))
You.

The automatic generation tool reads out the number of parameters and the name of the subroutine in the recorded information, corrects these keyword parts, and creates the source file of the process part.

FIG. 8 explains the correction of the keyword portion in the template. PARAMETER
In the case of COUNT, replace with the number of parameters (simple replacement). For example, when the number of parameters is 3, it becomes as shown in FIG. In the case of PARAMETERDLEN,
Replace with the total number of bytes of the address passing parameter (simple replacement of character string). For example, when the number of parameters is 384, it becomes as shown in FIG. FUNCTION C
In the case of ALL, by replacing the result of creating the character string of the subroutine calling portion in the manner shown in FIG. 8 (d), the result becomes as shown in FIG. 8 (c).

FIG. 9 shows the file association according to the embodiment (1), in which the source file generated as a result of the processing of the library section shown in (A) above is a func.
1, c, and the source file generated as a result of the processing of the process part shown in (B) is func. p and c, and the source file of the original subroutine is func. In the case of c, the file relations until the file of the format required for execution is created are shown.

In FIG. 9, the inside of the dotted line frame is func ().
No change is required unless the interface of is changed.
A program that uses the func () function is fu
nc Link 1, o. func Function name in 1, o
Is the same as the actual function name, but the processing is different.

FIG. 10 is a diagram for explaining the operation of the embodiment (2) of the present invention, and shows a case where a process unit is operated on another host by using a socket.

The embodiment shown in FIG. 10 differs from the embodiment (1) in the parameter transmission / reception processing portion and the process portion activation processing portion. In addition, a new means for specifying in which host the process is to be started is required.

As a method of specifying the host, a method using a definition file, a method of setting an environment variable in the calling process, and the like are conceivable. Here, a method of using the definition file will be described.

In order to start the process of another host, a server program for accepting the process start (hereinafter, simply referred to as a server) is provided in the host to be started. The server monitors the socket connection from the library section.

The library section reads the connection destination host name from the above definition file and performs socket connection processing. After the connection is established, the library part sends the name of the process to start to the socket.

When the server receives this information, the server starts a process in its own host and switches the socket port being connected to the process.

The parameter transmission / reception process is performed in the embodiment (1).
Send / read read / write to socket pair
All you have to do is replace it with reception.

[0057]

As described above, according to the present invention, the following effects can be obtained. (1) In the case of processing within the same host According to the method of the present invention, it is possible to reduce the memory capacity required for executing the processing. This is because the library to be linked is only a small fixed program.
In addition, unless the subroutine call interface such as the number of parameters, parameter type, input / output memory size, etc. is changed, when changing the actual processing part,
Only the process part needs to be changed, and there is no need to change the calling process. Therefore, it is more effective when the scale of the actual processing part is large and general, that is, when many processes are used.

(2) Processing by another host Since the program in the other host can be used as an image of calling a subroutine, the processing can be distributed easily. Therefore, there is an advantage that flexibility of system design is increased.

[Brief description of the drawings]

FIG. 1 is a diagram showing the operation principle of the present invention.

FIG. 2 is a diagram showing conversion of subroutine input / output information in the embodiment (1) of the present invention.

FIG. 3 is a diagram showing a program configuration when a socket pair is used.

FIG. 4 is a diagram showing an example of parameter information input by HMI.

FIG. 5 is a diagram showing an example of a source code generation program.

FIG. 6 is a diagram showing a source code generation result.

FIG. 7 is a diagram showing a template for automatic process part generation according to the embodiment (1) of the present invention.

FIG. 8 is a diagram illustrating correction of a keyword portion in a template.

FIG. 9 is a diagram showing file association according to the embodiment (1).

FIG. 10 is a diagram illustrating the operation of the embodiment (2) of the present invention.

FIG. 11 is a diagram exemplifying conventional provision of a subroutine in the same host.

FIG. 12 is a diagram showing an example of conventional function provision to another host.

[Explanation of symbols]

 1 library section 2 process section

Claims (4)

[Claims] 1. In a multi-process computer system, when a certain function is provided to an arbitrary program, a process unit for actually performing the computer system, starting the process, and transmitting parameters to the process, A program that separates the function into a library part that receives return information from the process and uses the function is called by a program that calls the library using the same library call interface as the interface that calls the function. A method of processing a procedure characterized by being executed. 2. A program structure including a library routine and an actual processing process for automatically generating a library part and a process part according to claim 1 from a subroutine source by giving interface information of the function concerned. Procedural process method characterized by being provided by. 3. The process method of claim 1, wherein the process unit is placed in another host connected to the library unit host via a network for actual processing. A method of processing the characteristic procedure. 4. A library routine and a process routine according to claim 3 are automatically generated from a subroutine source by giving interface information of the function concerned, and a library routine which operates on one host, A procedure process method characterized by being provided by a program structure consisting of an actual processing process that operates on the other host.