JP4668367B2 - Computer, parallel distributed system, and function call method - Google Patents

Description

[0001]
[Technical field to which the invention belongs]
The present invention relates to, for example, a computer that performs a function call between processes operating on computers connected via a network, a parallel distributed system, and a function call method.
[0002]
[Prior art]
2. Description of the Related Art A network system in which various computers are connected to a plurality of computers via a network such as a telephone line, cable television, and satellite communication is rapidly spreading. As such a network system, there is a parallel distributed system in which a plurality of objects are arranged on a computer in a network-wide manner and linked to perform desired processing.
Conventionally, many distributed processing languages have been proposed to realize such a parallel distributed system. Also, a distributed system construction function limited to a specific language such as Java RMI (Remote Method Invocation) or HORB has been attempted.
However, in distributed multimedia systems that require a flexible approach to programming, messages between concurrent objects that are described in various programming languages and managed by processes running on various operating systems (OS) There is a request to realize communication. Here, the parallel objects include distributed objects, distributed procedures (functions), global shared variables, and the like.
[0003]
By the way, a message communication mechanism between concurrent objects in a conventional parallel distributed system is composed of, for example, an OS, a distributed platform library depending on a programming language, and one or a plurality of concurrent objects described in the programming language. This is implemented using a user application program.
Here, the distributed platform library includes various modules that perform processing necessary for message communication between concurrent objects, and some modules perform processing involving thread control. A thread means a flow of processing related to message communication for function call, and may be generated by a distributed platform library (program language processing system) or generated by an OS depending on the type of program language.
[0004]
FIG. 7 is a diagram for explaining a message communication mechanism in a conventional parallel distributed system.
In the distributed platform libraries 112 and 116 shown in FIG. 7, only modules related to message reception are shown for simplicity of explanation.
As shown in FIG. 7A, when the user application program 110 is described in the program language “Java”, the distributed platform library 112 is also described in “Java”. Further, as shown in FIG. 7B, when the user application program 114 is described in the program language “C ++”, the distributed platform library 116 is also described in “C ++”.
That is, a distributed platform library is prepared for each programming language.
[0005]
In this way, the distributed platform library is prepared for each programming language for the following reason.
As described above, the distributed platform libraries 112 and 116 perform thread control, and the program language “Java” is generated by the distributed platform library 112 so that the program can be described without depending on the platform below the OS. A Java (pseudo) thread 130 is used, and in the programming language “C ++”, a native thread 134 generated by the OS 118 in response to a thread generation request 132 from the distributed platform library 116 is used.
[0006]
Here, since the thread implementation method differs for each program language, a thread of one program language cannot be a target of thread control in a distributed platform library of another program language.
Therefore, the distributed platform library 112 cannot use the native thread provided by the OS 118 according to the programming language “C ++”, and the distributed platform library 116 cannot use the Java thread generated by the distributed platform library 112.
As a result, user application programs 110 and 114 use their own distributed platform libraries 112 and 116, respectively.
[0007]
[Problems to be solved by the invention]
However, as in the conventional parallel distributed system described above, if a unique distributed platform library must be used for each programming language, it is necessary to develop a large-scale distributed platform library for each programming language. In addition, there is a problem that the burden of debugging work is large.
[0008]
The present invention has been made in view of the above-described problems of the prior art, and an object thereof is to provide a computer, a parallel distributed system, and a function call method that can reduce the burden of development and debugging work of a distributed platform library developed for each programming language. To do.
[0009]
  In order to solve the above-described problems of the prior art and achieve the above-described object, the computer of the present invention is a process that operates on another computer connected via a network or a process that operates on the same computer. A function for receiving a function call message on a predetermined operating system, the process receiving the function call comprising: an application program that provides a function that is a target of the function call; and When receiving a message, out of the function call processing according to the message, a program language independent part that performs processing independent of the type of the program language describing the application program, and a function call processing according to the message home,in frontThe function call message is executed by the program language dependent unit that performs processing depending on the type of the program language.In, Any data structureBut, Treated as an argument of the data representation format used in the application programI,ConcernedIn the message, the argument is converted from the data representation format used in the application program to the data representation format used for communication between networks.The programming language independent part transmits a message for calling a function of a process operating on another computer connected via a network or a process operating on the same computer, and is called by the received message. A reference resolution for converting the reference information for identifying the function to perform the function from the external reference information unique outside the process for calling the function into the internal reference information unique within the process, and a message for determining the execution timing of the message The program language dependent unit activates the function of the application program corresponding to the function call corresponding to the message whose execution timing is determined by the program language independent unit and performs the function call processing. As you do Carried out by starting the function call processing corresponding to the new the message for accepting the message messages concurrently acceptance process based on the function call processing.
[0010]
  The parallel distributed system of the present invention is a parallel distributed system that executes a process while performing a function call between processes operating on operating systems of a plurality of computers connected via a network. The receiving process includes an application program that provides a function that is a target of the function call and a program language that describes the application program in the function call process corresponding to the message when the function call message is received. Of the program language-independent part that performs type-independent processing, and function call processing according to the message,in frontThe function call message is executed by the program language dependent unit that performs processing depending on the type of the program language.In, Any data structureBut, Treated as an argument of the data representation format used in the application programI,ConcernedIn the message, the argument is converted from the data representation format used in the application program to the data representation format used for communication between networks.The programming language independent part transmits a message for calling a function of a process operating on another computer connected through a network or a process operating on the same computer, and is called by the received message. A reference resolution for converting the reference information for specifying the function to perform the function from the external reference information unique outside the process that performs the function call into the internal reference information unique within the process, and a message for determining the execution timing of the message The program language dependent unit activates the function of the application program corresponding to the function call corresponding to the message whose execution timing is determined by the program language independent unit and performs the function call processing. As you do Carried out by starting the function call processing corresponding to the new the message for accepting the message messages concurrently acceptance process based on the function call processing.
[0011]
  The function calling method of the present invention is a function calling method for calling functions between processes. When a process receiving a function call receives a message of the function call, In the function call processing according to the message, the processing independent of the type of the programming language describing the application program is performed in the programming language independent portion.,in frontProcessing dependent on the type of programming language is performed in the programming language dependent section, and the function call messageIn, Any data structureBut, Treated as an argument of the data representation format used in the application programI,ConcernedIn the message, the argument is converted from the data representation format used in the application program to the data representation format used for communication between networks.The program language independent part is configured to send a message to a process that operates on another computer connected via a network or a function of a process that operates on the same computer, and the received message. Determines the reference resolution for converting the reference information for specifying the function to be called from the external reference information unique outside the process for calling the function into the internal reference information unique within the process, and the execution timing of the message And the program language dependent unit activates the function of the application program corresponding to the function call corresponding to the message whose execution timing is determined by the program language independent unit. Call processing Utotomoni, performed in parallel message reception process based on the function call process by starting the function call processing corresponding to the new the message for accepting the message.
[0022]
DETAILED DESCRIPTION OF THE INVENTION
Hereinafter, a parallel distributed system according to an embodiment of the present invention will be described.
In the present embodiment, a distributed distributed system in which a plurality of computers are connected via a network, and each computer performs a desired calculation process in cooperation while communicating via the network. The present invention will be described by exemplifying a parallel distributed system that provides a processing environment.
[0023]
FIG. 1 is a diagram schematically showing the overall configuration of the parallel distributed system of the present embodiment.
The parallel distributed system of the present embodiment regards distributed resources on the network as a logically integrated computing environment in a network environment configured by mixing various communication media such as the Internet, CATV network, and satellite communication. It provides a distributed processing environment.
Here, the distributed resource provides an arbitrary calculation function such as a database, a high-performance calculation server, and an information source of a WWW page in addition to the hardware function of each node. The calculation includes execution of various processes in a wide range.
[0024]
In such a distributed processing environment, parallel objects as calculation entities are arranged to form a calculation space. Note that a plurality of calculation spaces can be individually formed on the same network environment.
Specifically, this concurrent object is a distributed object that can be called remotely, a distributed function, or a shared variable (global shared variable) that can be referred to via a network. Thus, the calculations such as the distributed object-oriented calculation, the distributed function (procedure) call, and the global shared variable processing are performed in parallel.
[0025]
Communication between concurrent objects such as calling concurrent object methods and distributed functions and accessing global shared variables to perform such calculations is as follows: (1) Asynchronous message transmission (unidirectional communication without return value) (2) Delay evaluation type synchronous call (blocks when the return value is accessed) and (3) Complete synchronous call (caller blocks until return value arrival). These communications are collectively referred to as message communications.
That is, such a parallel distributed system can be said to be a system in which parallel objects distributed and arranged on a network sequentially execute parallel calculations by message communication and advance desired calculations as a whole by a chain of messages. .
[0026]
As shown in FIG. 2, each parallel object placed in the calculation space generates and manages a process in a computer.
A process is a computing environment for concurrent objects that provides a mechanism for sending and receiving messages between concurrent objects. For this reason, an application language interface (API) and a system interface for the OS and hardware are provided, and the system can be operated in accordance with differences in execution environments such as programming languages, OS, hardware, and networks. In addition, messages can be sent between different languages, and any data structure can be handled as an argument.
As a result, the execution environment obtained as a set of such processes functions as a common virtual computing environment in the global space.
[0027]
Hereinafter, a message communication mechanism provided in each process in order to realize communication between such processes will be described.
The message communication mechanism is realized in a process operating on each computer connected via a network.
[0028]
When the user application program is "Java"
FIG. 3 is a diagram for explaining the reception function of the message communication mechanism provided by the process when the user application program 110 written in the program language “Java” is used.
In this case, as shown in FIG. 3, the reception function of the message communication mechanism is realized by the OS 117, the language-independent part common library 10, the language-dependent part library 20, and the user application program 110.
The interface between the language-independent part common library 10 and the language-dependent part library 20 is an external function interface provided by the language-dependent part library 20, for example, “Java Native Interface” of JDK1.1. Is done.
First, each component will be described in detail.
[0029]
[OS117]
For example, Unix (trade name) and MS-DOS (trade name) are used as the OS 117.
[0030]
[Language independent library 10]
The language-independent part common library 10 is a collection of basic functions that do not depend on the program language among the message communication functions as common functions, and is positioned as a system-independent function layer.
Specifically, the reception function of the language independent common library 10 includes a reference resolution module 11, a message distributor module 12, a CPP preinvoke module 13, and a message evaluation scheduler. It is realized by a scheduler module 14, a CPP postinvoke module 15, a CMI (Communication Media Interface) module 16, and a sending launcher module 17. Each module may be generated, for example, by executing a program described in the program language “C ++” in a CPU (Central Processing Unit) of the computer, or may be realized by hardware.
[0031]
When the language-independent part common library 10 is generated by executing a program described in the program language “C ++”, the language-independent part common library 10 is also linked from the program language “Java” in order to use it. It is realized as a DLL (Dynamic Link Library). This eliminates the need to reconstruct the user application program even when the distributed platform is upgraded or bug-fixed.
[0032]
The reference resolution module 11 manages global references to the concurrent objects and distributed object methods that make up the user procedure 120. At the time of message transmission, a computer having a destination parallel object to which a message is transmitted, a process identifier, and a communication protocol for message transmission are determined. In the case of message reception, the concurrent object and process identifier 50 included in the message_FiveAnd the identifier 50_FiveIs converted from the external reference information unique on the network to the internal reference information unique within the process, and the identifier 50 obtained by the conversion is converted.₆Is output to the message distributor module 12.
[0033]
The message distributor module 12 receives a call request 50 from the receiver module 22 of the language dependent library 20.₁The call request 50 of the CMI module 16 is received.₂To call the CMI module 16.
The message distributor module 12 receives a structure FD (Function Descriptor) 50 from the CMI module 16._FourIs input, the structure FD50_FourOf concurrent objects and processes contained in_FiveIs output to the reference resolution module 11, and the identifier 50 obtained from the reference resolution module 11 is output.₆Based on the message 50_FourIs determined to be directed to its own process. And message 50_FourIs addressed to its own process, the message distributor module 12 sends the structure FD50._FourThe structure FD50₇To the receiver module 22.
[0034]
  The CMI module 16 calls the call request 50 by the message distributor module 12.₂It is called by, and enters the standby state after being called. When the CMI module 16 receives a message from an external process, the CMI module 16 enters an operating state, and the structure FD50 that stores the received message.₄Is output to the message distributor module 12. Also, the CMI module 16 returns the return value 50 input from the sending launcher module 17.₂₄Including message 50₂₅Message 50₃Output to the sender. The CMI module 16 operates on another computer connected via a network.processUsed when communicating with. The CMI module 16 is configured as an independent module for each communication protocol, and for example, Ethernet or ISDN is used as the communication protocol. When communicating with other processes operating on the same computer, the process communication function provided by the OS 117 is used without using the CMI module 16.
[0035]
The CPP pre-invoke module 13 calls the call request 50 from the pre-invoke module 23 of the language dependent unit library 20.₁₁In response, the call request 50 of the message evaluation scheduler module 14 is received.₁₂And call request 50₁₁FD50 included as an argument in₁₂Is output to the message evaluation scheduler module 14.
The CPP pre-invoke module 13 receives one or more structures FD50 from the message evaluation scheduler module 14.₁₃Is inputted, the inputted structure FD50₁₃The structure FD50₁₄To the pre-invoke module 23 of the language dependent library 20.
[0036]
The message evaluation scheduler module 14 receives the structure FD input from the CPP pre-invoke module 13.₁₂The structure FD is stored in the built-in queue based on the priority added to the message stored in₁₂Register. Then, the structure FD present at the head of the queue, that is, the structure FD having the highest priority is sequentially extracted to obtain the structure FD50.₁₃To the CPP pre-invoke module 13.
[0037]
The CPP post-invoke module 15 receives a call request 50 from the post-invoke 25 of the language dependent library 20._{twenty two}When the call request 50 is received,_{twenty two}Structure FD50 included in_{twenty three}Return value 50 of procedure caller module 21_{twenty three}Are output to the sending launcher module 17.
[0038]
The sending launcher module 17 has a structure FD50 input from the CPP post invoke module 15._{twenty three}Included in the message 50_ThreeThe sender information is extracted, and a return value 50 is sent to the sender._{twenty three}Call request 50 to send_{twenty four}To call the CMI module 16.
[0039]
[Language dependent library 20]
Similar to the user application program 110, the language dependent unit library 20 is described in the program language “Java” and includes modules for performing various processes including thread generation and thread control.
[0040]
As shown in FIG. 3, the reception function of the language dependent library 20 includes a procedure caller module 21, a receiver module 22, a preinvoke module 23, an invoker module 24, and a post-in. This is realized by a postinvoke module 25 and a thread generation module 26. Each module may be generated, for example, by executing a program described in the program language “Java” in a CPU of a computer, or may be realized by hardware.
[0041]
The receiver module 22 has a structure FD50.₇Is input from the message distributor module 12, the thread generation request 50₈Is output to the thread generation module 26. As a result, a new receiver module 22 is generated, and the new receiver module 22₁Is output to the message distributor module 12 again. At the same time, the structure FD50₇, The receiver module 22 receives the structure 50 as an argument.₇Call request 50 including_TenIs output to the pre-invoke module 23.
[0042]
The thread generation module 26 receives a thread generation request 50 from the receiver module 22.₈Is input, a new receiver module 22 is generated.
Further, the thread generation module 26 receives a thread generation request 50 from the pre-invoke module 23.₃₀Is input, the thread generation request 50₃₀The number of invoker modules 24 specified in (1) is generated.
[0043]
The pre-invoke module 23 receives a call request 50 from the receiver module 22._TenIs input, the call request 50 of the CPP pre-invoke module 13 of the language-independent part common library 10 is entered.₁₁And the structure 50 as an argument₇Is output to the CPP pre-invoke module 13.
Further, the pre-invoke module 23 is supplied from the CPP pre-invoke module 13 by one or more structures FD50.₁₄Is input, the structure FD50₁₄Thread generation request 50 for instructing to generate the number of invoker modules 24₃₀Is output to the thread generation module 26.
Further, the pre-invoke module 23 includes the structure FD50.₁₄The structure FD50₁₆Is output to the invoker module 24.
[0044]
At this time, the pre-invoke module 23 has three structures FD50 from the CPP pre-invoke module 13.₁₄[1], FD50₁₄[2] and FD50₁₄When [3] is input, three invoker modules 24 are correspondingly generated by the thread generation module 26.₁, 24₂And 24_ThreeIs generated. Then, the pre-invoke module 23 to the invoker module 24₁, 24₂And 24_ThreeAnd the structure FD50, respectively.₁₄[1], FD50₁₄[2] and FD50₁₄[3] is output.
[0045]
The invoker module 24 is a structure FD50 input from the pre-invoke module 23.₁₄For each message, the procedure caller module 21 to be called is determined for each message, and the call request 50 of the determined procedure caller module 21 is determined.₁₇Is generated. Then, the invoker module 24 receives the structure FD 50 input from the pre-invoke module 23 as an argument to the called procedure caller module 21.₁₄Is output.
The invoker module 24 also returns a return value 50 in the internal representation format input from the procedure caller module 21.₂₀Is converted into a logical representation form. Here, the internal representation format is a data representation format used by the user application program 110, and the logical representation format is a network-wide data representation format used when communication is performed between networks. .
The invoker module 24 is a structure FD50 input from the pre-invoke module 23.₁₄And the return value 50 converted as described above.₂₀Call request 50 that includes_{twenty one}Is output to the post invoke module 25.
[0046]
  The procedure caller module 21 has a structure FD50 input from the invoker module 24.₁₄The call request 50 of the user procedure 120 which is a parallel object, function or method in the user application program 110 using the arguments stored in₁₈Is generated. Thereby, the function of the user procedure 120 is executed, and a return value is generated as necessary. The procedure caller module 21 returns a return value of 50 from the user procedure 120.₁₉Is entered, the return value 50₁₉ ReturnReturn value 50₂₀To the invoker module 24.
[0047]
The post invoke module 25 is a call request 50 input from the invoker module 24._{twenty one}Structure FD50 included in₁₄And return value 50₂₀Call request 50 of CPP post invoke module 15 with_{twenty two}Is generated.
[0048]
[User application program 110]
The user application program 110 includes one or a plurality of user procedures 120 written in the program language “Java”.
[0049]
The user procedure 120 is a concurrent object, a function, a method, or the like.
In this embodiment, the user procedure 120 is a function that is called from another process, and a call request 50 from the procedure caller module 21.₁₈In response to this, a predetermined process is performed using the argument input from the sync call module 60 as necessary, and a return value 50 corresponding to the processing result₅₀Is output to the sync call module 60.
[0050]
The operation of the reception function of the message communication mechanism shown in FIG. 3 will be described below.
First, for example, a structure in which a message output from a process operating on another computer connected via a network is received by the CMI module 16 of the language independent common library 10 and the received message is stored. Body FD50_FourIs output to the message distributor module 12.
[0051]
The message distributor module 12 receives the structure FD50 from the CMI module 16._FourIs input, the structure FD50_FourOf concurrent objects and processes contained in_FiveIs output to the reference resolution module 11 and the identifier 50 obtained from the reference resolution module 11 is output.₆Based on the message 50_FourIs determined to be directed to its own process. And message 50_FourIs determined to be addressed to its own process, the message distributor module 12 sends the structure FD50._FourIs structure FD50₇Is output to the receiver module 22.
[0052]
Structure FD50 from the message distributor module 12 to the receiver module 22₇Is input from the receiver module 22 to the thread generation module 26.₈Is output. Then, a new receiver module 22 is generated by the thread generation module 26.
As a result, a call request 50 is sent from the new receiver module 22 to the message distributor module 12.₁Will occur again. At the same time, the structure FD50₇To the pre-invoke module 23 from the receiver module 22 that has received₇Call request 50 including_TenWill occur.
[0053]
Call request 50 from the receiver module 22 to the pre-invoke module 23_TenIs generated, the call request 50 for the CPP pre-invoke module 13 of the language independent part common library 10 from the pre-invoke module 23 is generated.₁₁And the structure 50 as an argument₇Is output to the CPP pre-invoke module 13.
[0054]
Call request 50 from pre-invoke module 23 of language dependent library 20₁₁Is received by the CPP pre-invoke module 13, the call request 50 of the message evaluation scheduler module 14 is received.₁₂And call request 50₁₁FD50 included as an argument in₁₂Is output to the message evaluation scheduler module 14.
[0055]
Then, in the message evaluation scheduler module 14, the structure FD input from the CPP pre-invoke module 13.₁₂The structure FD is stored in the built-in queue based on the priority added to the message stored in₁₂Is registered. Further, the structure FD present at the head of the queue, that is, the structure FD having the highest priority is sequentially extracted, and this structure FD50 is extracted.₁₃To the CPP pre-invoke module 13.
[0056]
Further, from the message evaluation scheduler module 14, one or a plurality of structures FD50₁₃Is input to the CPP pre-invoke module 13, the input structure FD50 is input.₁₃Is structure FD50₁₄Is output to the pre-invoke module 23 of the language dependent library 20.
[0057]
From the CPP pre-invoke module 13, one or more structures FD50₁₄Is input by the pre-invoke module 23, the structure FD50₁₄Thread generation request 50 for instructing to generate the number of invoker modules 24₃₀Is output to the thread generation module 26.
Then, the thread generation module 26 causes the structure FD50.₁₄The number of invoker modules 24 is generated. Further, the structure FD50 is transferred from the pre-invoke module 23 to the invoker module 24.₁₄Is structure FD50₁₆Is output as
[0058]
Then, in the invoker module 24, the structure FD50 input from the pre-invoke module 23.₁₄For each message, the procedure caller module 21 to be called is determined, and the call request 50 of the determined procedure caller module 21 is determined.₁₇Will occur. Then, the structure FD50 input from the invoker module 23 as an argument to the called procedure caller module 21 from the invoker module 24.₁₄Is output.
[0059]
Then, in the procedure caller module 21, the structure FD 50 input from the invoker module 24.₁₄The call request 50 of the user procedure 120 in the user application program 110 using the argument stored in₁₈Will occur. Thereby, the function of the user procedure 120 is executed, and a return value is generated as necessary.
[0060]
Return value 50 from the user procedure 120 to the procedure caller module 21₁₉Is output, the return value 50₁₉Returns 50₂₀Is output to the invoker module 24.
[0061]
Then, in the invoker module 24, the return value 50₂₀Is converted from the internal representation format to the logical representation format, and the structure FD50 inputted from the invoker module 24 to the post invoke module 25 and from the pre invoke module 23 is obtained.₁₄And the return value 50 converted into the logical expression format.₂₀Call request 50 that includes_{twenty one}Will occur.
[0062]
Then, the call request 50 input from the invoker module 24 by the post invoke module 25._{twenty one}Structure FD50 included in₁₄And return value 50₂₀Call request 50 of CPP post invoke module 15 with_{twenty two}Is generated.
[0063]
Then, the CPP post invoke module 15 calls the call request 50 from the post invoke 25 of the language dependent unit library 20._{twenty two}When the call request 50 is received,_{twenty two}Structure FD50 included in_{twenty three}Return value 50 of procedure caller module 21_{twenty three}Are output to the sending launcher module 17.
[0064]
Then, in the sending launcher module 17, the structure FD50 inputted from the CPP post invoke module 15 is used._{twenty three}Included in the message 50_ThreeSource information is extracted and a return value of 50 is returned to the source._{twenty three}Call request 50 to send_{twenty four}And the CMI module 16 is called.
[0065]
Then, the return value 50 input from the sending launcher module 17 from the CMI module 16._{twenty four}Including message 50_{twenty five}But message 50_ThreeIs output to the sender.
[0066]
FIG. 4 is a diagram for explaining the transmission function of the message communication mechanism provided by the process when the user application program 110 written in the program language “Java” is used.
[0067]
[Language independent library 10]
As shown in FIG. 4, the transmission function of the language independent part common library 10 is realized by a reference resolution module 11, a CMI module 16, a calling launcher module 71, and a message sender module 72. Each module may be generated, for example, by executing a program written in the program language “C ++” in a CPU of a computer, or may be realized by hardware.
[0068]
The calling launcher module 71 receives a call request 50 from the caller module 61.₅₂In response, the call request 50 of the message sender module 72 is received.₅₃And call request 50₅₂The reference information to the destination user procedure and the argument of the logical expression format to be given to the destination user procedure are output to the message sender module 72.
The calling launcher module 71 also returns a return value 50 from the message sender module 72.₅₈When this is entered, this is returned as the return value 50₅₉To the caller module 61.
[0069]
The message sender module 72 uses the reference information 50 input from the calling launcher module 71 in order to specify the transmission destination.₇₁Is output to the reference resolution module 11 and the message destination information 50 is output.₇₀Get.
The message sender module 72 sends message destination information 50.₇₀And a call request 50 including a logical expression format argument input from the calling launcher module 71.₅₄Is output to the CMI module 16.
The message sender module 72 also returns a return value 50 from the CMI module 16.₅₇When this is entered, this is returned as the return value 50₅₈To the calling launcher module 71.
[0070]
The CMI module 16 sends message destination information 50₇₀Argument 50 in the logical expression format input from the message sender module 72 for the destination specified in FIG.₅₅Send.
The CMI module 16 returns a return value 50 from another process.₅₆When this is entered, this is returned as the return value 50₅₇To the message sender module 72.
[0071]
[Language dependent library 20]
As shown in FIG. 4, the transmission function of the language dependent unit library 20 is realized by a sync call module 60 and a caller module 61.
[0072]
The caller module 61 calls the call request 50 from the sync call module 60.₅₁When received, the logical expression format arguments and reference information input from the sink call module 60 are input, and the calling request 50 of the calling launcher module 71 including them is input.₅₂Is generated.
The return value 50 from the calling launcher module 71₅₉When this is entered, this is returned as the return value 50₆₀To the sync call module 60.
[0073]
The sync call module 60 receives the call request 50 from the user procedure module 80.₅₀When received, the argument and the reference information of the destination are input from the user procedure module 80, the input argument is converted from the internal representation format to the logical representation format, and the caller including the converted argument and the input reference information Call request 50 of module 61₅₁Is generated.
Also, the sync call module 60 receives a return value 50 from the caller module 61.₆₀Is converted into the internal representation format, and the converted return value is returned to the return value 50.₆₁To the user procedure module 80.
[0074]
[User application program 110]
The user application program 110 includes one or a plurality of user procedures 80 written in the program language “Java”.
[0075]
The user procedure 80 is a concurrent object, a function or a method.
In this embodiment, the user procedure 80 is a function for calling a function provided by another process, and a call request 50 is sent to the sink call module 60.₅₀Return value 50₆₁Stops processing until is entered. Then, the return value 50 from the sync call module 60₆₁When is entered, the process is resumed.
[0076]
In addition to the sync call module 60, the language dependent unit library 20 can generate a send module and a call module in response to a call request from the user procedure module 80, for example.
Here, upon receiving a call request from the user procedure module 80, the send module and the call module generate a call request (thread) for the caller module 61 in response to the call request, and the thread generation module 26 shown in FIG. A thread generation request is output, and the newly generated thread is returned to the user procedure module 80. The user procedure module 80 receives the new thread and resumes processing.
Here, the send module does not input a return value from the callee process, whereas the call module inputs a return value from the callee process.
[0077]
The operation of the transmission function of the message communication mechanism shown in FIG. 4 will be described below.
First, when a function provided by a user procedure module of a user application program of a process operating on another computer connected via a network is called from the user procedure module 80 of the user application program 110, an argument and a transmission destination Call request 50 of the sink call module 60 including the reference information of₅₀Is generated.
Call request 50 from user procedure module 80₅₀When the sink call module 60 receives the call, the argument from the user procedure module 80 is converted from the internal representation format to the logical representation format, and the call request 50 of the caller module 61 including the converted argument and the input reference information.₅₁Is generated.
[0078]
Call request 50 from the sync call module 60₅₁Is received by the caller module 61, the call request 50 of the calling launcher module 71 including the arguments in the logical expression format input from the sync call module 60 and the reference information.₅₂Is generated.
[0079]
Call request 50 from caller module 61₅₂Is received by the calling launcher module 71, the calling launcher module 71 issues a call request 50 for the message sender module 72.₅₃And call request 50₅₂The reference information to the destination user procedure and the argument of the logical expression format to be given to the destination user procedure are output to the message sender module 72.
[0080]
The reference information 50 input from the calling launcher module 71 in order to specify the transmission destination₇₁Is output from the message sender module 72 to the reference resolution module 11, and the message transmission destination information 50 is output from the reference resolution module 11.₇₀Is obtained.
Then, a call request 50 is sent from the message sender module 72.₅₄Occurs, message destination information 50₇₀And arguments in the logical expression format input from the calling launcher module 71 are output to the CMI module 16.
[0081]
Then, the CMI module 16 sends message destination information 50.₇₀Argument 50 in the logical expression format input from the message sender module 72 for the destination specified in FIG.₅₅Is sent.
[0082]
Thereafter, the CMI module 16 returns a return value 50 from another process.₅₆This will return a return value of 50₅₇Is output to the message sender module 72. This return value 50₅₇Is output to the user procedure module 80 via the message sender module 72, the calling launcher module 71, the caller module 61, and the sync call module 60.
[0083]
When the user application program is “C ++”
FIG. 5 is a diagram for explaining the reception function of the message communication mechanism provided by the process when the user application program 114 written in the program language “C ++” is used.
In this case, as shown in FIG. 5, the reception function of the message communication mechanism is realized by the OS 117, the language-independent part common library 10, the language-dependent part library 30, and the user application program 114.
In FIG. 5, the language independent part common library 10 is the same as the language independent part common library 10 described above with reference to FIG. That is, the language-independent part common library 10 is described in the program language “C ++”.
[0084]
[Language dependent library 30]
Similar to the user application program 114, the language dependent library 30 is described in the program language “C ++” and includes modules for performing various processes including thread generation and thread control.
[0085]
As shown in FIG. 5, the reception function of the language dependent unit library 30 is realized by the procedure caller module 21, the receiver module 32, the pre-invoke module 33, the invoker module 24, and the post-invoke module 25.
Here, the procedure caller module 21, the invoker module 24, and the post invoke module 25, which have the same reference numerals as those in FIG. 3, are the same as those shown in FIG.
Each module may be generated by executing a program described in the program language “C ++” in a CPU of a computer, for example, or may be realized by hardware.
[0086]
The receiver module 32 has a structure FD50.₇Is input from the message distributor module 12, the thread generation request 50₈Is output to the OS 118. As a result, a new receiver module 32 is generated, and the new receiver module 32 receives the call request 50.₁Is output to the message distributor module 12 again. At the same time, the structure FD50₇, The receiver module 22 receives the structure FD50.₇Call request 50 that contains as an argument_TenIs output to the pre-invoke module 33.
[0087]
The pre-invoke module 33 receives a call request 50 from the receiver module 32._TenIs input, the call request 50 of the CPP pre-invoke module 13 of the language-independent part common library 10 is entered.₁₁And the structure 50 as an argument₇Is output to the CPP pre-invoke module 13.
Further, the pre-invoke module 33 is supplied from the CPP pre-invoke module 13 by one or more structures FD50.₁₄Is input, the structure FD50₁₄Thread generation request 50 for instructing to generate the number of invoker modules 24₃₀Is output to the OS 118.
Further, the pre-invoke module 33 includes the structure FD50.₁₄The structure FD50₁₆Is output to the invoker module 24.
[0088]
At this time, the pre-invoke module 33 has three structures FD50 from the CPP pre-invoke module 13.₁₄[1], FD50₁₄[2] and FD50₁₄When [3] is input, the three invoker modules 24 are correspondingly executed by the OS 118.₁, 24₂And 24_ThreeIs generated. And the pre-invoke module 33 to the invoker module 24₁, 24₂And 24_ThreeAnd the structure FD50, respectively.₁₄[1], FD50₁₄[2] and FD50₁₄[3] is output.
[0089]
[OS118]
The OS 118 sends a thread generation request 50 from the pre-invoke module 33.₃₀Is input, the thread generation request 50₃₀The number of invoker modules 24 specified in (1) is generated.
[0090]
[User application program 114]
The user application program 114 includes one or a plurality of user procedures 140 described in the program language “C ++”.
The user procedure 140 is a concurrent object, a function, a method, or the like.
In this embodiment, the user procedure 140 is a function that is called from another process, and a call request 50 from the procedure caller module 21.₁₈In response to this, a predetermined process is performed using the argument input from the sync call module 60 as necessary, and a return value 50 corresponding to the processing result₅₀Is output to the sync call module 60.
[0091]
The operation of the receiving function of the message communication mechanism shown in FIG.₈, 50₃₀3 is the same as the operation of the reception function shown in FIG.
[0092]
Next, when the user application program 114 written in the program language “C ++” is used, the transmission function of the message communication mechanism provided by the process is such that the language dependent unit library 30 and the user application program 114 have the program language “C ++”. Is basically the same as that shown in FIG.
[0093]
In addition to the sync call module 60, the language dependent unit library 30 can generate the above-described send module and call module in response to a call request from the user procedure module 80, for example.
[0094]
However, in the case of the language dependent part library 30, unlike the case of the language dependent part library 20, when the send module and the call module receive a call request from the user procedure module 80, the caller module 61 corresponding to the call request is sent. A call request (thread) is generated and the process returns to the user procedure module 80.
[0095]
As described above, according to the parallel and distributed system of the present embodiment, as shown in FIG. 6, the process of the user application program 110 described in the program language “Java” and the program language “C ++” are described. The language independent part common library 10 having modules other than the modules related to thread control can be shared with the process of the user application program 114. Therefore, the language dependent part library 20 of the program language “Java” and the language dependent part library 30 of the program language “C ++” can be made small.
As a result, it is possible to reduce the burden of developing and debugging a distributed platform library composed of the language dependent part libraries 20 and 30 and the language independent part common library 10.
Further, since the modules related to thread control are individually provided in the language dependent library 20 and 30, it is possible to effectively avoid erroneous thread control.
[0096]
Moreover, according to the parallel distributed system of this embodiment mentioned above, in the receiver module 22 shown in FIG._TenIn addition to existing threads that generate₁Therefore, the execution of the function of the user procedure 120 based on the existing thread and the message communication by the message distributor module 12 and the CMI module 16 generated according to the new thread are performed in parallel. Can be done.
[0097]
The present invention is not limited to the embodiment described above.
In the above-described embodiment, “Java” and “C ++” are exemplified as the program language in which the user application program is described, but “LISP” or the like may be used. Even when the program language “LISP” is used, the language dependent library is realized in the same manner as “Java” and “C ++”.
[0098]
In the above-described embodiment, the case where the function call of the user procedure module is performed between processes operating on different computers connected via a network is illustrated. However, different processes operating on the same computer The present invention can also be applied when a function call of a user procedure module is performed between.
[0099]
【The invention's effect】
As described above, according to the computer, the parallel distributed system, and the function calling method, a plurality of programs can be provided by providing a program language independent part that performs processing independent of the type of program language as part of the distributed platform library. When developing a distributed platform library of a language, the program language independent part can be shared, and the burden of development and debugging work of the distributed platform library can be reduced.
[Brief description of the drawings]
FIG. 1 is a diagram schematically showing an overall configuration of a parallel distributed system according to an embodiment of the present invention.
FIG. 2 is a diagram for explaining a relationship between a process and a parallel object;
FIG. 3 is a diagram for explaining a reception function of a message communication mechanism provided by a process when a user application program described in a program language “Java” is used;
FIG. 4 is a diagram for explaining a transmission function of a message communication mechanism provided by a process when a user application program written in a program language “Java” is used;
FIG. 5 is a diagram for explaining a reception function of a message communication mechanism provided by a process when a user application program written in a program language “C ++” is used;
FIG. 6 is a diagram for explaining the effect of the parallel distributed system according to the embodiment of the present invention.
FIG. 7 is a diagram for explaining a reception function of a conventional message communication mechanism provided by a process when a user application program written in program languages “Java” and “C ++” is used; .
[Explanation of symbols]
DESCRIPTION OF SYMBOLS 10 ... Language independent part common library, 11 ... Reference resolution module, 12 ... Message distributor module, 13 ... CPP pre-invoke module, 14 ... Message evaluation scheduler module, 15 ... CPP post-invoke module, 16 ... CMI module, 17 ... Sending launcher module, 20 ... language dependent library, 21 ... procedure caller module, 22 ... receiver module, 23 ... pre-invoke module, 24 ... invoker module, 25 ... post invoke module, 26 ... thread generation module, 60 ... Sync call module, 61 ... Caller module, 71 ... Calling launcher module, 72 ... Message sender module, 80, 120, 140 ... Over Heather Puroshija, 110, 114 ... user application program, 117,118 ... OS

Claims (6)

A computer that operates on a predetermined operating system a process that receives a function call message from a process that operates on another computer connected through a network or a process that operates on the same computer,
The process that receives the function call is
An application program that provides a function that is a target of the function call;
When receiving the function call message, out of the function call processing according to the message, a program language independent part that performs processing independent of the type of the program language describing the application program,
Of function call processing according to the message, and the program language dependent portion that performs processing that depends on the type of prior SL programming language,
Executed by
In the message of the function call, any data structure, handling cracking as arguments representation of the data used by the application program,
In the message, the argument is converted from the data representation format used in the application program to the data representation format used for communication between networks .
The programming language independent part is
Sending a message for calling a function of a process operating on another computer connected to the network or a process operating on the same computer;
Reference resolution for identifying the function to be called by the received message is converted from external reference information unique outside the process for performing the function call to internal reference information unique within the process, and
Message evaluation scheduling to determine the execution timing of the message;
And
The program language dependent part is:
While activating the function of the application program corresponding to the function call according to the message whose execution timing has been determined by the program language independent part and performing the function call process,
A computer that activates a function call process corresponding to the new message for receiving the message and performs a message reception process based on the function call process in parallel . Activation of the function call processing and activation of the function of the application program are as follows:
The computer according to claim 1, which is performed by the program language dependent unit generating a request for generating a new thread in the process. The program language dependent unit includes a thread generation unit that generates the new thread in response to the thread generation request.
The computer according to claim 2 , wherein the application program and the program language dependent unit are programs written in a program language that generates the thread in the program language dependent unit. The operating system generates the new thread in response to the thread generation request generated by the programming language dependent unit,
The computer according to claim 2 , wherein the application program and the program language dependent unit are programs written in a program language that causes the operating system to execute the thread generation. In a parallel distributed system that executes processing while performing function calls between processes operating on operating systems of a plurality of computers connected via a network,
The process of receiving the function call of the computer is
An application program that provides a function that is a target of the function call;
When receiving the function call message, out of the function call processing according to the message, a program language independent part that performs processing independent of the type of the program language describing the application program,
Of function call processing according to the message, and the program language dependent portion that performs processing that depends on the type of prior SL programming language,
Executed by
In the message of the function call, any data structure, handling cracking as arguments representation of the data used by the application program,
In the message, the argument is converted from the data representation format used in the application program to the data representation format used for communication between networks .
The programming language independent part is
Sending a message for calling a function of a process operating on another computer connected to the network or a process operating on the same computer;
Reference resolution for identifying the function to be called by the received message is converted from external reference information unique outside the process for performing the function call to internal reference information unique within the process, and
Message evaluation scheduling to determine the execution timing of the message;
And
The program language dependent part is:
While activating the function of the application program corresponding to the function call according to the message whose execution timing has been determined by the program language independent part and performing the function call process,
A parallel distributed system that activates a function call process corresponding to the new message for accepting the message and performs message accepting processes based on the function call process in parallel. In the function call method for calling functions between processes,
The process that receives the function call is
When receiving the function call message, among the function call processes corresponding to the message, the process independent of the type of the program language describing the application program is performed in the program language independent part,
Of function call processing according to the message, it performs a process that depends on the type of prior SL program language program language-dependent part,
In the message of the function call, any data structure, handling cracking as arguments representation of the data used by the application program,
The argument is converted from the data representation format used in the application program to the data representation format used for communication between networks in the message ,
The programming language independent part is
A message transmission process for calling a function of a process operating on another computer connected via a network or a process operating on the same computer;
A reference resolution process for converting the reference information for specifying the function to be called by the received message from the external reference information unique outside the process for performing the function call into the internal reference information unique within the process;
A message evaluation scheduling process for determining the execution timing of the message;
And
The program language dependent part is:
While activating the function of the application program corresponding to the function call according to the message whose execution timing has been determined by the program language independent part and performing the function call process,
A function call method that activates a function call process according to the new message for receiving the message and performs a message reception process based on the function call process in parallel .

Images