JP2000112759A - Static analyzing method and optimizing method of program in distributed object environment - Google Patents

Abstract

PROBLEM TO BE SOLVED: To reduce a communicating amount between a client and a server by securely extracting an executable part only on a client side and also moving the executable part to the client side. SOLUTION: Concerning an object program arranged at a computer on the client side and an object program arranged at a computer on a side to be called, the part which can independently be executed by only the computer on the client side is judged by annotation and propagation with a static analyzing device 103. In addition to it, a part of the object program which can independently be executed by only the computer on the client side is moved to the computer on the client side.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a method for static analysis and optimization of a program in a distributed object environment.

[0002]

2. Description of the Related Art Conventionally, a client computer calls object programs distributed on a plurality of computers connected via a network.
2. Description of the Related Art A computer system in a distributed object environment that performs processing in cooperation with an object program arranged on a client computer is known.

[0003]

SUMMARY OF THE INVENTION A distributed processing environment, in particular C
In a distributed object environment typified by ORBA, an inquiry about the location of a program required on the client side is made to the server side, so that the communication between the client and the server tends to increase as compared with a normal client-server system. Is remarkable. This is a factor that degrades the performance of the entire system. For this reason, reducing unnecessary client-server communication has become an important issue.

In the distributed object environment, libraries of the distributed framework are used, and in these libraries, simple processing such as outputting a NOP (processing that does nothing) and a message is frequently used. This is because emphasis is placed on interface consistency with relational processing in the library and expandability in the future. The execution itself of these processes is performed instantaneously on the server side, but is called from the client side through the network.

For example, consider a case where a class hierarchy as shown in FIG. 10 is defined. “Class B” 1001, “Class C” 1002 have “method m” 1003, 100
4 is defined. When the class designer determines that “method m” is a method that should be generally defined in this class hierarchy, “parent class A” 1005
Also, “method m” 1006 is defined as a virtual method.

Although "method m" is not required for "class D" 1007, "method m" 1008 without a method definition body is provided because the interface must be the same as "parent class" 1005. . Also,
In the creation of "Class E" 1009, the designer wants to write a full-fledged method in the future, but prints a character string "Not supported" as a message to the effect that it is not yet supported. A simple “method m” 1010 is implemented.

Now, it is assumed that a client server system based on the distributed object technology is constructed as shown in FIG. In such a system, since the system is constructed based on network-transparent objects that do not make the client and server aware of the location, calls across networks are frequently used, and emphasis is placed on maintainability and expandability. Therefore, there is a need for a method (1008) having no definition body as described above and a method (1010) as simple as printing a message.

For example, when there is a processing code 1101 in FIG. 11, "foo" 1102, "bar" 1
103 and “baz” 1104 are sequentially called, and these are respectively called server-side methods “foo”.
_Impl ”1105,“ bar_impl ”110
6, “baz_impl” 1107 is called for processing. However, “foo_impl” 1105 is a method without an execution body, and the control is immediately returned to the client side. Therefore, “foo” 1102
The processing takes time because of the overhead of the call to the “foo_impl” 1105 via the network.

From “bar” 1103 to “bar_imp”
The same applies to the call to "1" 1106, in which server-client communication is performed merely to print a determined character string.

Therefore, these method definitions “foo_
“impl” 1105 and “bar_impl” 1106 to the client side “foo” 1102
If it is moved to “bar” 1103 and rewritten as a call as shown in FIG. 12, “foo” 1202, “bar” 12
In 03, no call to the server side occurs and “baz” 1
As in the case of calling “baz_impl” 1205 from 204, communication between networks can be performed only when processing on the server side is actually required.

In general, such rewriting can be performed if there is a server-side method whose specific processing content is known in advance. For this purpose, it is necessary to determine in advance which part of the server-side method can be calculated, but this has not been realized in the past.

A first object of the present invention is to provide a method for static analysis of a program in a distributed object environment in which a portion executable only on the client side can be accurately extracted. A second object of the present invention is to provide a program in a distributed object environment in which a portion that can be executed only on the client side is moved to the client side to reduce the amount of communication between the client and the server and improve the system throughput. To provide an optimization method.

[0013]

In order to achieve the above object, a method for static analysis of a program in a distributed object environment according to the present invention comprises a method for locating an object program located on a client computer and a method for locating the object program on a called computer. With respect to the set object program, a part which can be independently executed only by the client computer is determined by a static analyzer by annotating and propagating the object program.

Further, the method of optimizing a program in a distributed object environment according to the present invention provides a method for optimizing an object program arranged on a client computer and an object program arranged on a called computer by annotating and propagating the annotation. After a part which can be independently executed only by the client computer is determined by the static analyzer, a part of the object program which can be independently executed only by the client computer is moved to the client computer.

[0015]

Embodiments of the present invention will be described below in detail with reference to the drawings. FIG. 1 is a functional configuration diagram showing a basic configuration of the present invention. As shown in FIG. 1, a client-side source program 101 and a server-side source program 102 are applied to a static analyzer 103, and the server-side source program 102 Among them, a portion 104 that can be executed only on the client side and a call on the client side that calls the portion 104 are found, and a client side program 105 and a server side program 106 including these information as annotations are generated. , The part 104 executable on the client side is moved to the method side called on the client side.

Next, an algorithm for determining a portion that can be executed (evaluated) with respect to a given program will be described with reference to FIG. 2, FIG. 3, and FIG. In the initial annotation step 201 of the algorithm shown in FIG. 2, information on the client side, that is, all variables and functions defined on the client side can be evaluated. In addition, it is determined that a portion having a direct value such as a character string, a character, or a numerical value can be evaluated. In addition, if there is input data given to the program, an execution environment, or the like whose values are already known from the beginning, it is determined that the variables holding those values can be evaluated. At the initial stage, it is determined that variables other than these, the result of the method call, and the like cannot be evaluated.

A program fragment determined to be evaluable is annotated with s, and a program fragment determined to be unevaluable is annotated with d. In this way, the initial value of the environment "env" at the time of annotation is determined (step 202).

Next, the entire program is annotated based on the initial environment. This annotation continues until no further annotations are made (step 20).
3). In order to determine the end of the repetition, the annotation of the previous stage is first set to “old_program” (step 204), and then the subroutine “prop”
"aggregate" to advance the annotation of the entire program one step (step 205). The finally annotated program is returned as a return value (step 50)
6).

The definition (207) of the subroutine "propagate" is, as shown in FIG.
"agate" takes a program p as an argument and repeatedly performs the following two processes for each method of p (step 2).
08). First, a method call in the program is examined to determine whether each argument has an annotation of s or d. From the analysis of this method call, an annotation of s or d is attached to each argument of the method definition. When there are a plurality of calls to the same method, only the argument having the annotation of s is regarded as s, and the argument having at least one annotation of d is regarded as d. Also, in an object-oriented program, the definition entity may be different for each type of class defined even for a method having the same name. In such a case, an annotation similar to a normal method is performed only when the type information of the defined class has an annotation of s, and otherwise, an annotation of d is performed.

After the method arguments have been annotated in this way, the method definition body is evaluated and s or d is annotated (step 209). A new environment "env '" is created based on the result of the annotation on this parameter. Then call the subroutine list annotation,
An environment "e" that combines "env '" and the original environment "env"
Based on "nv'Uenv", the method body is annotated (step 210).

As shown in FIG. 3A, the annotation of the list is realized by calling another subroutine "annotation" for the execution statement s which is a component of the list (step 311; 312).

In the subroutine "annotation" of step 312, as shown in FIG. 3B, each annotation is performed according to the type of the execution statement s (steps 313 and 31).
4, 315, 316). In particular, when s is a variable v,
As shown in FIG. 4B, annotation of s or d is performed based on whether or not v appears in the environment “env” (step 4).
11, 412, 413). Note that FIG.
It is a detail of step 316 of (b). In the above processing, the part annotated with s can be finally evaluated.

The above method is simple in principle, but is inefficient because the whole program is repeatedly analyzed at each stage. Therefore, focusing on the fact that the portion once annotated s is not changed to d, a more efficient algorithm is shown in FIGS. 5 and 6. The outline is similar to the algorithm of FIGS. 2 to 4, but it is determined whether or not the annotation has been changed from d to s by “fl”.
ag ”, and only when the“ flag ”becomes true, the data is propagated.

First, "flag" is changed to "falses".
e "(step 501). Next, after constructing an initial environment (step 502), a loop is entered (step 503). If "flag" is rewritten in the processing body of the loop, the loop is continued. Otherwise, the process exits the loop and returns a result (step 504). Subroutine propagate called in the processing body of this loop
At the time of annotating the inside and each execution part (step 505), a check of “flag” is performed (FIG. 6).
(Step 601 of (c)), only when “flag” is true, substantial processing is performed. When annotating a variable, the annotation may change to s, and at this time, “flag” is rewritten (step 602 in FIG. 6D).

FIG. 7 illustrates the movement of the method definition. The method call “bar” 701 annotated with s is moved to the client side by the above procedure (7
03), embed the program on the client side,
ar ”702. This eliminated the method call from the client to the server via the network.

Here, in FIG. 7, the program is simply moved to the client side, but this allows the same data to be copied to a plurality of clients. As a result, this may be used when the size of the calculated data is small. However, when the size of the calculated data exceeds a certain value, the space efficiency of the entire system is reduced. For example, as shown in FIG. 8, when “foo” 801 and “bar” 802 call the same method “foobar” 803 on the server side, and when there are hundreds of processing entities, the client side Copies of this several hundred lines of code can be made in two places, and space efficiency is poor. This problem can be solved by installing the intermediate server 901 near the client as shown in FIG. 9 and moving “foobar” 902 there.

When the intermediate server 901 is installed as described above, the following improvement can be further performed. First, clients whose services are shared by the intermediate server are c1,. . , Cn. In the initial annotation of the annotation algorithm, instead of simply determining the information known by one client ci as s, c
1,. . , Cn if it is known, it is determined to be s, and by applying the algorithm shown in FIG. 2 to FIG. It is possible to move to the server and make the processing more efficient.

[0028]

As is apparent from the above description, according to the present invention, a portion that can be executed only on the client side can be accurately extracted. In addition, a portion that can be executed only on the client side is moved to the client side to reduce the amount of communication between the client and the server, thereby improving the system throughput. Further, the use of the intermediate server has an effect that a decrease in space efficiency can be avoided.

[Brief description of the drawings]

FIG. 1 is a functional configuration diagram showing a basic configuration of the present invention.

FIG. 2 is a PAD diagram showing an annotation algorithm.

FIG. 3 is a PAD diagram showing the algorithm following FIG. 2;

FIG. 4 is a PAD diagram showing the algorithm following FIG. 3;

FIG. 5 is a PAD diagram showing another example of an annotation algorithm.

FIG. 6 is a PAD diagram showing the algorithm following FIG. 5;

FIG. 7 is an explanatory diagram showing movement of a program code according to the present invention.

FIG. 8 is an explanatory diagram showing an example in which an intermediate server is introduced.

FIG. 9 is an explanatory diagram showing a program arrangement after the introduction of the intermediate server.

FIG. 10 is a diagram illustrating an object environment showing a typical situation where a problem to move a program occurs.

FIG. 11 is an explanatory diagram showing a program arrangement in a conventional object environment.

FIG. 12 is an explanatory diagram when the arrangement of programs is moved.

[Explanation of symbols]

101: Client-side source program, 10: 2
Server-side source program, 103 ... sexual analyzer, 1
04: executable part, 107: distributor, 901: intermediate server.

Claims (4)

[Claims] 1. A distributed object environment in which an object program distributed on a plurality of computers connected via a network is called from a client computer and a process is performed in cooperation with the object program disposed on the client computer. In a computer system, static analysis of an object program located on the client computer and an object program located on the called computer by annotating and propagating the part that can be executed independently on the client computer only. A static analysis method of a program in a distributed object environment, characterized in that the determination is performed by a device. 2. The method according to claim 1, wherein the part which can be independently executed only by the client computer is determined by changing the annotation of the part which can be independently executed only by the client computer and propagating the annotation. Static analysis method of program in distributed object environment. 3. A distributed object environment in which an object program distributed on a plurality of computers connected via a network is called from a client computer, and processing is performed in cooperation with the object program disposed on the client computer. In a computer system, static analysis of an object program located on the client computer and an object program located on the called computer by annotating and propagating the part that can be executed independently on the client computer only. A part of the object program that can be independently executed only by the client-side computer after the determination by the client-side computer is transferred to the client-side computer. Optimization method of the program in object environment. 4. When a plurality of computers are designated as client computers, a part which can be independently executed by only the local information held by them is determined by a static analyzer, and the code of the executable part is replaced by A method of optimizing a program in a distributed object environment, comprising moving to a computer located between a called computer and a plurality of calling client computers.