JP2005250958A - Service execution processing system in distributed computing environment, client device and program therefor, and service execution processing method - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To speed up processing by shortening a service execution request time. <P>SOLUTION: This service execution processing system for acquiring, in a distributed object environment, definition information for an interface every service use and executing the calling of of a service comprises a means generating, at the time of calling an operation provided by a certain service, a component specialized for the operation to be called, and a means executing the calling of the operation by use of the generated component. <P>COPYRIGHT: (C)2005,JPO&NCIPI

Description

  The present invention provides a service execution processing system in a distributed computing environment, a client apparatus and a program thereof, and a service execution process that acquire definition information regarding an interface every time the service is used in the distributed computing environment, and call and execute the service. Regarding the method.

In a distributed computing environment, there is an implementation in which a service using application acquires definition information about an interface every time it is used and can dynamically call a service. This execution format is called dynamic binding. By the way, as a method for realizing dynamic binding, a service component is called using a general-purpose component that can handle various definition information. More specifically, a conventional remote service call procedure in a distributed object system using dynamic binding is as follows.
First, the client accesses the naming service and acquires a specific client stub corresponding to the name of the interface to be acquired. Subsequently, the service operation is remotely called using it.
Among the procedures described above, the latter method of accessing the service is as follows: (1) When a service call code using a client stub used for service call is directly written in the client; (2) It does not depend on the client stub used. Code may be written to the client.

FIG. 6 shows the service execution procedure according to (1) above and FIG. 7 to (2) above. The service factory in FIG. 7 is a part that generates a service processing component corresponding to the name of the interface, and the “service processing component” is a code part that realizes a service call process.
When executing a service dynamically according to the interface determined each time at the time of execution, in the method shown in (1), the client must be changed every time the operation to be executed by the same service is changed. There is a problem that other services cannot be called by a common client. In the method shown in (2), since a common client can call another service using a general-purpose client, the problem (1) can be solved. Since the following two processes that are not necessary in the method (a) and (b) are added, there is a problem that the process becomes slow.

(A) Since the service processing component is implemented using a general-purpose component, the operation object generation process and the message object generation process for the operation can be reused in the case of the same operation. Despite this, it is executed every time it is called. Therefore, when the same operation is called repeatedly, it becomes a performance overhead especially.
(B) Since the service processing component is mounted using a general-purpose component, method calls using reflection with a large processing overhead increase. This is also a performance problem. “Reflection” is a method of dynamically generating a method object related to a method from a method name and executing a method using the method name for general-purpose method calling.

  In order to solve the respective problems when the above methods (1) and (2) are used, it is necessary to minimize degradation of performance while maintaining versatility. As an existing technology that realizes this, there is a program specialization. “Program specialization” is a technique for automatically generating a program using a partial input given to the program and fixing a part of the program to the input value. As a result, a general-purpose and highly readable program can be executed after being converted into a program for a specific purpose.

Next, a method for solving the above two problems using existing program specialization techniques will be examined. In program specialization, a method that specializes at the source language level is called partial calculation. When a program is frequently executed with fixed input, the partial calculation is applied as static input. (See, for example, Non-Patent Document 1).
FIG. 8 shows this technique. In FIG. 8, for example, when calling an operation like A, if S = 4 is known, by performing a partial calculation as a static input to the function F, a specialized code such as B can be obtained. Can be generated.

There is also a technology that specializes the code for serialization and deserialization processing of objects specified as operation arguments and reuses them to reduce the number of reflections, resulting in improved performance ( For example, refer nonpatent literature 2).
Here, “serialization processing” refers to conversion of data handled in the software so that it can be transmitted / received over the network, and “deserialization processing” refers to serial data sent over the network. Is to restore the converted data to the original data format that can be handled by software. FIG. 9 shows a method for specializing serialization and deserialization processing of argument objects. Regarding this method, processing procedures on the client side are listed in the following (1) to (8).

(1) Obtaining field information of an object using reflection and creating a Java (registered trademark) source program for serializing or deserializing related objects (Java (registered trademark) was developed by Sun Microsystems, Inc.) Programming language).
(2) Compile the source program and convert it into byte code.
(3) The serialization class is read into a Java (registered trademark) virtual machine on the client side.
(4) Write the object field information and the deserialization class as a byte string.
(5) Using the generated serialization class, write the value of the field of the object that needs to be serialized as a byte string.
(6) The written byte string is transmitted to the server side.

Next, processing procedures on the server side at the time of remote call are listed in the following (1) to (4).
(1) Receive a byte string.
(2) Extract the field information of the object and restore it to the object shape.
(3) The generated class for deserialization is extracted and read into the virtual machine.
(4) The serialized object is deserialized on the client side and restored to the object form.
At the second and subsequent remote calls, the serialization class has been loaded into the Java virtual machine on the client side, and the deserialization class has been loaded into the Java virtual machine on the server side. Therefore, only (5) and (6) of the above processing are required on the client side, and only (1) and (4) are required on the server side.
"Design and Implementation of Adaptive Partial Computation for Java (R) Language", 6th Workshop on Programming and Application Systems SPA 2003 "Acceleration of RMI by efficient code self-generation", IEICE Vol.J84-B No.5 pp.883-892 May 2001

As described above, the conventional program specialization has realized speeding up by replacing the operation argument itself and the processing related to the argument with static code for specialization. However, it is not sufficient to specialize these processes. The reason will be described below.
That is, the technique of specializing the operation argument is effective when the same operation is repeatedly called more than a certain number of times in one request. However, in the remote service call, not only a case where the number of operations executed by one request is large, but also a request for the same operation may be repeatedly performed. Therefore, this method alone is not sufficient. Further, by specializing serialization / deserialization processing, the data transfer processing is speeded up, but the above two problems cannot be solved.

  The present invention has been made in view of the above circumstances, and specializes not only the operation argument itself and argument serialization processing, but also the operation execution processing, that is, an operation executed every time the operation is called. Accelerates processing by avoiding the process of generating objects that manage the objects required to call the server and messages sent to the server, and replacing the process that calls the service processing component with static code. An object of the present invention is to provide a service execution processing system in a distributed computing environment, a client device and program thereof, and a service execution processing method.

  In order to solve the above-described problems, the present invention provides a service execution processing system that obtains definition information about an interface each time a service is used in a distributed object environment, and calls and executes the service. When invoking an operation, there is provided means for generating a component specialized for the operation to be invoked, and means for executing the invocation of the operation using the generated component.

  In the present invention, when the same operation provided by the certain service is called, the generated component is reused.

  The present invention also provides a client apparatus in a service execution processing system that acquires definition information about an interface each time a service is used in a distributed object environment, and calls and executes the service, the service being defined by a certain interface description method Service processing component means for executing call processing, service factory means for acquiring definition information related to service call processing to be used, defined by the interface description method, and generating the corresponding service processing component, and the service factory Requesting the service processing component to be generated, receiving the service processing component generated by the service factory, and using the service processing component to A user client device issuing beauty, characterized by comprising a.

  Also, in the present invention, the service factory means obtains definition information related to a calling process of a service to be used defined by a certain interface description method, generates an object based on the obtained information, and depends on the interface description method. A specialized code for calling an operation is generated from a specific file in which a code part for calling is not written, the file is stored, the file is compiled, and the response is returned to the user client means.

  Further, in the present invention, a WSDL file in which service contents are described is analyzed to acquire necessary information, an EJB remote object is generated using the acquired information, and the acquired information and the WSDL are not dependent on. A special code for calling an operation is generated from a file in which the code is described (for example, a Java (registered trademark) file).

The present invention also provides an operation calling method in a service execution processing system that acquires definition information about an interface each time a service is used in a distributed object environment, and calls and executes the service, and the operation provided by the service When calling a component, a process for generating a component specialized for the operation to be called, and a step of calling the operation using the generated component are provided.

  The present invention also provides a program used in a service execution processing system that obtains definition information related to an interface each time a service is used in a distributed object environment, and calls and executes the service, and performs an operation provided by the service. When calling, it is characterized by causing a computer to execute processing for generating a component specialized for the operation to be called and processing for calling the operation using the generated component.

According to the present invention, the service processing component acquisition process takes time, but the service call processing time is shortened. Since the service processing component acquisition process is performed only once for a specific operation, it is particularly effective when the user client calls the specific operation frequently.
According to the present invention, the first use process takes time, but the second and subsequent use processes become faster. Therefore, when the same operation provided by a certain service is repeatedly used more than a certain number of times, it can be executed faster than the existing technology. For this reason, if the number of uses is less than or equal to the number of times that the present invention is effective, the service is executed using the same method as in the prior art. The overall processing time can be shortened compared to the case of using the dynamic binding process by.

  The existing dynamic binding implementation format is a method of preparing a processing module that can handle any service in advance, copying that module, and performing an operation according to the acquired definition information. This is effective when there are various types of services to be supported. However, when the same service is repeatedly executed, the same processing is performed every time it is executed, and there is a drawback that the overhead of the processing itself is large. The present invention provides a method for realizing dynamic binding that solves these drawbacks, and can achieve high processing performance.

FIG. 1 is a flowchart showing a remote call processing procedure according to the embodiment of the present invention. According to the embodiment of the present invention, not only the operation argument itself and the argument serialization process, but also the operation execution process is specialized.
In other words, it avoids the process of generating an object (hereinafter referred to as an operation object) necessary for invoking an operation and an object for managing a message sent to the server (hereinafter referred to as a message object) that is executed each time the operation is invoked. The processing speed of the processing is realized by replacing the processing that the service processing component calls the operation with a static code and specializing it. Therefore, not only the operation argument itself and argument serialization processing, but also the operation execution processing is specialized (S13). When calling the same operation, the class generated by specializing the operation execution processing is created. Two features of the reuse (S14) process are characteristic.

In order to realize the dynamic binding described above, the service interface and binding information are defined in a format that can be understood by the calling client (hereinafter referred to as the interface description format), and the client must have a mechanism that can execute the service using it. It becomes.
Currently, Web (World Wide Web) service technology widely used for building a distributed system environment includes WSDL (Web Services Description Language) which is a service interface description language. The contents of the Web service are described using WDSL. In addition, there is a WSIF (Web Services Invocation Framework) that reads an interface definition described in WDSL and dynamically calls an operation. When WSIF is used, when the user client call procedure is further detailed, three processes relating to generation of a value object to be set in the message object, generation of an operation object related to the operation to be called, and generation of the message object are performed.
Details of WDSL and WSIF are shown in the following URLs.
WDSL: http://www.w3.org/TR/wedl http://ws.apache.org/wsif/
WSIF: http://ws.apache.org/wsif/

2 and 3 show the configuration and execution procedure of the service execution client. For reference, the conventional example (FIG. 2) and the embodiment of the present invention (FIG. 3) are shown in comparison.
Each client 1 includes a service processing component 11, a service factory 12, and a user client 13.
The service processing component 11 is a part that implements service call processing defined in the interface description format, and the service factory 12 receives definition information related to the service call processing to be used, defined in the interface description method, and corresponds to it. This is the part that generates the service processing component. The user client 13 is an application application part that requests the service factory 12 to generate the service processing component 11, receives the service processing component 11 generated by the service factory 12, and uses it to call a service.
Reference numeral 2 denotes a server, which is a device that provides a service via a network.

The calling procedure of the user client is as follows. The service processing component acquisition process will be described.
The conventional example shown in FIG. 2 will be described. When the user client 13 does not hold the service processing component 11 that the user client 13 wants to use, the user client 13 transmits information related to the service call processing that the user client 13 wants to use to the service factory 12. The service factory 12 generates the service processing component 11 based on the received information and returns it to the user client 13. Subsequently, the service execution request process is performed. Whenever the user client 13 calls the service operation, the user client 13 uses the returned service processing component 11 to generate an object necessary for the service operation call and execute the service operation. call.

  According to the embodiment of the present invention shown in FIG. 3, the service processing component 11 is realized by a component specialized for only a specific operation without being implemented using a general-purpose component. The second and subsequent operation calls are executed by reusing this component. This eliminates the need to generate an object each time an operation is called, and avoids time-consuming processing in WSIF, which is the first problem. In addition, a component specialized for a specific operation that is used to call an operation can generate code for calling the operation directly and compile it without using reflection, which is a general-purpose call. Generated. Therefore, it is possible to avoid processing with a large processing overhead, which was the second problem.

Next, FIG. 4 shows a procedure for generating a service processing component for calling a Web service published by EJB (Enterprise JavaBeans) using the present invention.
Here, first, a given WSDL file in which service contents are described is analyzed, and necessary values such as a Home object name and a JNDI name are acquired (S121). Note that the definition information of EJB conforms to the specifications defined in WSIF. Next, an EJB remote object is generated using the acquired information (S122). Here, a specialized code for calling an operation is generated from the acquired information and a Java (registered trademark) file describing a calling code part that does not depend on WSDL, and is stored as a file (S123). Then, the file is compiled, a specialized class is generated (S124), the class is instantiated and returned to the user client (S125).

Note that an evaluation experiment was performed in order to quantitatively estimate the effectiveness with respect to the processing time when the WSIF according to the embodiment of the present invention was used.
Here, processing is performed with one argument, and an operation of a service realized by an object on the EJB service side is called, and the processing time is calculated from the average of the same operation call repeated 10,000 times. FIG. 5 shows a comparison of processing times. The argument is a character string length of 20000 bytes.
As is clear from the comparison table shown in FIG. 5, as a result of the evaluation experiment, according to the embodiment of the present invention, the processing time of the entire service execution request can be reduced to 50% of the existing method. In the embodiment of the present invention, the service processing component 11 acquisition process takes time, but the service call processing time is shortened. Since the service processing component 11 acquisition process is performed only once for a specific operation, it is effective when the user client 13 calls the specific operation at a high frequency.

As described above, the present invention dynamically generates a client specialized in operation execution processing in a distributed object environment, uses it, exists on a different computer, and is used via a network. A client system that calls various services is provided. In addition, when calling the same operation, it is possible to call the operation by reusing the object necessary to call the operation, which improves the performance by speeding up the service execution process. is there.
The procedure executed by each of the service processing component 11, the service factory 12, and the user client 13 shown in FIG. 3 is recorded on a computer-readable recording medium, and the program recorded on this recording medium is read into a computer system. The service execution processing system and the client device of the present invention can be realized by executing and executing. The computer system here includes an OS and hardware such as peripheral devices.

Further, the “computer system” includes a homepage providing environment (or display environment) if a WWW system is used.
The program may be transmitted from a computer system storing the program in a storage device or the like to another computer system via a transmission medium or by a transmission wave in the transmission medium. Here, the “transmission medium” for transmitting the program refers to a medium having a function of transmitting information, such as a network (communication network) such as the Internet or a communication line (communication line) such as a telephone line.
The program may be for realizing a part of the functions described above. Furthermore, what can implement | achieve the function mentioned above in combination with the program already recorded on the computer system, and what is called a difference file (difference program) may be sufficient.

  The embodiment of the present invention has been described in detail with reference to the drawings. However, the specific configuration is not limited to this embodiment, and includes design and the like within the scope not departing from the gist of the present invention.

It is a figure which shows the remote call processing procedure which concerns on embodiment of this invention. It is a figure which shows the structural example of the conventional service execution processing system. It is a figure which shows the structural example which concerns on this invention embodiment. It is a figure which shows the production | generation procedure of the service processing component which concerns on this invention embodiment. The evaluation table | surface which contrasted and showed the performance of this invention embodiment and a prior art example is shown. It is a figure which shows the remote processing procedure of a prior art example. It is a figure which shows the remote processing procedure of a prior art example. It is the figure quoted in order to demonstrate the method of specializing an argument. It is the figure quoted in order to demonstrate the method of specializing the serialization of an argument object, or deserialization.

Explanation of symbols

DESCRIPTION OF SYMBOLS 1 ... Client, 2 ... Server, 11 ... Service processing component, 12 ... Service factory, 13 ... User client

Claims (7)

In a distributed object environment, a service execution processing system that acquires definition information about an interface each time a service is used, and calls and executes the service,
Means for generating a component specialized for the operation to be called when the operation provided by the service is called;
A service execution processing system comprising means for calling the operation using the generated component.   The service execution processing system according to claim 1, wherein the generated component is reused when calling the same operation provided by the certain service. In a distributed object environment, a client device in a service execution processing system that acquires definition information about an interface each time a service is used, and calls and executes the service,
Service processing component means for executing service invocation processing defined by a certain interface description method;
Service factory means for obtaining definition information related to service call processing to be used, defined by the interface description method, and generating the corresponding service processing component;
User client means for requesting the service factory to generate the service processing component, receiving the service processing component generated by the service factory, and calling the service using the service processing component;
A client device comprising: The service factory means includes
A specific information describing a code part for a call that does not depend on the interface description method, by obtaining definition information related to a call process of a service to be used defined by a certain interface description method, generating an object based on the acquired information 4. The client apparatus according to claim 3, wherein a specialized code for invoking an operation from the file is generated, the file is saved, the file is compiled, and the response is returned to the user client unit.   A file in which a WSDL file in which service contents are described is analyzed to acquire necessary information, an EJB remote object is generated using the acquired information, and the acquired information and code not dependent on the WSDL are described The client device according to claim 4, wherein a specialized code for invoking an operation is generated from the client device. In a distributed object environment, a method for calling an operation in a service execution processing system that acquires definition information about an interface each time a service is used and calls and executes the service,
Generating a component specialized for the operation to be invoked when the operation provided by the service is invoked;
Performing a call to the operation using the generated component;
An operation calling method in a service execution processing system characterized by comprising: In a distributed object environment, a program used in a service execution processing system that acquires definition information about an interface each time a service is used and calls and executes the service,
When calling an operation provided by the service, generating a component specialized for the call operation;
Processing to call the operation using the generated component;
A program that causes a computer to execute.

Images