KR20010034542A - Method and apparatus for dynamic distributed computing over a network - Google Patents

Abstract

In a client-server environment, it would be desirable to have many servers capable of handling a wide range of applications, such as computer intensive applications, or graphical operations such as rendering. In heterogeneous client-server environments, conventional systems statically store executables on the server for later execution. This required a lot of time and expensive storage for programmers to transport applications from client machines with different object modules to server machines. The present invention solves these problems by creating a homogeneous execution environment within a heterogeneous client-server network. Accordingly, the system dynamically downloads the code on the computer server, executes the code on the computer server, and returns the result to the calling client method. This technique does not require multiple copies of code to be downloaded or compiled because server code can run on all different systems. Systems designed according to this technique are also efficient. Server code is generally compiled locally on the client, downloaded to the server as bytecode, and then executed.

Description

METHOD AND APPARATUS FOR DYNAMIC DISTRIBUTED COMPUTING OVER A NETWORK}

In a native computing network, a user may harness the processing power of many computers connected to the network. By distributing processing among different computers on a network, tasks with many different independent calculations can be processed quickly in parallel. In addition, specialized tasks can be computed more quickly by placing a computer on a network that is most suitable for processing data. For example, a task running on a client system that performs intensive floating point calculations can execute certain calculations more quickly on a server system coupled to a network having suitable dedicated floating point hardware.

Unfortunately, conventional techniques for distributed computing are not readily implemented in typical heterogeneous computing environments. Each computer on the network is typically heterogeneous with different processor and operating system combinations and requires different object modules for execution. On the client side, different object modules add storage requirements to the client and also port them, since the user must compile different versions of the job for each of the different platforms and load this module on the corresponding platform. It requires porting, and the same task must be compiled many times. Moreover, the prior art requires that the code be distributed on a computer long before the code is executed. In conventional systems, many have discouraged the use of this technique with the intensive preparation required to perform distributed computing.

Distributed computing systems based on scripting languages are an improvement over some conventional distributed computing systems. Unfortunately, scripting-based systems eliminate the need to recompile code, but are still extremely inefficient. Distributed systems based on scripting can execute the same instructions on multiple platforms because this language is interpreted by an interpreter placed on each system. After all, most scripting languages are slow because they need to translate higher-level scripting instructions into lower-level native languages in real time. Moreover, scripting languages are difficult to optimize and can usually consume memory because they are not compressed.

Based on the above limitations found in prior art systems, it is desirable to improve distributed computing systems.

The present invention relates generally to distributed computing systems, and more particularly, to a method and apparatus for performing dynamic distributed computing over a network.

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate some embodiments in accordance with the invention, and together with the description serve to explain the principles of the invention.

1 is a network diagram suitable for use in the method and system according to the present invention.

2 is a block diagram of a computer system suitable for use in the method and system according to the present invention.

3 is a block diagram representation of a client-server networking environment suitable for use in the method and system according to the present invention.

4 is a flowchart of steps performed by a client in accordance with the method and system according to the present invention.

5 is a flowchart of steps performed by a server in accordance with the method and system according to the present invention.

In one aspect of the invention associated with a client computer, a method and apparatus for dynamic distributed computing is provided. First, the client selects a server from the network to process the job. This choice may be based on the availability of the server or the dedicated processing power of the server. The client stub then marshals the parameters and data into the work request. The client sends this work request to the server invoking the generic compute method. The server automatically determines whether the types associated with the job are available on the server and downloads the job type from the network as needed. The information in the job type can be used to extract the parameters and data stored in a particular job request. The comprehensive compute method is used to execute work requests for the selected server. After the server has processed the work request, the client receives the result or computed work again from the selected server.

In another aspect of the invention associated with a server, a method and apparatus for dynamic distributed computing is provided. First, the server will automatically determine which jobs are available on the server and will download the job type from the network as needed. These job types help the server unmarshal parameters and data from job requests and create local jobs. Next, the server invokes a generic compute method that can handle all types of compute jobs or subtypes of compute jobs. This generic compute method is used to execute work requests for the selected server. If a subsequent job uses this result, the server stores the result from the computed job in a local cache. Once the job is completed, the server returns the result or computed job to the client.

summary

Hereinafter, embodiments of the present invention will be described in detail as illustrated in the accompanying drawings. Like reference numerals will be used throughout the drawings and the following detailed description to refer to the same or like parts as much as possible.

The system according to the invention corrects the disadvantages of the prior art and provides a dynamic distributed computing system used over a network of server computers. This dynamic distributed computing system is particularly useful for heterogeneous computer networks where computers have different processors, different operating systems, and combinations thereof. Such a system allows a client application to select a server computer at runtime to execute a particular task. In the method and system according to the invention, a task is an object with a particular type or class definition. The server can generally delay the actual class definition until the parameters and data associated with the object are received on the server. For example, if an object instance of unknown class is sent to the server, the server downloads the unknown class. The server then uses this class to process the object. This assignment of class definitions to objects increases flexibility in handling complex tasks across a network of server computers. In addition, the current design utilizes features within the existing remote procedure call subsystem, such as the remote method call (RMI) subsystem developed by Sun Microsystems, Inc. of Mountain View, California, USA, to minimize minimal overhead. Facilitates flexibility with the head. For detailed information on remote method invocation (RMI), see "System and Method For Facilitating Loading" by Ann M, Wolrath, James Waldo, and Roger Riggs, incorporated by reference of the present invention and assigned to the applicant of the present invention. See US Patent Application Serial No. 08 / 636,706 entitled "Stub" Information to Enable a Program Operating in One Address Space to Invoke Processing of a Remote Method or Procedure in Another Address Space. RMI is also described in detail in FTP://ftp.javasoft.com/docs/jdk1.2/rmi-spec-jdk1.2.ps on JavaSoft Webpage, which is also incorporated by reference of the present invention.

Unlike conventional systems, work in a dynamic distributed system according to the present invention can be recorded once and executed on any server computer in the network. This capability is particularly advantageous in heterogeneous networks because the work does not have to be ported to all platforms before it can run. Instead, a comprehensive compute task designed in accordance with the present invention can execute various tasks specified by the client at runtime. For example, a user may develop a generic compute task that accepts a type called "Compute", and a type "Compute" in an object oriented language such as Java. Java is described in a book entitled "The Java Language Specification" (Addison-Wesley, 1996) by James Gosling, Bill Joy, and Guy Steels, which is incorporated by reference in many of the books. The client creates a job with a subtype of type "Compute" and passes the object corresponding to the job to a comprehensive compute job on the server. The remote procedure call mechanism downloads this object to the server and to the comprehensive compute job that runs the job.

In Java, a job sent by a client is actually an object that contains a series of bytecodes. These bytecodes can be executed immediately as long as the server implements the Java Virtual Machine (JVM). JVMs are efficiently simulated at the software layer, either directly implemented in hardware or running on top of a native operating system. The Java language is designed to run on a computing system with the characteristics specified by the Java Virtual Machine (JVM) specification. The JVM specification is described in detail in the text entitled The Java Virtual Machine Specification, (Addison-Wesley), which is incorporated herein by reference. A single JVM environment enables homogeneous execution of tasks, even though computer systems are heterogeneous and have different processes, different operating systems, and combinations thereof. Combining a powerful remote procedure call subsystem with comprehensive computer tasks on a server designed in accordance with the present invention results in a powerful dynamic distributed computing environment.

Compute servers using bytecode can process tasks much faster than systems using conventional text-based scripting or other languages. Each bytecode is compact (8 bits) and is in aberration format. After all, the server computer doesn't waste computer cycles parsing characters and arguments at runtime. In addition, bytecodes can be optimized on the client before transporting them to the server. The server may optionally convert the bytecode into a native instruction for execution at runtime directly on hardware using a processing mechanism such as a Just-In-Time (JIT) compiler. For a more detailed description of the JIT compiler, see The Java Virtual Machine Specification.

The system designed according to the present invention assumes that each client can communicate to each server via a common networking protocol such as TCP / IP. It is also assumed that a remote procedure call (RPC) subsystem exists on the client and on the server that can receive and execute remote requests from the client. The RPC system also automatically downloads code and related information to perform the task at runtime. RMI, developed by Sun Microsystems, Inc., is a suitable RPC subsystem that provides these features. However, those skilled in the art will appreciate that other RPC server systems such as DCOM / COM from Microsoft, Inc. may be used in place of RMI.

Computer network

1 illustrates a network 100 in which one embodiment of the invention may be practiced. The network 100 includes, as its essential components, a local area network (LAN) 101, a backbone or broadband network (WAN) 102, and a local area network 116. The LAN 101 includes a series of workstation and server computers 102, 104, 106 and 108. LAN 116 includes a series of workstation and server computers 118, 120, 122, and 124. These computer systems 102-108 and 118-124 are coupled together to share information, transmit data and also share computing power. LAN 101 is coupled to a larger overall network using network interconnect 110. The particular type of network interconnect device may be a router, a switch or a hub, depending on the particular network. In general, network interconnect device 110 is a router, switch, hub, or any other network interconnect device capable of coupling a user terminal and LAN 101, WAN 112, and LAN 116 together in a unified network. Can be. Network interconnect device 114 may also be a router, switch, hub, or any other network interconnect device capable of coupling user terminals and computers on LAN 116 to an integrated network. In general, a dynamic distributed computing system designed in accordance with the present invention is typically located on each computer system connected to the network 100. Thus, each computer can act as a client or server, depending on the particular request made and the service provided. Typically, a client computes a job on a server computer and requests that the server computer process the job.

Computer systems

Referring now to FIG. 2, a system architecture for a computer system suitable for implementing the method and system according to the present invention is illustrated. The example computer system is for illustration only. Although this description refers to terminology commonly used to describe a particular computer system, such as an IBM PS / 2 personal computer, this description and concepts refer to network computers, workstations, and even mainframes with a different architecture than FIG. The same applies to other computers such as computers.

Moreover, although the present invention can be equally applied to other computer systems having similar conditions, this embodiment is described with reference to a computer system implementing the Java programming language and the Java virtual machine specification. In particular, the present invention may be practiced with object oriented and non-object oriented programming systems.

Computer system 200 includes a central processing unit (CPU) 105, which may be implemented as a prior art microprocessor, random access memory (RAM) 210 for temporarily storing information, and permanently for storing information. A read only memory (ROM) 215 is provided. The memory controller 220 is provided to control the RAM 210.

Bus 230 interconnects the components of computer system 200. Bus controller 225 is provided to control bus 230. Interrupt controller 235 is used to receive and process various interrupt signals from system components.

The mass storage device may be provided by the diskette 242, the CD ROM 247, or the hard disk 252. Data and software may be exchanged with computer system 200 via removable media, such as diskette 2452 and CR ROM 247. Diskette 242 is insertable into diskette drive 241 connected to bus 230 by controller 240. Similarly, CD ROM 247 is insertable into CD ROM drive 246 connected to bus 230 by controller 245. Hard disk 252 is part of fixed disk drive 251 connected to bus 230 by controller 250.

User input to computer system 200 may be provided by a number of devices. For example, keyboard 256 and mouse 257 are connected to bus 230 by controller 255. Those skilled in the art will appreciate that other input devices such as pens and / or tablets may be connected to the bus 230, appropriate controllers and software as desired. DMA controller 260 is provided to perform direct memory access to RAM 210. The virtual display is generated by the video controller 265 which controls the video display 270.

Computer system 200 also includes a communication adapter 290 that allows the system to be interconnected to a local area network (LAN) or a wide area network (WAN), as illustrated by bus 291 and network 295. .

The operation of computer system 200 is generally controlled and manipulated by operating system software. The operating system controls the allocation of system resources and, among other things, performs tasks such as scheduling, memory management, networking, and services.

Dynamic distributed computing

Dynamic distributed computing is generally a client server process. Client-server relationships are established for each call made and generally change roles. Typically, a client is defined as a process that invokes to request a resource that is found or controlled by the server. In this specification, a computer or processor executing a requesting process may also be referred to as a client. However, these roles may vary depending on the context of the information and the particular processing that occurs.

3 is a block diagram of a client-server networking environment used to practice one embodiment of the present invention. This figure includes a subsystem closely related to the present invention, with an emphasis on one embodiment of the present invention. Depending on the actual implementation, additional subsystems excluded from FIG. 3 may be required.

Thus, FIG. 3 includes a client 302, a server 316, and an object / method store 314, all operatively coupled to the network 312. Client 302 includes an application 304 that allows a remote computer 306 to process work on a remote server computer. Remote stubs 310, which are typically generated using a remote procedure call subsystem as described in the RMI specification, are used to package the parameters and data associated with a particular remote compute call 306. A typical client may also include a set of local objects / methods 308 that may include the type of work client 302 that the remote compute call 306 executes. Optionally, tasks may be located in object method repository 314 and accessed by compute method 320 as needed. The server 316 includes a remote Skelton 322 that unmarshalls the parameters and data sent from the client. Remote Skelton 322 prepares the information for use by compute method 320. Local object / method 324 also includes a task client 302 that can request processing from server 316.

In operation, remote compute call 306 calls compute method 320 to process a particular task. The remote stub 310 meshes information about the calling method so that the computer method 320 on the server 316 can execute the task. The remote stub 310 can also mesh basic parameters used as arguments by the compute method 320 on the server 302. The remote Skelton 322 receives the job, unmarshals the data and parameters received over the network, and provides them to the computer method 320. If the job and associated types are not available on server 316, Skelton downloads the types from client 302, object / method store 314, or other secure and reliable missing type source. The type information maps the location of the data within the object and allows the remote Skeleton to complete processing of the object. RMI (not shown) is one remote procedure call (RPC) system capable of providing a remote stub 310 and a remote Skelton 322. Once the object is processed by Skelton, compute method 320 executes the task and returns the computed task or computed task result to client 302.

4 is a flowchart of steps performed by a client using a dynamic distributed computing system and method in accordance with the present invention. Initially, the client selects a suitable server from the network to process the job (step 402). This selection criterion may be based on overall processing load balancing among a group of server computers or the dedicated computing capabilities of each server computer. For example, a load balancing technique can be used to automatically determine if a computer has the least load at a given moment. Furthermore, some work with dedicated hardware, such as graphics accelerators or match coprocessors, because the task must have intensive graphics calculations, such as rendering three-dimensional wireframes, or perform many floating point operations. The computer can be selected by the client.

Once the server is selected, the client invokes a remote compute method on the selected server (step 404). RPC systems, such as RMI, facilitate calling remote compute methods on server computers. Typically, a client needs to know that a remote computer method can be used as a conduit to handle a particular task on the remote computer. For example, in Java, the remote command "Server.runTask (newPI (10000))" executed on the client causes the remote method "runTask" to be called on the remote server "Server" of type "computeServer". This step provides the task as a parameter to the generic compute method via the remote method "runTask", in which case the task is a type task object instantiated by "newPI (1000)." The "runTask" method on the server Implement the Compute remote interface Optionally, this command can tell the server that the results from the computed task should be stored in the results cache on the selected server, which allows subsequent tasks to share the results between the cycles. For example, the result of calculating "PI" can be used later by other remote methods to calculate the volume of a sphere or to perform other exact calculations using the value of "PI".

The stub is then used to marshal the parameters and data into the work request. This work request is then provided to the selected server. Typically, a work request includes data and parameters about the work as well as the network location for the type or class, if not present on the server. Skelton on the server uses type or class information to process objects and unmarshal data and parameters. In systems using Java and RMI, work requests are objects, and class location information is contained in codebase universal record locator (URL) parameters. A detailed description of this is included in the RMI specification. The server can schedule a task for execution immediately or whenever the server finds a suitable time to execute the task. After the server performs the operation, the client receives a result from the computed task (step 408).

5 is a flowchart of steps performed by a dynamic distributed computing system and method in accordance with the present invention. First, Skelton on the server unmarshals the parameters and data from the job request and recreates the original job sent (step 504). Unmarshalling such parameters involves downloading some additional types. Skelton determines whether the type associated with the work request is available on the server (step 506). If the types associated with the work request are not available, Skelton must download the work from one of the areas on the network (step 509). For example, if the "PI ()" class does not exist on the server, the Skelton server will download this type from the client. Types or classes are used by Skelton to map data within objects and to unmarshal parameters and data.

Typically, a client will point to where a particular type is located in a request packet. Skelton can download the requested type from the object / method repository and cache the type for future server requests. In addition, the requested type may also be located on the client. For example, in Java and RMI, a class containing a particular type is located in a given codebase uniform record locator sent by the client. Dynamic class loading in RMI facilitates the automatic downloading of classes using the codebase. These types allow Skelton to parse work requests and extract the appropriate data and parameters. The steps described above make the parameters and data readily available for future processing.

Once the appropriate type is available, Skelton invokes a generic compute method (step 508). The comprehensive computer method on the server then executes the particular task requested by the client (step 510). For example, suppose a client calls "ComputeServer.runTask (newPI (1000)). Skelton will call the generic computer method" runTask "on the server. The" runTask "method will be used for tasks invoked by the client. Invoke the built-in "run ()" method, which also implements the remote interface "Compute", which maintains a remote connection with the client, at the time of client selection or at the specified configuration of the server. The turn saves the results from the computed work in the cache when the subsequent work uses the results As a final step for the server, the computed work or result executes "return.t.run ()" on the server Is returned.

Example Alternative Embodiment

According to the invention, the following code example is provided as an embodiment. Although the example is provided as an object-oriented Java programming language, other programming languages may also be used. For example, the server could contain the following Java code:

THE TASK

public interface Task extends Serializable {

// this interface has a class ("PI" class)

// run the abstract run () class

// allow

{

public Object run ();

}

THE REMOTE INTERFACE:

import java.rmi. *;

public interface Compute extends Remote {

// RMI / RPC Interface

public Object runTask (Task t) throws RemoteException;

// abstract runIt method

}

THE COMPUTE SERVER IMPLEMENTATION

import java.rmi. *;

import java.server. *;

public class ComputeServer extends UnicasRemoteObject

implements Compute {

public ComputeServer () throws RemoteException {}

// implement the Compute interface

// abstract "runTask" method

//..The code in this area is used to initialize the routine with the RPC system

public Object runTask (Task t) throws RemoteException

// runTask is defined in the ComputeServer interface

// implement abstract method

return t.run (); //

}

The following example Java code can be used on a client to perform dynamic distributed computing in accordance with the present invention.

class PI {

private int precision;

PI (int how ManyPlaces) {// sets precision of PI value to be calculated alter precision = howManyPlaces;

}

public Obejct run () {// execute abstract run method in compute interface

double pi = computePIsomehow (person); // calculate pi

return new Double (pi);

}

public static void (String [] args) {

ComputerServer server = getAComputerServer (); // select a server from the network, and remote to RMI

// abstract RPC on compute call

// save the remote interface

Double pi = server.runTask (new (1000)); // abstract method to execute the "pi" operation // defined in the "PI" class

//practice

System.out.println ("PI seems to be" + pi ") // returns the result in the" pi "variable // and prints it to standard

Although specific embodiments have been described herein for purposes of illustration, various modifications and changes may be made without departing from the scope of the present invention. Those skilled in the art will appreciate that the present invention may be implemented in a variety of software and hardware, and is not limited to the traditional routers, switches, and intelligent head devices described above. Accordingly, the invention is not limited to the above described embodiments, but instead is defined by the appended claims in light of the full scope of equivalents.

Claims (27)

A computer system having a main storage device, a secondary storage device, a display device, and an input / output mechanism. In a method that makes it possible to disperse, Selecting a server from among a plurality of heterogeneous servers to process a task based on overall processing load balancing among the collection of server computers and the special computing capabilities of each server computer; Marshalling parameters and data in a task request, wherein the Marcell step determines whether code and data related to the requested task exist on the selected server, and wherein the code or data type is Downloading the code and associated data type to the selected server when not present at the selected server; Invoking a generic compute method associated with the selected server to execute the task, wherein the invoking step comprises providing the task as a parameter to the comprehensive compute method, and subsequent tasks. Indicating to the server that the results from the operation computed for use should be stored in a result cache on the selected server; And Receiving the computed job again from the selected server for future processing on the client. Performed on a processor contained within a computer system having a main storage device, an auxiliary storage device, a display device, and an input / output mechanism, wherein the server associated with the set of server computers is configured to dynamically receive and process work from the client computer. Wherein the task is an executable programming language that is compatible with each of the server computers. Unmarshalling parameters and data from the job request to the job, wherein the unmarshall step determines whether the types involved in the job are available on the server and whether the types associated with the job are not available on the server. Including a substep of determining; Downloading the types to the server from the location indicated by the client; Invoking a comprehensive compute method capable of processing all tasks, the executing the task and generating a result; Storing a result from the executed job in a cache if a subsequent job can use the result; And Returning a result from the executed task to the client. A method performed on a processor operably coupled to a collection of servers, the method associated with enabling a client associated with the processor to dynamically distribute work to servers. Selecting a server to process the job; Forming a work request from parameters and data; Invoking a comprehensive compute technique capable of executing the work request against the selected server and sending the work request to the selected server generating a result; And Receiving the result again from the selected server. 4. The method of claim 3, wherein the processor is operably coupled to a computer system having a main memory device, an auxiliary memory device, a display device, and an input / output mechanism. 4. The method of claim 3, wherein the task is developed in a programming language and environment that is compatible with each of the server computers. 4. The method of claim 3, wherein the server is selected from a plurality of heterogeneous computer systems. 6. The method of claim 5 wherein the environment comprises a remote procedure call subsystem. 8. The method of claim 7, wherein the remote procedure call subsystem is a remote method call (RMI) system. 4. The method of claim 3, wherein the criteria for selecting a server includes overall processing load balancing between sets of server computers. 7. The method of claim 6, wherein the selected server has the lowest load characteristic compared to the average load characteristic of the server over a predetermined time period. 4. The method of claim 3, wherein the criteria for selecting a server includes the special computing capabilities of each server computer. The method of claim 11, wherein the special computing capability comprises a rendered image. The method of claim 3, wherein the transmitting step Determining whether a code associated with the requested task exists in the selected server; And Downloading the code to the selected server when the code is not present on the selected server. The method of claim 3, wherein the transmitting step, Providing the task as a parameter to the global compute method. 4. The method of claim 3, further comprising indicating to the server that the result from the computed task should be stored as a result in a cache on the selected server for use in subsequent tasks. 4. The method of claim 3, wherein the result is used to further process for the client. The method of claim 3, wherein the result is an object. Performed on a processor operatively coupled to a collection of servers, the server associated with the processor to dynamically receive and process a task from a client computer, wherein the task is executable to be compatible with each of the server computers. Is a possible programming language, Retrieving parameters and data from the job request in the job; Invoking a comprehensive compute method on the server capable of processing a plurality of job types and executing the job and generating a result; And Returning a result to the client. 19. The method of claim 18, wherein the processor is operably coupled to a computer system having a main memory, an auxiliary memory, a display device, and an input / output mechanism. 19. The method of claim 18, wherein the task is developed in a programming language compatible with each of the server computers. The method of claim 18, wherein the task is developed using a Java programming language and environment. 22. The method of claim 21 wherein the environment comprises a remote procedure call subsystem. 23. The method of claim 22, wherein the remote procedure call subsystem is a remote method call (RMI) system. The method of claim 18, wherein the searching step, Determining whether types associated with the task are available on the server; When the types are available on the server, downloading the types to the server from the location indicated by the parameter provided by the client; And Executing the task based on the data and parameters provided by the client. 25. The method of claim 24, wherein said determining step and said downloading step are performed by a remote procedure call (RPC) subsystem. 27. The method of claim 25, wherein the determining step is performed by a remote method call (RMI) type of a remote procedure call subsystem. 19. The method of claim 18, further comprising the step of storing the result from the job in a cache if a subsequent job uses the result.