WO2004086243A1

WO2004086243A1 - Script execution method and server-client system

Info

Publication number: WO2004086243A1
Application number: PCT/JP2004/004014
Authority: WO
Inventors: Hirohisa Mori
Original assignee: Toudai Tlo, Ltd.
Priority date: 2003-03-25
Filing date: 2004-03-24
Publication date: 2004-10-07
Also published as: JP2004295262A

Abstract

There is provided a technique for effectively executing a script. A first script requesting a process in a first server is executed by a client terminal (step 2-1). An interpreter of the client terminal generates a mark before a process result is returned from the first server and stores it in a data storage section (step 2-2). When the mark is returned, the script of the client terminal temporarily handles the mark as a result from the server. Subsequently, the client terminal executes a second script requesting a second server to execute a process (step 2-3). Since the mark has been generated as a temporary result, the client terminal can execute the second script before the actual result is returned from the first server. When the actual result corresponding to the mark is returned from the server, the client terminal replaces it with the mark and executes the script.

Description

Description Script execution method and server / client system

Technical field

TECHNICAL FIELD The present invention relates to a method for executing a script.

Background of the Invention

In the server / client system, rendezvous is performed by a script on the client or server. Rendezvous means that the client terminal waits until the server receives a request from the client terminal and returns the execution result. With this rendezvous, the execution operations of the server and client terminal can be synchronized. When performing such a rendezvous, the execution of the script will wait for a long time due to the communication overhead of the network. For this reason, the script execution efficiency of the conventional system may be very low.

For example, consider a situation in which client C rendezvous with servers S, T, and U. Run the following script on client C.

(fonc

(remote S (rv-S)),

(remote T (rv-T))

(remote U (rv-U)))

When this script is interpreted in applica-teip order, the execution order is as follows.

1. Run rv-S on server S and get the result. The execution time including the network is d-S.

2. Run rv-T on server T and get the result. Similarly, let the execution time be d-T.

3. Execute rv-U on server T and get the result. Similarly, let the execution time be d-U.

4. Give the above three results to fonc and get the result. Its execution time (Lfonc). The time required for all of these processes is

d_S + d—T + d_U + d_iunc

It becomes.

However, during time d—S + d—T + d—U, server-side processing is performed, and client C is almost idle. "Disclosure of the Invention

The present invention has been made in view of the above circumstances. An object of the present invention is to provide a technique for efficiently executing a script.

The script execution method according to the present invention includes the following steps:

(1) a step in which a client terminal executes a first script requesting processing in a first server;

(2) a step in which the client terminal generates and stores a mark before a processing result is returned from the first server;

(3) a step in which the client terminal executes, after the step (2), a second script requesting the second server or the client terminal itself for processing;

(4) After the processing results for the first and second scripts are returned to the client terminal, the client terminal executes a third script using these processing results.

A method for performing a scribing according to the present invention may include the following steps:

(1) a step in which the first server executes a first script requesting processing in the second server sent from the client terminal;

(2) a step in which the first server generates a mark before a processing result is returned from the second server, and stores the mark in a data storage unit in the first server;

(3) A step in which the first server executes a second script sent from the client terminal and requesting processing in the third server or the first server itself. A system according to the present invention includes a client terminal, a first server, and a second server. In addition, the client terminal performs the following steps Is:

(1) executing a first script requesting a process in the first server;

(2) a step of generating and storing a mark before the processing result is returned from the first server;

(3) After the step (2), executing a second script requesting the second server or the client terminal itself for processing;

(4) A step of executing a third script using the processing results after the processing results for the first and second scripts are returned to the client terminal.

Another system according to the present invention includes a client terminal, a first server, a second server, and a third server, wherein the first server performs the following steps:

(1) executing a first script sent from the client terminal and requesting processing in the second server;

(2) generating a mark before returning a processing result from the second server, and storing the mark in a data storage unit in the first server;

(3) a step of executing a second script sent from the client terminal and requesting processing on the third server or the first server itself.

In this system, the second server and the third server may be the same server.

The client terminal according to the present invention performs the following steps:

(1) Step of executing a first script requesting processing on the first server

(2) Step of generating and storing a mark before the processing result is returned from the first server

(4) The processing results for the first and second scripts are After returning to the end, a step to execute a third script that uses these processing results.

The first server according to the present invention performs the following steps:

(1) executing a first request sent from a client terminal requesting processing in a second server;

(2) generating a mark before the processing result is returned from the second server and storing the mark in the data storage unit of the first server;

(3) A step of executing a second script sent from the client terminal and requesting a process in the third server or the first server itself.

The client terminal program according to the present invention executes the following steps:

(1) Step of executing a first script requesting processing on the first server

(2) Step of 'generating and storing a mark before the processing result is returned from the first server

(3) After the step (2), a step 'executing a second script requesting the second server or the client terminal itself for processing';

(4) A step of executing a third script using these processing results after the processing results for the first and second scripts are returned to the client terminal.

The first server program according to the present invention executes the following steps:-

(1) executing a first script sent from a client terminal and requesting processing in a second server;

(3) a step of executing a second script sent from the client terminal and requesting processing on the third server or the first server itself. BRIEF DESCRIPTION OF THE FIGURES

FIG. 1 is a block diagram showing a schematic configuration of a server-client system according to the first embodiment of the present invention.

FIG. 2 is a flowchart for explaining a method of executing the scribing in the first embodiment.

FIG. 3 is an explanatory diagram for explaining a script execution method according to the first embodiment.

FIG. 4 is a block diagram showing a data storage unit in the server / client system according to the second embodiment of the present invention.

FIG. 5 is a flowchart for explaining a script execution method in the second embodiment.

FIG. 6 is an explanatory diagram for explaining a script execution method according to the second embodiment. BEST MODE FOR CARRYING OUT THE INVENTION

(First Embodiment: Corresponding to Claim 1)

A method for executing the scribing according to the first embodiment of the present invention will be described below. Here, the script refers to a program that is interpreted and executed on the server or client terminal, regardless of its length or language. First, the client's server system used in this method will be described with reference to FIG. This system includes a client terminal C, a server S, a server T, a server U, and a network N connecting these.

The client terminal C includes a control unit 10, a storage unit 11, an interface unit 12, and a network interface unit 13. The storage unit 11 includes a program storage unit 111 and a data storage unit 112.

The control unit 10 performs an operation according to a program stored in the program storage unit 11.

The program storage unit 111 stores an interpreter for the client terminal and other programs necessary for the operation of the client terminal. Program behavior The work will be described later. The data storage unit 112 stores data such as marks generated during execution of a script (described later).

The interface unit 12 connects the input / output devices. The input / output device is, for example, a display or a printer / keyboard.

The network interface section 13 is a section for connecting the client terminal C to the network N.

The server S has a control unit 20, a storage unit 21, and a network interface unit 23. The control unit 20 performs an operation according to the program stored in the program storage unit 211.

The storage unit 21 includes a program storage unit 211 and a data storage unit 212. The program storage unit 211 stores an interpreter for the server S and other programs necessary for the operation of the server S. The operation of the program will be described later. The data storage unit 212 stores data such as marks generated in execution of a script (described later).

The network interface section 23 is a section for connecting the server S to the network N.

The server S may further include an interface unit.

Each of the server T and the server U has a control unit 30.40, a storage unit 31.41, and a network interface unit 33.43. The storage unit 3 1 · 4 1 includes a program storage unit 3 1 1-4 1 1 and a data storage unit 3 1 2 · 4 1 2. The program storage unit 3 1 1 · 4 1 1 1 stores an interpreter for each server and other programs necessary for the operation of the server. Other configurations are basically the same as those of the server S, and therefore, detailed description is omitted.

The above-described client terminal C and servers S, T, and U can be configured using appropriate peripheral devices.

The network N is an appropriate communication network for the components such as the client terminal C and the server S to communicate with each other, and is, for example, the Internet. However, the network N may use a protocol other than TCP / IP. Next, a method of executing a script using the system will be described. The execution of this script is performed by a program (interpreter) stored in the client terminal C and the server S, τ, υ.

As a specific example of the script,

(func

^ remote S urv-S))

^ remote T (rv-T))

(remote U (rv-U)))

Suppose that Assume that this script is input to client terminal C. Client terminal C evaluates this script using the interpreter and performs the following operations.

The client terminal C executes a first script (remote S (rv-S)) requesting processing on the server S (first server) (step 2-1 in FIG. 2). ) Is sent, and this command is executed on server S (step 2_2).

On the other hand, the client terminal C generates a mark and stores it in the data storage unit 112 before the processing result is returned from the server S (first server) (step 2-2). That is, as soon as you run the first script, the interpreter returns the mark. At this time, it is preferable to store the mark and the server in association with each other. Either of the mark generation and the script transmission to the server S may be performed first. A mark is data defined by a data type meaning a provisional result. That is, the interpreter defines such a data type. Such a data type can be defined similarly to, for example, an integer type or a real number type. When the mark of the client terminal C returns the mark, the script is tentatively handled as a result from the server S. After the step 2-2, the client terminal C requests the server T (the second server) to perform processing. 2 Execute the script (remote T (rv-T)) (Step 2

— 3). The second server may be the same as the first server. Further, the second script may be executed by the client terminal C itself to calculate the result. Since the mark is generated as a provisional result, such processing is possible. Then, before returning the processing result from the server T (second server), the client terminal C generates a mark in the same manner as described above and stores it in the data storage unit 112 (step 2-4). Either of the mark generation and the script transmission to the server S may be performed first.

In this embodiment, the client terminal C further executes a third script (remote U (rv-U)) that requests the server U (second server) to perform processing. Then, similarly to the above, the client terminal C generates a mark before storing the processing result from the server U, and stores the mark in the data storage unit 112.

Then, after the processing results for the first to third scripts are returned to the client terminal C, each result is replaced with the mark stored corresponding to each server. Next, the client terminal C executes a third script (func) using the processing results. Thereby, the entire script described above can be executed. Since the mark is a data type indicating temporary data, the interpreter waits for the processing of the third script until the actual result is returned. Further, after executing the third client, the client terminal C outputs the result to the interface section 12. In the conventional execution method, the processing on the server T is performed after the processing on the server S is completed, and then the processing on the server U is performed. Therefore, the total processing time of the processing time at each server and the processing time at the client terminal using the result at each server is the processing time of the script.

On the other hand, according to the method of this embodiment, the client terminal C can immediately proceed to the processing of the next script after generating the mark. For this reason, it is possible to significantly reduce the processing time of the scribing. The processing time of scribing is conceptually explained with reference to FIG. As described above, the script processing request is transmitted from the client terminal C to each server. The processing time (including communication overhead) at the server S is defined as time d_S. Similarly, the processing time at server T is time d_T, and the processing time at server U is time d_U. Furthermore, the processing time at the client terminal is set to time d_func. Conventionally, the total processing time is d_S + d_T + d_U + d-func Met. 'However, in this embodiment, the total processing time is

max (d-S + d-T + d_U) + d „func

It becomes. If the execution time of the script on each server is almost the same and the time d_func is negligible, the execution time will be about one-third compared to the past. ·

(Second embodiment ... corresponding to claim 2)

Next, a method for executing a script according to the second embodiment of the present invention will be described. In this method, the same system as in the first embodiment is used. However, it is assumed that queues 2 12 a and 2 13 a are mounted in the data storage units 2 12 and 2 13 of the servers S and T. The other configuration is the same as that of the first embodiment, and the description is omitted by using the same reference numerals.

The second embodiment mainly relates to the operation of the server S. First, assume the following script. The script definition on server S is

(Define grvl— 1 some-sequence and

return (remote T (rv2 ~ l)))

(Define (rvl-2) some-sequence and

return (remote T (rv2 ~ 2)))

Assume. Here, some-sequence means any script executed on the server side. On the server, usually after such an arbitrary script is executed, the script after the return instruction is executed.

Further, Client C executes the following script.

(func

(remote S (rvl-1))

(remote S (rvl-2)))

In this state, server S and server T are cascaded. Further, the client terminal C executes the same method as in the first embodiment. In the following description, FIG. 6 showing the operation on the network and FIG. 5 mainly showing the operation of the super S will be mainly referred to. Further, in the following description, the description will be given for each step in FIG. (Step H in Fig. 6)

First, the client terminal C executes the script (remote S (rvl-1)) and sends the script (rvl-1) to the server S. At this time, the client terminal C generates a mark in the same manner as in the first embodiment. Subsequently, the client C executes (remote S (rvl-2)) to generate a mark in the same manner as in the first embodiment, and then sends the client (rvl-2) to the server S.

(Step I in Figure 6)

Server S (first server) receives the script (rvl-1) sent from client terminal C and requesting processing at server T (second server) (Step 5-1 in Fig. 5). ). The script (rvl-1) includes, in its definition, (remote T (rv2-l)) corresponding to the first script of the present invention. Further, the server S (first server) receives the second script (rv2) requesting the processing in the server T (third server) sent from the client terminal C (step 5—). 1). The script (rvl-2) includes, in its meaning, (remote T (rv2-2)) corresponding to the second script of the present invention. In this embodiment, the third server in the present invention is the server T as in the second server, but the third server may be the server U or another server. Also, the second script may be a server that processes itself and calculates the result.

Next, the server S executes the script (rvl-1). Thus, in this embodiment, the server S first executes the script described in some-sequence (step 5-2). Thereafter, the server S executes the first script (remote T (rv2-l)), sends the script (rv2-1) to the server T, and requests the server T to perform the processing (step 5-3). The execution of the first scrivet may be performed before the receipt of the second scrivet.

Further, the server S (first server) generates a mark before returning the processing result corresponding to the first client from the server T (second server), and stores the mark in the data storage unit 2 in the first server. It is stored in the queue 2 1 2 a of step 1 2 (step 5-1 3). This operation may be performed before or after sending the script to the server T. (Step J in Figure 6)

After that, the server T executes the script (rv2-1).

(Step K in Fig. 6)

Next, the server S executes the second script (rvl-2). Thus, in this embodiment, the server S executes the script described in some-sequence (step 5-4). After that, the server S executes the second script (remote T (rv2-2)), sends the script (rv2-2) to the server T, and requests its processing (step 5-5). In this embodiment, since the mark is stored in the queue 211a, the server S can execute the second script even before the processing result in the server T is returned. Thereby, the waiting time in the server S is reduced, and the processing time can be shortened.

(Step L in Fig. 6)

After that, the processing result of the script (rv2-l) is returned from the server T (second server) to the server S (first server) (step 5-6). That is, server S receives the processing result of server T. Next, the server S replaces this processing result with the mark stored in the queue 211a, and executes an instruction (return). As a result, the server S sends the result of the first script to the client terminal C (Step 5-7).

(Step M in Fig. 6)

When the processing result of the script (rv2-2) is returned from the server T (third server), the server S replaces the processing result with the mark stored in the queue 212a as described above. And send it to client terminal C.

(Step N in Fig. 6)

When the actual result corresponding to the mark generated by the client terminal C returns from each server, the client terminal C executes the script (func) and outputs the result to the interface unit 12 (steps 5-8). .

When the method of the first embodiment is applied to the cascade, the server S cannot shift to the processing of the second script until the processing of the first script ends. This is the server

The mark used until the processing result returns from T is tentative data only. Is not returned to the client terminal C. On the other hand, according to the method of the second embodiment, as described above, before the processing of the first script ends, the server S can shift to the processing of the second script. Therefore, there is an advantage that the processing time of the script can be reduced. Note that the descriptions of the above embodiments and examples are merely examples, and do not show configurations essential to the present invention. The configuration of each section is not limited to the above as long as the purpose of the present invention can be achieved. For example, there may be multiple client terminals. Further, the number of servers may be large.

In addition, the components in each of the above-described embodiments may exist as functional components. One functional element may be integrated with another element, or one element may be realized by a plurality of components / software. Further, as a method of realizing the functional elements, hardware or computer software may be used. Further, the connection form between the functional elements may be via a network. That is, a plurality of functional elements may exist at positions separated from each other. Industrial potential

According to the present invention, it is possible to execute a script efficiently.

Claims

The scope of the claims

1. How to run a script with the following steps:

(1) a step in which the client terminal executes a first script requesting processing in the first server;

(2) the client terminal generates and stores a mark before a processing result is returned from the first server;

(3) after the step (2), the client terminal executes a second client requesting a process to the second server or the client terminal itself;-

2. How to run a script with the following steps:

(1) the first server executing the first script sent from the client terminal and requesting the processing in the second server;

(2) a step in which the first server generates a mark before returning a processing result from the second server and stores the mark in a data storage unit in the first server;

(3) a step in which the first server executes a second script sent from the client terminal and requesting processing in the third server or the first server itself.

3. A system comprising a client terminal, a first server and a second server, wherein the client terminal performs the following steps:

(1) a step of executing a first script requesting a process in the first server;

(2) generating and storing a mark before a processing result is returned from the first server;

(4) After the processing results for the first and second scripts are returned to the client terminal, a step of executing a third script using these processing results is performed. H.

4. A system comprising a client terminal, a first server, a second server and a third server, wherein the first server performs the following steps:

(2) generating a mark before returning a processing result from the second server and storing the mark in a data storage unit of the first server;

5. The system according to claim 4, wherein the second server and the third server are the same server.

6. Client terminal that performs the following steps:

(1) Step of executing a first script requesting processing on the first server

7. First server that performs the following steps:

(2) generating a mark before returning a processing result from the second server and storing the mark in a data storage unit in the first server;

8. Client terminal program that performs the following steps: (1) Step of executing a first script requesting processing on the first server

9. First server program that performs the following steps: