JPH10207722A - Method and device for dividedly executing program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To execute efficient load dispersion by providing a server computer with a recognition program for checking whether an API function is a function having a result related to a client computer or not. SOLUTION: When an application program 43 executes an API function in a library 44, the API function is sent to a program 48 for discriminating the type of the API function in the library 44. When it is judged that the received function is an API function having a result related to the client computer, the program 48 sends the API function to an window client 46. In the other case such as system service, the API function is executed on an AP stack. When the API function related to man-machine interface processing is selected and executed by access terminals 10, 20, the function can be executed so as to be automatically divided on two computers.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a computer system in which a plurality of low-cost multimedia-compatible client computers share a plurality of server computers, and in particular, divides a single program into two programs, each of which is a client computer. And divided execution of a program executed on the server computer and load distribution of the server computer.

[0002]

2. Description of the Related Art As a method of executing programs of a client computer and a server computer, a method using an "X window" is known (Adrian Nye, "Xlib Programmin").
g Manual for Version II, Volume One, "O'Reilly & A
ssociates, Inc., pp. 3-51).

In a program execution method using an X window, a client computer (X terminal) and a server computer at hand of a user are used. The server computer is connected to the X terminal via a network. The server computer executes the data processing part of the program, and the X terminal executes the man-machine interface processing part of the program. The program on the server computer performs man-machine interface processing by communicating with the X server running on the X terminal using the X library (Xlib). The X server transmits data input from an input device such as a mouse or a keyboard on the X terminal to the server computer, and passes the input data to a program executed on the server computer. The program running on the server transmits the execution result of the program to the X terminal, and the X server on the X terminal outputs the execution result to an output device such as a monitor. In this way, the program is executed using both the X terminal and the server computer.
Note that files used by the program are stored in an auxiliary storage device such as a disk of the server computer.

[0004] As a method of distributing the load of a server computer, a Task Broker of HP is known. When requested to execute a program from a client computer, the task broker temporarily places the program in a queue. Next, a computer with a small load is selected from the computers on the network, and the program at the head of the queue is executed on the computer.

[0005] Also, as a load distribution method of a server computer, a Load Leveller of IBM Corporation is known. When parallel processing is performed using a plurality of computers, a program usually realizes the parallel processing by generating a plurality of processes and threads and executing the processes and threads on different computers. Load Leveller selects multiple computers with a light load and runs processes and threads in parallel on those computers.

[0006]

According to the above-mentioned conventional technique using an X window, in order for an X server on a client computer to output data sent from a server computer, a program on the server computer needs to execute an X library. It is necessary to send data to the client computer using (Xlib). For example, to display a moving image file on a server computer on an X terminal, a program on the server computer reads the moving image file, creates bitmap data of each frame of the moving image from the file, and sends it to the X terminal. There is a need to. Therefore, in the server computer, data copy occurs between the memory space of the operating system and the memory space of the application program twice when reading the file and when sending the bitmap data to the X terminal. Is reduced. In addition, when transmitting an image using the current X library, it is necessary to transmit bitmap data, which causes a problem that network traffic between the X terminal and the server computer increases.

[0007] According to the above-mentioned conventional technology using Task Broker or Load Leveller, batch processing and parallel processing are targeted. Therefore, there is a problem that it cannot be used for interactive processing using a GUI like a PC.

An object of the present invention is to solve the above-mentioned problems and to provide a method of dividing and executing a program of a client computer and a server computer capable of outputting multimedia data such as a moving image or audio with high performance; An object of the present invention is to provide a load balancing method of a server computer suitable for interactive processing.

[0009]

In order to achieve the above object, according to the method of dividing and executing a program and distributing a load according to the present invention, the API function is, for example, a man-machine interface process, a multimedia process, a client computer, or the like. The server computer is provided with a recognition program for checking whether or not the function has a result related to the client computer, such as the display processing in the above or the compressed data processing. Also, if the API function is a function having a result related to the client computer,
It has a window client program that sends API functions to the client computer. Further, the server computer
It has a server computer management table for managing the CPU load, CPU performance, memory capacity, etc. of the server computer. Further, the client computer has a window server program that receives an API function sent from the server computer and executes the API function on the operating system.

[0010]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Hereinafter, a detailed embodiment of the present invention will be described.

FIG. 2 shows an embodiment of a computer system to which the method of executing a program division and the method of distributing load according to the present invention are applied.

In FIG. 2, reference numerals 10 and 20 denote access terminals to which the method of executing a program according to the present invention is applied;
12 and 22 are operating systems (OS) such as Microsoft's Windows, and 14 and 24 are Micros
Libraries 16 and 26, such as oft's Win32 subsystem, are window servers, 17 and 2 which are components of one embodiment of the method of the present invention for dividing and executing programs.
7 is a communication library for executing RPC (Remote Procedure Call), 18 and 28 are access terminals 10 and 2
7 shows an initialization routine for initializing 0. 11a
And 21a are mouses as input devices, 11b and 2
1b is a keyboard as an input device, 11c and 21c
Denotes a monitor as a display device, and 11d and 21d denote speakers. Similarly, other input devices or output devices related to the man-machine interface not shown in FIG. 2 are connected to the access terminals 10 and 20.

Reference numeral 70 denotes an application engine to which the method for executing a program according to the present invention is applied in combination with the access terminals 10 to 20, 30 denotes a system management stack for managing the application engine 70, 40
And 50, an AP (Application Program) stack for executing an application program; 60, a network connecting the system management stack 30 and AP stacks 40, 50; 62, access terminals 10, 20;
Shows a network that connects to the application engine 70.

In the system management stack 30, the AP stack 40, and the AP stack 50, 32, 42, 5
2 is an OS such as Microsoft's Windows,
Reference numerals 44 and 54 denote libraries such as the Microsoft Win32 subsystem, and reference numerals 35, 45 and 55 denote disk units. The files on the disk devices 35, 45, 55 are
The file sharing function of the OS 12, 22, 32, 42, 52 makes it appear as one file system.

The functions and functions related to Microsoft's Windows and Win32 are described in Jeffrey Richter, "Ad
vanced Windows (tm) -The Developers Guide to the Win
32 (R) API for Windows NT (tm) 3.5 and Windows 95, M
It is described in icrosoft Press, 1995 (ISBN1-55625-677-4).

In the system management stack 30, 27
Is a library for initializing the application engine 70, 100 is a stack management table for managing hardware information and load status of the AP stack, and 150 is an AP stack used by the access terminals 10 to 20. 4 shows an access terminal management table to be managed.

In the AP stacks 40 and 50, 46
And 56 are window clients which are components of one embodiment of the method for dividing and executing a program of the present invention, 47 and 57 are communication libraries for executing RPC, and 48 and 58 are libraries 34, 44 and 54.
, And 49 and 59 are program loaders that are called when the program is loaded on the AP stack.

In FIG. 2, the system management stack 30
And the AP stacks 40 to 50 are separately illustrated for convenience, but the stack management table 100, the access terminal management table 150, and the initialization library 27 in the system management stack 30 may exist in the AP stack. . As described above, when the processing capacity of the application engine has room for the request from the access terminal, an economical configuration can be obtained by incorporating the function of the system management stack into the AP stack. Access terminals 10, 20, system management stack 30, A
The stacks 40 and 50 for P can be realized by an ordinary computer or the like. As the computer, a computer having a CPU, a memory, an internal bus, I / O devices such as a keyboard, a mouse, and a monitor, a communication device, a disk driver such as an FD, a CDROM, and a hard disk can be considered. OS, Wi
Programs such as n32, application, RPC, and recognition program are stored in a memory or a hard disk and executed by the CPU.

Now, an embodiment of the present invention will be described for a case where an application program is started and executed in the computer system shown in FIG.

In FIG. 2, an application engine 70 executes an application program, and the access terminal 10 or 20 performs man-machine interface processing of the application program. Application engine 70 and access terminals 10, 2
0 is a man-machine
By exchanging information regarding the interface processing, the program is divided and executed by both the access terminal and the application engine, and the load of program execution is distributed within the application engine. Hereinafter, the description will be made in the order of starting the application program and then executing the application program.

(A) Start of Application Program First, an embodiment of the present invention in the case of starting an application program will be described in detail with reference to FIGS.

In FIG. 3, steps 200 to 212 show the processing flow of the program executed by the access terminal, and steps 220 to 248 show the processing flow of the program executed by the application engine.

In the access terminal 10, when a user clicks an application program icon displayed on the monitor 11c of the access terminal and starts the application program (200), an initialization routine 18 on the access terminal is started. Requests the system management stack 30 in the application engine 70 to allocate an AP stack (202). The system management stack 30 in the application engine 70 searches for an unused AP stack using the stack management table 100 (220).

FIG. 4 shows an embodiment of the stack management table 100. In FIG. 4, reference numeral 102 denotes an ID number that is information for identifying an AP stack (the information is not limited to a number and may be information for identification), and 104 denotes a host of the AP stack on a network. Name and network address; 106, a busy / empty flag indicating whether the AP stack is used by any access terminal; 108, the dynamic CPU load of the AP stack I do. The load of 108 is updated by the system management stack 30 checking the value of the CPU load of each AP stack, for example, every second. Since various methods are known for checking the load value, they are not particularly described here. 110
Reference numerals 116 show the hardware performance of the AP stack. 110 indicates that the type of CPU mounted on the AP stack is, for example, Pentium and the operating frequency is 150 MHz.
Such CPU performance is shown. Reference numeral 112 denotes a mounted memory capacity, 114 denotes a built-in disk capacity, and 116 denotes what kind of hardware accelerator such as three-dimensional graphics processing and MPEG2 encoder is mounted. As described above, information of each AP stack mounted on the application engine is registered in each entry of the stack management table 100.

Returning to FIG. 3, the system management stack 30
Checks the in-use / empty flag 106 of the stack management table 100 in order from the lowest number of the ID number 102 of the AP stack, and searches for an empty AP stack (222). When an empty AP stack is found, the host name or network address (104) registered in the entry of the AP stack is obtained (230). If no empty AP stack is found, the access terminal management table 150 is used to check the ID numbers of all AP stacks currently used by the access terminal that has requested the AP stack allocation (224). .

FIG. 5 shows an embodiment of the access terminal management table 150. In FIG. 5, reference numeral 152 denotes a header of a list of each entry of the access terminal management table 150;
Reference numerals 54 to 156 denote each entry of the access terminal management table 150. In entry 154, 154a
Is the host name or network address of the access terminal on the network, 104b is a pointer to the next entry, 154c is the number of AP stacks used by the access terminal, and 154d to 154e are APs.
Indicates the ID number of the application stack. Thus, one access terminal may use a plurality of AP stacks.

Returning to FIG. 3, the system management stack 30
Examines the access terminal management table 150 to find all APs currently used by the access terminal.
The ID number of the application stack is checked (226). A in use
If there is a stack for P, the stack management table 100 is searched using the ID number of the AP stack obtained from the access terminal management table 150 as a key, and the CPU load 108 of the stack for AP is checked. By repeating this procedure, the CPU load 108 is checked for all AP stacks used by the access terminal,
Select the AP stack with the smallest CPU load (23
2). The host name or network address (10) registered in the entry of the selected AP stack
4) is obtained (234). If there is no AP stack in use, A
CPUs in order from the youngest ID number 102 of the stack for P
The load 108 is checked, and the AP stack with the minimum CPU load is selected (228). The host name or network registered in the entry of the selected AP stack
An address (104) is obtained (234).

The system management stack 30 allocates the AP stack having the obtained host name or network address to the access terminal, and activates the AP stack (236). The activated AP stack boots the window client using the program loader in the AP stack (240). When the boot is completed, the AP stack notifies the system management stack 30 of the completion of the boot. The system management stack 30 determines the host name or network address of the assigned AP stack on the network,
The port number of the AP stack used for communication with the AP stack is notified to the access terminal that has requested allocation of the AP stack (238). When the notification is completed, the system management stack 30 sets the stack management table 10
0 is updated to “in use”, the number of AP stacks used by the access terminal in the access terminal management table 150 (154c) is updated, and the AP for the AP stack used by the access terminal is updated. An entry of the stack ID number is added (239). On the other hand, the AP stack waits for a communication channel establishment request from the access terminal (242).

After requesting the allocation of the AP stack (202), the access terminal boots the window server by using the initialization routine 18 in the access terminal (204). Further, the host name or network address of the assigned AP stack on the network and the AP used for communication with the AP stack
The port number of the application stack is received (206). Upon receiving these, the access terminal sends the AP of the received host name.
It requests the communication stack to establish a communication path using the received port number (208). Upon receiving the establishment request, the AP stack returns an ACK signal for establishing a communication path (244). As a result, the access terminal and the AP
A communication path necessary for performing communication using the RPC or the like is established with the communication stack. When the communication path is established, the access terminal transmits the file name of the application program clicked by the user to the application engine (AP engine) (210). Upon receiving the file name of the application program, the AP stack boots the application program having the file name by using the program loader in the AP stack (246). Further, the resource file of the application program is transmitted to the access terminal (248). Here, the resource file is
A file that holds information about the menu bar that appears at the top of the window and the dialog boxes that appear when you drag the menu bar. The access terminal registers the received resource file with the window server (212). As a result, the window can be correctly displayed on the access terminal.

As described above, when the application program is started, by using the stack management table 100 and the access terminal management table 150, the AP can be dynamically changed according to the CPU load of the AP stack in the application engine 70. Since the application stack can be allocated, load distribution between the AP stacks can be realized, and the processing efficiency of the entire application engine improves.

In the embodiment of the present invention shown in FIG. 3 described above, the AP stack is allocated according to the CPU load of the AP stack. However, according to another embodiment of the present invention shown in FIG. The AP stack can be allocated in consideration of the CPU performance and memory capacity required by the application program to be executed. Hereinafter, this will be described in detail with reference to FIG.

In FIG. 6, steps 300 to 306 show the processing flow of the program executed by the access terminal, and steps 320 to 340 show the processing flow of the program executed by the application engine.

In the access terminal 10, when the user starts the application program by clicking the icon of the application program displayed on the monitor 11c of the access terminal (300), the initialization routine 18 on the access terminal is started. First looks up information about the clicked application program and finds the C
The PU performance and memory capacity are checked (301). Next, using these as parameters, the system management stack 30 in the application engine 70 is requested to allocate an AP stack (302).

The system management stack 30 in the application engine 70 has a stack management table 10
0 to search for an unused AP stack (32
0, 322).

When an empty AP stack is found, the CPU management 110 and the main storage capacity 112 of all empty AP stacks are checked using the stack management table 100, and the CPU required by the application program is checked. An AP stack that exceeds the performance and memory capacity is searched (331, 333). If an AP stack that satisfies the condition is found, one of them is selected, and the host name or network address (104) of the AP stack is obtained (335). If no AP stack that satisfies the condition is found, the AP stack that is closest to the condition is selected, and the host name or network address (10
4) is obtained (330).

When no empty AP stack is found, the access terminal management table 150 is used to check the ID numbers of all AP stacks currently used by the access terminal that has requested the AP stack allocation. (324, 326). If there is an AP stack in use, the stack management table 100 is searched using the AP stack ID number obtained from the access terminal management table 150 as a key, and the CP of the AP stack is searched.
The U load 108, the CPU performance 110, and the main storage capacity 112 are checked. By repeating this procedure, C is obtained for all AP stacks used by the access terminal.
PU load 108, CPU performance 110, main storage capacity 112
To find the C required by the application program
In the AP stack that exceeds PU performance and memory capacity,
Select the AP stack with the smallest CPU load (33
2). If an AP stack satisfying the conditions of the CPU performance and the main storage capacity is not found, an AP stack with the minimum CPU load is selected (332). Further, using the stack management table 100, the host name or the network address (10
4) is obtained (334).

If there is no AP stack in use,
In the stack management table 100, the CPU load 108,
The CPU performance 110 and the main storage capacity 112 are checked, and an AP stack with the smallest CPU load is selected from the AP stacks exceeding the CPU performance and the memory capacity required by the application program (328). CPU performance,
If no AP stack that satisfies the condition of the main storage capacity is found, an AP stack with the minimum CPU load is selected (328). Further, the stack management table 1
Using 00, the host name or network address (104) of the selected AP stack is determined (33
4).

The system management stack 30 allocates the AP stack having the obtained host name or network address to the access terminal, and activates the AP stack (336). The activated AP stack boots the window client using the program loader in the AP stack (340). When the boot is completed, the AP stack notifies the system management stack 30 of the completion of the boot (340). The system management stack 30 has requested allocation of the AP stack with the host name or network address of the allocated AP stack on the network and the port number of the AP stack used for communication with the AP stack. The access terminal is notified (338). The subsequent processing is the same as in FIG.

After requesting the AP stack allocation (302), the access terminal boots the window server using the initialization routine 18 in the access terminal (304). In step 304, a window handle correspondence table described later is generated. Further, it receives the host name or network address of the assigned AP stack on the network and the port number of the AP stack used for communication with the AP stack (306). The subsequent processing is the same as in FIG.

As described above, by using the stack management table 100 and the access terminal management table 150 when starting an application program, not only the CPU load of the AP stack in the application engine 70 but also the application to be started -AP stacks can be dynamically allocated in consideration of the CPU performance and memory capacity required by the program, so not only can load distribution between AP stacks be realized, but also application program execution efficiency can be improved. Can be done.

(B) Execution of Application Program (b1) Outline of Method for Executing Application Program Referring to FIG. 1, an embodiment of the present invention for executing an application program using an access terminal and an AP stack will be described. The outline of the procedure will be described.

According to the procedure shown in FIG. 3 or FIG. 6, every time the application program is started, FIG.
In, AP stacks 40 to 50 were allocated to access terminals 10 to 20. Window clients 46 to 56 on the AP stack,
The application program was booted and the window servers 16 to 26 were booted on the access terminal. Further, the RPC programs 17, 27, 47,
A window server on the access terminal using A and A
A communication path with the client server on the P stack has been established. As a result, the application can be executed using the access terminal and the AP stack.

Now, in FIG. 1, means having the same reference numerals as those in FIG. 2 indicate the same means in FIG. In FIG. 1, 10 and 20 are access terminals, 12 and 22 are OSs such as Microsoft Windows,
14 and 24 are libraries such as Microsoft's Win32 subsystem, 15a, 15b and 25 are resource files of corresponding application programs, and 16a, 16b and 26 are window files.
A server, 17a, 17b and 27 are communication libraries for executing RPC, and 18 and 28 are initialization routines. Reference numerals 40 and 50 denote stacks for the AP, reference numerals 42 and 52 denote OSs such as Microsoft Windows, and reference numerals 44 and 54 denote Microsoft Win32s.
Libraries like subsystems, 43, 53a
And 53b are application programs,
46, 56a and 56b are window clients, 47, 57a and 57b are communication libraries for executing RPC, and 48, 58a and 58b are programs for identifying the types of libraries 44 and 54.

In the embodiment of the present invention shown in FIG. 1, the access terminal 10 executes the application program 1 (43) and the application program 2 (53a) by using two AP stacks 40 and 50. At this time, the access terminal 20 newly starts the application program 3 (53b), and as a result, the AP stack 50 is allocated, and the access terminal 20 and the AP stack 50 execute the application program 3 (53b). Is shown.

In FIG. 1, when an application program 1 (43) executes an API function of a library such as the Win32 subsystem, the type of the API function in the library is determined. Is sent to the program 48 for identifying The program 48 has determined that the received function is an API function having a result related to the client computer in the library, such as man-machine interface processing such as window management, drawing, and reproduction of multimedia data. At this time, the API function is sent to the window client 46. In other cases, such as system services, the API function is sent to the library 44 on the AP stack and executed on the AP stack. The identification is performed by using an API function code and a table in which whether or not these API functions are of a type having a result related to the client computer is registered. In the identification for finding a specific function, A
The arguments of the PI function may be used with the code of the API function. The window client 46 extracts the argument of the API function, and passes the API function and the argument to the communication library 47. After performing the marshalling process of the API function and the argument, the communication library 47 sends the API function and the argument to the communication library 17a of the access terminal 10 by RPC. The communication library 17a performs an unmarshalling process on the received API function and argument, and passes the API function and argument to the window server 16a. The window server 16a calls a library 14 such as the Win32 subsystem to perform man-machine interface processing.

Here, the marshalling process is a process of setting the name of an API function and its argument in a communication packet in the remote procedure call RPC. The name of the API function is a number mutually agreed between the client computer and the server computer. The name is set in the communication packet. The function argument is recorded somewhere in memory in the AP stack or somewhere in memory specified by the pointer. So the argument is AP
Set in the communication packet after being collected from the memory in the stack. Unmarshalling is a procedure in which an API function and its arguments are obtained from a communication packet and set in a memory (in the access terminal in this embodiment).

The return value upon execution of the API function is passed from the library 14 to the window server 16a.
The window server 16a returns the return value to the communication library 1
7a. The communication library 17a sends the passed return value to the communication library 47 on the AP stack 40 as a return value of the RPC. The communication library 47 returns a return value to the application program 1 (43).

The application program 2
(53a), application program 3 (53
b) is performed similarly.

As described above, an API function (library) such as the Win32 subsystem is provided with a program for identifying the type of API function, an API function relating to man-machine interface processing is selected, and this is transmitted to the access terminal. By executing, even if a program was originally executed on one computer, it can be automatically divided and executed on two computers. As a result, a low-cost access terminal specialized in the man-machine interface processing function can be realized.

(B2) Opening and Playback of Multimedia File An embodiment of the method for executing a program division according to the present invention in multimedia data playback processing will be described with reference to FIGS. 7, 8 and 9. .

In FIG. 7, means having the same reference numbers as in FIG.
FIG. 7 shows the same means. In FIG. 7, 10 is an access terminal, and 12 is Microsoft Windows.
Is shown. Reference numeral 12a denotes a file system which is one component of the OS 12, and shares a file with the file system in the AP stack 40. Reference numeral 12b denotes a device driver which is one component of the OS 12, 11a denotes a mouse, 11b denotes a keyboard, 11c denotes a monitor, and 11d denotes a speaker. 14 is a library such as Microsoft's Win32 subsystem, 16 is a window server, 15 is a resource file, 17 is R
A communication library for executing the PC, 18 indicates an initialization routine. 40 is a stack for AP, 42 is W of Microsoft Corporation
OS like Windows, 44 is a library like Microsoft's Win32 subsystem, 43 is an application
45, a disk, 46, a window client, 47, a communication library for executing RPC,
Reference numeral 8 denotes a program for identifying the type of the library 44. 43a and 43b indicate types of libraries included in the application program 43.

First, an embodiment of the present invention for opening a multimedia file will be described in detail with reference to FIGS. 8 and 7. FIG.

In FIG. 8, the application program 43 opens a multimedia file A
When the PI function is executed (400), the program 48 for identifying the type of the library determines that the API function is a function related to multimedia reproduction (40).
2) Call an API function to open the multimedia file in the window client 46 (404). The window client 46 determines that A
Check the ID number of the thread that executed the PI function (40
6), such API name, file name, etc.
The argument of the PI function and the ID number of the thread are passed to the communication library 47. The communication library 47 uses the API
Function name, arguments of the API function, and thread I
The D number is marshaled, and the communication library 17 in the access terminal 10 is called by RPC (40).
8). The communication library 17 performs an unmarshalling process on the content sent from the AP stack, and passes the API function name, the API function argument, and the thread ID number to the window server 16. Window server 1
6 uses the thread ID correspondence table 700 to convert the ID number of the thread executed on the AP stack into the ID number of the thread executed on the access terminal (410).

FIG. 12 shows an embodiment of the thread ID correspondence table 700. In FIG. 12, 702 indicates the ID number of the thread on the AP stack, and 704 indicates the ID number of the thread on the access terminal. Thread ID
The process of adding an entry in the correspondence table is performed using the thread ID number on the AP stack as a key.
This is performed when there is no matching entry when 00 is searched. If there is no matching entry, a new thread is created on the access terminal, and the ID number of the created thread is registered in the thread ID correspondence table 700.
The process of deleting the entry of the thread ID correspondence table is performed when the application program running on the AP stack ends.

Returning to FIG. 8, the window server 16
The name of the API function and the argument of the API function are passed to the thread corresponding to the ID number of the converted thread (41
2). This thread calls library 14,
An API function for opening the multimedia file is executed (414). At this time, since the file system 12a of the OS 12 performs file sharing with the file system 42a of the OS 42 on the AP stack 40, the file on the disk 45 can be directly opened from the access terminal 10 ( 414). The library 14 returns a return value such as a file identifier indicating the execution result of the API function to the window server 16 (41
6). The window server 16 returns a return value to the communication library 17. The communication library 17 returns the return value to RPC
Of the communication library 4 on the AP stack
7 and the communication library 47 returns the return value to the window
Return to the client 46 (418). The window client 46 returns a return value to the application program 43 (420).

As described above, the API function for opening a multimedia file is executed by the above-described procedure shown in one embodiment of the present invention. Thus, A
As a result of the multimedia file on the disk 45 of the P stack 40 being opened from the access terminal 10, the access terminal 10 combines the multimedia file on the disk 45 of the AP stack 40 by combining the file sharing function of the OS. Files can be read directly.

Next, with reference to FIGS. 9 and 7, an embodiment of the present invention for reading and reproducing a multimedia file will be described in detail.

Referring to FIG. 9, when the application program 43 executes an API function for reading and reproducing a multimedia file (450), the program 48 for identifying the type of the library recognizes that the API function is a function relating to multimedia reproduction. Judge that there is (4
52), calls the API function in the window client 46 (454). Window client 4
6 checks the ID number of the thread that has executed the API function (456), and determines the name of the API function, arguments of the API function such as a file identifier, and the thread ID.
The D number is passed to the communication library 47. Communication library 4
7 is the name of the API function, the argument of the API function,
And the thread ID number are marshaled, and R
Communication library 17 in access terminal 10 by PC
Is called (458). The communication library 17 performs an unmarshalling process on the contents transmitted from the AP stack, and passes the API function name, the API function argument, and the thread ID number to the window server 16. The window server 16 uses the thread ID correspondence table 700 to determine the I of the thread being executed on the AP stack.
D number is the I of the thread running on the access terminal.
It is converted to a D number (460). Further, using the window handle correspondence table 720, the window handle executed on the AP stack is converted into the window handle for execution on the access terminal.

Here, the window handle is an ID number for identifying a window displayed on the monitor, and is held by a program using a graphical user interface on the window OS. One window handle is given to a program when the program is started. The window handle for the AP stack application program is A
Generated in the P stack. Meanwhile, a window handle for the window server of the access terminal is created in the access terminal. The window handle for the AP stack application program is:
Sent to the access terminal and used for the window / handle correspondence table.

FIG. 17 shows an embodiment of the window / handle correspondence table 720. In FIG. 17, 722 is A
Indicates the window handle on the P stack, 72
4 indicates a window handle on the access terminal.
The process of generating an entry in the window handle correspondence table is as follows:
This is performed when the application program executes an API function for generating a window on the AP stack. Deletion of an entry in the window handle correspondence table is performed by the AP
This is performed when the application program executes an API function for window erasure on the stack for use.

Returning to FIG. 9, the window server 16
The name of the API function and the argument of the API function are passed to the thread corresponding to the ID number of the converted thread (46).
2). This thread calls library 14,
API for reading and playing multimedia files
Execute the function (464). At this time, the file system 12 a of the OS 12 stores the OS 4 on the AP stack 40.
2, the multimedia file stored in the disk 45 on the AP stack 40 is directly read out,
The data can be reproduced by the access terminal 10 (464).
Multimedia file is device driver 12b
Is reproduced on the monitor 11c and the speaker 11d (464). The library 14 returns the execution result of the API function for reproducing the multimedia file to the window server 16 (466). Window server 16
Returns a return value to the communication library 17. The communication library 17 returns the return value to the communication library 47 on the AP stack as the return value of the RPC.
Returns the return value to the window client 46 (46
8). The window client 46 returns a return value to the application program 43 (470).

As described above, according to the above-described procedure shown in one embodiment of the present invention, by using the file sharing mechanism of the OS in combination, the access terminal 10 can access the multimedia media stored in the disk 45 of the AP stack 40. The file can be read directly and played back locally on the access terminal 10. In other words, the application program 43 once reads the multimedia file on the disk 45, and the application program 43 does not need to transmit the file to the access terminal 10. As a result, the access terminal 1
Even when a program is divided and executed between the stack 0 and the AP stack 40, a multimedia file such as a moving image file can be reproduced at a high speed.

(B3) Message Processing from Mouse and Keyboard Referring to FIGS. 11 and 10, one embodiment of the present invention will be described in detail for a case where a user sends a message to an application program using a mouse or keyboard. explain.

In FIG. 10, means having the same reference numerals as those in FIG. 7 indicate the same means in FIG. FIG.
At 0, 10 indicates an access terminal, and 12 indicates an OS such as Microsoft's Windows. 12a is one of OS12
A file system as a constituent element is shown, and a file is shared with the file system in the AP stack 40. Reference numeral 12b denotes a device driver that is one component of the OS 12, 11a denotes a mouse, 11b denotes a keyboard,
11c indicates a monitor, and 11d indicates a speaker. 14 is Mi
libraries like the crosoft Win32 subsystem, 1
6 is a window server, 17 is a communication library for executing RPC, and 18 is an initialization routine. 40 is AP
Stack, 42 is O like Microsoft's Windows
S and 44 are libraries such as Microsoft's Win32 subsystem; 43 is an application program;
Is a disk, 46 is a window client, 47 is a communication library for executing RPC, 48 is a library 4
4 shows a program for identifying four types. 43a and 4
3b indicates the type of library included in the application program 43.

In FIG. 11, when the application program 43 executes an API function (getmessage ()) for receiving a message from an input device such as a keyboard or a mouse (500), the program 48 for identifying the type of library executes the API function. It is determined that the function is a function relating to man-machine interface processing such as window management (502), and the window client 46 is determined.
Calls the API function (getmessage ()) in
4). The window client 46 checks the ID number of the thread that has executed the API function (506), and passes the name of the API function, the argument of the API function, and the ID number of the thread to the communication library 47. The communication library 47 performs a marshalling process on the name of the API function, the argument of the API function, and the thread ID number, and calls the communication library 17 in the access terminal 10 by RPC (508). Communication library 17
Performs an unmarshalling process on the contents sent from the AP stack, and stores the name of the API function, the argument of the API function, and the thread ID number in the window server 16.
Pass to. Using the thread ID correspondence table 700, the window server 16 converts the ID number of the thread executed on the AP stack into the ID number of the thread executed on the access terminal (510). Further, using the window handle correspondence table 720, the window handle executed on the AP stack is converted into the window handle for execution on the access terminal. The window server 16 passes the name of the API function and the argument of the API function to the thread corresponding to the ID number of the converted thread (512). This thread calls the library 14 and executes the API function (getmessag
Execute e ()). As a result, the access terminal waits for a message from the input device (514). When an event such as a mouse click or a menu drag occurs on a window in which an application program is executed (516), the OS 12 transmits the event to the library 14, and the library 14 determines what kind of event has occurred. Then, a message indicating whether the message has been sent is generated, and the message is transmitted to the window server (518). Window server 16 returns the message to communication library 17 (520). The communication library 17 returns the message to the communication library 47 on the AP stack as a return value of the RPC, and the communication library 47 returns the message to the window client 46 (522). Window client 46 returns the message to application program 43 (524). The application 43 performs a process according to the content of the received message (526).

As described above, according to the above-described procedure shown in one embodiment of the present invention, an event generated in the input device of the access terminal 10 can be transmitted to the application program running on the AP stack 40. .

(B4) Method of Reducing Communication Processing Between AP Stack and Access Terminal According to the above-described embodiment of the present invention, each time the application program 43 executes one API function, Since the function is sent to the access terminal 10, communication processing may be enormous.

However, according to an embodiment of the present invention of the window client 46 shown in FIGS. 14 and 15, since a plurality of API functions are transmitted together from the AP stack 40 to the access terminal 10, a marshalling process is performed. It is possible to reduce communication processing related to RPC, such as the RPC and unmarshalling processing.

Referring to FIGS. 14 and 15, the window client 46 has a queue 620 and a timer 622 capable of holding a plurality of API functions. First,
The window client 46 sets an upper limit value on the timer 622 (600). The value of the timer 622 is decremented by one at regular intervals. Next, the window client 46 executes the program 4 for identifying the type of the library.
8 (601). When called by the program 48 for identifying the type of library, the called API function and its argument are stored in a queue 620.
(604). API for drawing graphics
If the return value of the API function inserted as a function is a VOID, it is checked whether the queue 620 is full (608). If the queue is not full, it is checked whether the value of the timer 622 is equal to or less than zero (610).
If the timer value is not less than zero, the process returns to 601 and waits for the application program 43 to execute the next API function.

If the return value of the inserted API function is not a VOID, the application program 43 uses the return value in the program.
Performs a marshalling process for the API functions in the batch and sends them to the access terminal 10 by RPC (61).
2). This can prevent a program that requires a return value from being delayed. Also, when the queue 620 is full or when the value of the timer 622 becomes zero or less, the queue 62
The API functions in the number 0 are sent to the access terminal 10 in a lump (612). Thereafter, the flow returns to 600.

As described above, according to the embodiment of the present invention, a plurality of API functions are put together to form the AP stack 40.
, The communication processing related to RPC such as marshalling processing and unmarshalling processing in the communication library 47 can be reduced, and the CPU load of the AP stack 40 and the access terminal 10 can be reduced.

Further, according to the embodiment of the present invention described above, each time the user generates an input message from the mouse 11a or the keyboard 11b of the access terminal 10,
Since this message is sent to the AP stack 40,
The communication processing may be enormous.

However, according to one embodiment of the present invention of the window server 16 shown in FIG.
Since only the message processed by the program 43 is transmitted to the AP stack 40, communication processing relating to RPC such as marshalling processing and unmarshalling processing can be reduced.

First, FIG. 13 shows the message registration table 7
50 shows details. Reference numeral 752 denotes an entry in which the number of the message to be transmitted to the AP stack is registered. This message registration table is held by the window server of the access terminal, and is generated when the window server is started (step 304 in FIG. 6). The message number represents the type (type) of the message received by the application program, that is, the content of the message registration table changes depending on the type of the application program of the AP stack. The AP stack registers a message number in a message registration table when activating an application program. Then, the contents of the message registration table are held until the window server ends.

In FIG. 16, the window server 16
Receives a message from the library 14 (65
0), the window server 16 searches the message registration table 750 using the received message number as a key (652). As a result of the search, if the message is registered in the message registration table 750, the message is stored in the AP stack 4 in the same procedure as the method described above.
Send to 0 (656). If not registered, the default processing that the library 14 has locally in the access terminal 10 is executed (658).

The functions of the present invention can be realized by executing a program having the above functions on a computer. The program is provided to the computer in a form recorded on a computer-readable storage medium. The computer executes the program stored in the recording medium. The program for the access terminal and the program for the application engine may be recorded and supplied on one recording medium, or may be recorded and supplied on another recording medium. As a recording medium, an FD (floppy disk), a CD (compact disk) ROM, a DVD, and the like can be used. The computer reads the program (software) in the storage medium using the storage medium reader and executes this function.

As described above, according to the embodiment of the present invention, only the message registered in the message registration table 750 can be transmitted from the access terminal 10 to the AP stack 40. For RP and unmarshalling
Communication processing related to C can be reduced, and the CPU load on the AP stack 40 and the access terminal 10 can be reduced.

FIG. 18 shows the data and the flow of control when bitmap data is displayed on a display device of a client terminal in the prior art. (1) The compressed multimedia data is read from the disk.
(2) The compressed multimedia data is decompressed (expanded) by the application. That is, the data is returned to the uncompressed state. Then, bitmap data for display is created from the multimedia data. (3) The bitmap data is sent to the X library. The X library then sends the bitmap data to the OS on the server computer. (4) The OS on the server computer sends the bitmap data to the OS on the client computer. (5) The OS on the client computer sends the bitmap data to the window server that controls the display on the client side. (6) The bitmap data is displayed on a display.

FIG. 19 shows a control flow and a data flow in the present invention. (1) An application on a server issues an API function for reproducing multimedia data. Then, the function type recognizing program and the window client program decide to send the API function to the access terminal. (2) The OS transfers the API function to the access terminal. (3) The window server on the access terminal receives the API function from the server OS. (4) The window server issues an API function to the OS on the access terminal. Here, the target processed by the API function is a multimedia file that is shared by the access terminal and the server. (5) The OS of the server computer is called from the OS of the access terminal by the file sharing protocol.
(6) The OS of the server computer accesses the secondary storage (disk). (7) The OS reads the compressed multimedia data from the disk. (8) The compressed multimedia data read from the disk is transferred from the server to the access terminal. (9) The OS on the access terminal passes the multimedia data to the window server. (10) The window server decompresses (expands) the compressed multimedia data. That is, the multimedia data is not compressed. then,
The window server creates bitmap data from the decompressed multimedia data and sends it to the display device.

In the prior art, the data on the network between the server and the access terminal is bitmap data, but in the present invention, the data is compressed multimedia data. The amount of data of the present invention on the network is less than that of the prior art. Therefore, the present invention is effective in reducing the data transfer load of the network.

In the prior art, the multimedia data is copied twice between the application program and the OS in the server computer (one of which is bitmap data). On the other hand, in the present invention, multimedia data is not copied in the server computer. Therefore, the present invention is effective in reducing the load on the server computer. Further, the present invention creates the bitmap data conventionally performed by the server computer at the access terminal, so that it is effective to balance the load between the server computer and the access terminal.

[0082]

According to the present invention, when the application is started, the CPU performance and the memory capacity required by the application are determined according to the following:
By allocating computing resources (stack for AP),
Achieve efficient load distribution.

When the API provided by the OS is a man-machine interface process or a multimedia process, the process is executed not by the AP stack but by the access terminal, so that an NC or PDA can be used. Even with a low-cost PC, an existing multimedia-compatible application can be executed efficiently, similarly to a normal desktop PC.

According to the embodiment of the present invention, a program is divided and executed between a client computer and a server computer so that multimedia data such as a moving image and an audio can be output with high performance, and an interactive application program can be executed. Even in this case, the load on the server computer can be distributed.

[Brief description of the drawings]

FIG. 1 is a diagram showing an embodiment of a method for dividing a program according to the present invention.

FIG. 2 is a diagram showing an embodiment of a configuration of a computer system targeted by the present invention.

FIG. 3 is a flowchart illustrating an embodiment of an application program starting process according to the load distribution method of the present invention.

FIG. 4 is a diagram showing a stack management table according to the load distribution method of the present invention.

FIG. 5 is a diagram showing an access terminal management table according to the load distribution method of the present invention.

FIG. 6 is a flowchart showing another embodiment of an application program starting process according to the load distribution method of the present invention.

FIG. 7 is a diagram showing an embodiment of processing of a multimedia file according to the method of dividing a program according to the present invention.

FIG. 8 is a flowchart showing an embodiment of a multimedia file opening process according to the program division execution method of the present invention.

FIG. 9 is a flowchart showing one embodiment of a process of reading and reproducing a multimedia file according to the method of dividing a program according to the present invention.

FIG. 10 is a diagram showing an embodiment of message processing according to the method of dividing a program according to the present invention.

FIG. 11 is a flowchart illustrating an example of message processing according to the method of dividing a program according to the present invention.

FIG. 12 is a diagram showing a thread ID correspondence table according to the method of dividing and executing a program of the present invention.

FIG. 13 is a diagram showing a message registration table according to the method of dividing a program according to the present invention.

FIG. 14 is a flowchart showing an embodiment of a window client according to the program division execution method of the present invention.

FIG. 15 is a diagram showing an embodiment of a window client according to the method of dividing a program according to the present invention.

FIG. 16 is a flowchart showing one embodiment of a window server according to the program division execution method of the present invention.

FIG. 17 is a diagram showing a window-handle correspondence table according to the program division execution method of the present invention.

FIG. 18 shows the data and control flow of the system in the prior art.

FIG. 19 shows a data and control flow of the system according to the present invention.

[Explanation of symbols]

10, 20: access terminal, 30: system management stack, 40, 50: stack for AP, 70: application engine, 16, 16a, 16b, 26: window server, 46, 56, 56a, 56b: window client , 17, 17a, 17b, 27, 4
7, 57, 57a, 57b: communication library, 48,
58, 58a, 58b: API type (library type) identification program, 100: stack management table, 150: access terminal management table, 700: thread ID correspondence table, 720: window handle correspondence table.

 ──────────────────────────────────────────────────の Continuing on the front page (72) Inventor Toshimitsu Furukawa 1-280 Higashi Koigakubo, Kokubunji-shi, Tokyo Inside the Central Research Laboratory, Hitachi, Ltd. Central Research Laboratory

Claims (13)

[Claims] 1. A computer connected to a second computer having a second operating system via a network, having a first operating system, and
A first computer for providing the functions of the first and second operating systems to an application program by an API function, wherein the identification means for identifying a specific function of the API function; Sending means for sending to the second computer, when the identification means identifies that the API function is a specific function, sending the file function to the second computer by the sending means. A first computer characterized by the following. 2. The first computer according to claim 1, wherein the first operating system has a file sharing mechanism with the second operating system. 3. The first computer according to claim 2, wherein said specific function is an API function related to multimedia processing. 4. The first computer according to claim 2, wherein said specific function is an API function relating to man-machine interface processing. 5. The computer according to claim 1, wherein the first computer is a server computer,
5. The first computer according to claim 3, wherein the second computer is a client computer. 6. A computer which is connected via a network to a first computer having a disk and a first operating system, has a second operating system, and has said first and second operating systems. A second computer that provides an application program with an operating system function by an API function, wherein the second computer receives the API function sent from the first computer; File sharing means, and means for directly reading and reproducing the multimedia file stored on the disk by using the file sharing mechanism. A second computer characterized by the following. 7. A first computer (server) and a second computer (client) communicate via a network, and the first and second computers have first and second operating systems, respectively. Wherein the first and second operating systems provide the functions of the first and second operating systems to an application program by an API function. The computer, when the application program executes the API function, the identification program identifies whether the API function is an API function related to man-machine interface processing or multimedia processing. Is the window client
A method for dividing a program, wherein the program sends the API function to the second computer via the network. 8. The computer according to claim 7, wherein said second computer receives said API function sent from said first computer, and executes said API function in said second operating system. How to divide the described program. 9. The first computer further includes a disk, the first and second operating systems of the computer system include a file sharing mechanism, and the second computer receives the received API. If the function reads and plays the multimedia file stored on the disc of the first computer, the second
9. The program according to claim 8, wherein the operating system directly reads and reproduces the multimedia file stored on the disk of the first computer using the file sharing mechanism. Split execution method. 10. The first computer transmits the API function to the second computer when sending the API function to the second computer.
The thread ID of the thread of the first computer that is executing the program is also sent to the second computer, and the second computer sends the received thread ID to the AP.
9. The method according to claim 8, wherein the thread executing the I function is converted into a thread ID in the second computer, and the API function is executed in the second operating system. 11. A plurality of server computers and one or more client computers are connected via a network. Each of the server computers and the client computers has an operating system, and the operating system comprises: In a computer system that provides the functions of the operating system to an application program by an API function, any one of the plurality of server computers includes a server computer in which a CPU load of each of the plurality of server computers is described. A management table, and each of the plurality of server computers has:
An identification program for identifying the function of the API function; and a window client program for sending the API function to the client computer. When the client computer starts executing an application program, the plurality of server computers From among the server computers, the server computer with the minimum CPU load described in the server computer management table is selected, the application program is booted on the selected server computer, and in the selected server computer, When the application program executes the API function, the identification program determines that the API function is a man-machine
If it is determined that the API function is an API function related to interface processing or multimedia processing, the window client program sends the API function to the client computer that has started the execution of the application program via the network. A program split execution method and a load distribution method characterized by the above-mentioned. 12. The server computer management table further describes hardware performance such as CPU performance and memory capacity of each server computer. When the client computer starts execution of an application program, Among the plurality of server computers, the CPU performance and the memory capacity described in the server computer management table correspond to the C required by the application program.
A server computer that exceeds PU performance and memory capacity, and
The CP described in the server computer management table
12. The method according to claim 11, wherein a server computer having a minimum U load is selected. 13. One of the plurality of server computers further includes a client computer management table for registering all server computers used by the client computers that have started the execution of the application program. 12. The program according to claim 11, wherein when the client computer starts execution of the application program, a server computer described in the client computer management table is selected from the plurality of server computers. Split execution method and load distribution method.