CN1258704C - Method for using synergic multiple computer engines based on gridding environment - Google Patents

Abstract

The present invention relates to a method for cooperatively using multiple computing engines on the basis of grid environment, which is characterized in that With the support of the GT3 version of OGSA, a remote computing node and a user end computing node make use of the support of an operating system on which jdk 1.4 and Java 1.4 runtime environment are installed, and applies a GridFTP protocol, and thereby, the user computing node can query a list of registered remote computing nodes from a registration node, and utilize a cooperative computing software package of a client to cooperatively use computing resources distributed over a grid. The present invention has the basic method that the computing resources are packaged by using a GridService through a uniform computing interface, and the client allocates subtasks to the remote computing node through an interface provided by the GridService so as to cooperatively execute the subtasks. The method can effectively integrate the software and hardware resources of high performance computation so as to obtain computing capability and storing capability of high efficiency.

Description

Many computing engines Synergistic method based on grid environment

Technical field

Belong to high-performance grid computing technology field based on the collaborative using method of many computing engines of grid environment

Background technology

Gridding technique is a kind of important information technology of rising in the world in recent years, and its target is high-performance resource sharing and the collaborative work that realizes on the grid virtual environment, eliminates information island and resource isolated island.The technology relevant with it comprises: Real-Time Enterprise infosystem, gridding virtual design environment, technique of internet, information management, XML technology, ASP technology, Web service technology (webservice), semantic net (semantic web) and high-performance calculation.

This method is exactly a kind of grid computing technology that proposes at the high-performance calculation under the grid environment.Present a lot of R﹠D institutions, government department all has the very strong supercomputer of computing power, but these machines are often because just isolated not playing one's part to the full for our unit serves is in idle condition in the most of the time; And on the other hand, also have a lot of schools or R﹠D institution not to have the ability of this supercomputer, but they often need this supercomputer to finish some scientific research project or other high-performance calculation task.

The collaborative using method of our designed this grid computing engine is on the basis that the supercomputer on the internet is utilized grid system integrate, realize the sharing of various Heterogeneous Computing softwares (instrument) on it, and the collaborative use service of various Heterogeneous Computing softwares (instrument) further is provided.As long as the user applies for the use certificate of these supercomputers and just can use these computational resources that for the calculation task of super large calculated amount, the user can also utilize many supercomputers to work in coordination with and finish calculating simultaneously.

Common grid system only provides sharing of computing power resource, and promptly the user can utilize the hardware resource that it is shared, but also inconvenient to the use of these computational resources, can not directly use the various computational resources that are distributed on the grid simultaneously.

The technology similar to this method mainly contains MPI multiple programming storehouse, but there is following shortcoming in MPI multiple programming storehouse:

1. because user's program is moved on computation host, so the user just must clearly know the installation path of various softwares.

2.MPI it is living requiring the memory location of user program on every station server of executed in parallel, and this requirement is difficult to accomplish for each service node that is under the grid environment.

3.MPI program also must be understood the name list of each main frame that is used to carry out this concurrent program when carrying out, and this name list must be monolithic on each node, this grid environment for dynamic change also is inapplicable.

Summary of the invention

The object of the present invention is to provide a kind of collaborative using method of the many computing engines based on grid environment that is suitable for using.

The invention is characterized under the support of Open Grid Service framework Globus Toolkit 3.0 versions, the remote computation node is by means of the support of the operating system that JDK1.4 and java 1.4 runtime environments have been installed, use the reliable file host-host protocol GridFTP under the grid environment, after unified register node computing machine registration, join in the above-mentioned grid environment, the user node computing machine is equally by means of the support of the operating system that JDK1.4 and java1.4 runtime environment have been installed, by tabulating to obtain effective computing node to the register node computer inquery, the collaborative calculating interface that provides by this locality visits the respective remote computing node again, uses the various computational resources that are distributed on the grid thereby can work in coordination with; Above-described each process comprises following steps successively:

Step 1 user inquires about effective node to register node;

Step 2 is then obtained node listing if effectively node exists;

Step 3 is obtained the ComputePool interface and is entered the mouth and start computing, and this step 3 contains following steps successively:

Step 3.1 is established to the connection of remote computation node;

Task program and desired node number that step 3.2 is submitted to according to the user are created the execution thread of respective number, and are the node corresponding in remote computation node listing of each thread distribution number;

Step 3.3 starts each thread, in each thread, will carry out user Task program;

Step 3.4 waits for that all thread execution finish;

Being connected of step 3.5 release and remote computation node;

The task termination of step 4 user node;

Program on the step 5 remote computation node provides service to use to the user according to the following steps:

Step 5.1 remote computation node receives that the user asks;

Step 5.2 remote computation node is judged user's request;

If step 5.3 DriverManager interface requests then according to the request of registration of request type executive software or cancellation, is returned waiting status;

If step 5.4 ServiceInfo interface requests, then query software returns lookup result and gives the user;

If step 5.5 ComputeService interface requests is then carried out corresponding operating respectively according to request type:

If step 5.5.1 sets up or eliminate example, return waiting status after then operation is finished to listen attentively to user's request;

If step 5.5.2 operates example,, carry out corresponding operating respectively then according to action type;

If step 5.5.3 file operation, the reliable file host-host protocol GridFTP that then calls under the grid environment carries out file transfer;

If step 5.5.4 task is carried out, then select corresponding software to execute the task by the ComputeDriver interface;

If step 5.5.5 Mission Monitor is then carried out monitor task.

The invention has the advantages that Architecture at Open Grid Service framework Open Grid Service, the realization version Globus Toolkit 3.0 that is OGSA is under the support of GT3 version, the remote computation node is the support of remote node computing machine by means of the operating system that JDK1.4 and java 1.4 runtime environments have been installed, use the reliable file host-host protocol GridFTP under the grid environment, after unified register node computing machine registration, join in the above-mentioned grid environment, the user node computing machine is equally by means of the support of the operating system that JDK1.4 and java1.4 runtime environment have been installed, by tabulating to obtain effective computing node to the register node computer inquery, the collaborative calculating interface that provides by this locality visits the respective remote computing node again, uses the various computational resources that are distributed on the grid thereby can work in coordination with.

We realize collaborative Calculation Method for this cover that the distributed grid computational resource proposes, and its basic characteristics have:

1. based on the ways of services supplied of WebService, have all advantages of WebService, be suitable for wan environment fully.

2. by criterion calculation interface (ComputeDriver) concrete software for calculation and service interface are separated, whether the user only can carry out this calculating with the care server, and does not need to know specifically be with what software to calculate.

3. the control of the execution of subtask and overall tasks separately, server only is responsible for a sub-task executions, the control of whole calculation task is transferred to the client and is brought in management, simplified the design of service end, also made things convenient for simultaneously the writing of user application (user flexibly control task execution and obtain the task executions state).

4. adopt file transfer protocol (FTP), guaranteed the reliability of large-scale data file transfer under the high-performance computing environment based on GridFTP.

Description of drawings

Fig. 1. the interface relationship figure of remote computation node

Fig. 2. the collaborative resource schematic flow sheet that uses of user node

The service corresponding relation figure that main interface of Fig. 3 .SubTask program and remote computation node Service provide

Fig. 4. register node software interface figure

Fig. 5. the overall relation figure of the method for the invention

Fig. 6. the user uses the process flow diagram of service

Fig. 7. the program flow diagram of remote computation node

Fig. 8. the realization flow figure of user side ComputePool

Fig. 9. register node data information memory distribution plan

Figure 10. remote computation node data information stores distribution plan

Figure 11. user node information stores distribution plan

Embodiment:

Open Grid Service Architecture is called for short OGSA, just proposes in the grid computing field, and at the architecture of resource sharing under the grid environment and service access, about specific descriptions and interface realization and the visit of OGSA, can reference Http:// www.globus.orgFollowing related article.

Globus Toolkit is the project of increasing income as the grid computing architecture, and its up-to-date 3.0 editions are to issue as the realization of OGSA, a kind of programming mode of realizing the described mesh architecture of OGSA is provided for the programmer, and provided corresponding system interface configuration and various DLL (dynamic link library) have been installed.Our collaborative using method of the many computing engines based on grid environment realizes on the basis of globus toolkit 3.0.

Here the interface of mentioning is divided into two classes: the interface on remote computation node and the register node is the GridService service interface of being mentioned in the OGSA standard, the user can conduct interviews by the described access mode of OGSA standard ( Http:// www.globus.org); The interface of client is that we are the DLL (dynamic link library) that client-side program person provided, and when the programmer writes the application program of oneself, can work in coordination with the computational resource that uses in the grid environment by these interfaces and finish the task of oneself.

◆ the remote computation node

We are packaged into Grid Service with the calculation services on the remote computation node calculation services (ComputeService) externally are provided according to the standard of OGSA.Local software for calculation is registered to local data base then and just can be visited by ComputeService by the user as long as realize the ComputeDriver (being similar to the relation of database and ODBC driver) of oneself.

Three class software interface: DriverManager, ServiceInfo and ComputeService are provided on the remote computation node.

DriverManager is used for the registration and unregistration of software for calculation, and interface method is defined as follows:

RegisterDriver (catalog, softname, driverclassname, driverpackage) // registration ComputeDriver

UnregisterDriver (catalog, softname) // cancellation ComputeDriver

Wherein catalog is the classification under the software for calculation, and softname is a dbase, and driverclass is the title for the designed ComputeDriver of this software, and driverpackage is and the routine package of realizing this ComputeDriver.How to realize that about ComputeDriver we will be introduced in the back.

The ServiceInfo interface is used to inquire about provides for which service on the computing node, and whether these services are current effective, service quality and current state, and the interface method definition has:

String ListServices () // the list relevant information of the software of all registrations on the computing node

ServiceStatus getServiceStatus (catalog, softname) // obtain the information on services of this kind software, comprise validity, efficiency of service and current state.

The ComputeService interface is the interface that calculation services externally is provided, and the user is by the use of this interface realization of visit to the software for calculation on this node.Consider dirigibility and versatility, we provide following interface method

Upload (filename, userhostport) // file upload

Download (filename, userhostport) // file in download

String remotesend (filename) // be ready for sending file to another node

Remotereceive (filename, remotehostport) // accept file from another node

Execute (catalog, softname, commandline, type) // task submission and execution

Whether IsJobOver () // detection task is finished

Getresult () // obtain task action result

Wherein, four interface methods in front are used for data file transmission, because data file may very big (as weather forecast, petroleum prospecting), so we have adopted GridFTP (the reliable file host-host protocol that is used for grid environment) technology to be realized.

In addition, in order to realize the collaborative work between a plurality of remote nodes, Data transmission between these nodes possibly just, but because grid computing environment is that dynamic change is very big, a remote node is not understood the information of user on other remote node, but the several remote nodes that carry out collaborative work all are to be same user service, therefore will be between several remote nodes Data transmission, the best way is exactly startup and the end that is come control transmission by this user.Remotesend and remotereceive interface method are exactly the file transfer that is subjected between the remote node that the user controls.Wherein remotesend tells distance host to set up listening port, and prepares transfer files filename, returns remotehostport then and gives the user; The user calls the remotereceive interface of another node then, tells it to prepare to be subjected to file in the remotehostport termination.

The execute interface method is used for the submission task and begins carrying out, and wherein catalog indicates the classification that will use software, and softname indicates and uses which software for calculation, and type indicates the implication of commandling, specifically has following three kinds

1.Type equal 1 expression COMPUTE_XML format string

2.Type equal 2 expression simple characters strings

3.Type equal 3 expression order line call parameters, can comprise filename and the export file name uploaded the front.

Whether the user comes test assignment complete by IsJobOver () interface method.

The getresult interface method is to be used to obtain the results of task execution value, is mainly used in the smaller situation of result, and when result set was bigger, the user can download destination file by download (resultfilename).

Introduce the design of ComputeDriver below

ComputeDriver mainly designs in order to connect ComputeService and software for calculation, and the user unifies and standardized calculation software by the ComputeDriver of design count software.The design of ComputeDriver is very simple, the user if the interface method of realizing ComputeDriver as follows with the java language both can:

import?org.tsinghua.ComputeDriver；

import?org.tsinghua.ServiceStatus；

pubilc?class?MyComputeDriver?implements?ComputeDriver{

public?boolean?connect(String?usemame，String?password){...}

public?void execute(String?commandline，int?type){...}

public?String getresult(){...}

public?String getresultfile(){...}

public?ServiceStatus?getStatus(){...}

public?String getHelp(){...}

}

Here the function that relates to SOME METHODS is as follows:

Connect:: set up and being connected of software for calculation, user's ComputeDriver can be used for the initialization user data to this interface.

Execute: specifically carry out the task that the user submits to

Getresult: obtain task action result

Getresultfile: the memory location that obtains the results of task execution file

GetStatus: obtain application state information

GetHelp: obtain the software using method, comprise command line parameter, the data layout of support.

The user finishes writing according to above method after the ComputeDriver of oneself, and the RegisterDriver method under the DriverManager interface of the standard access way access node by OGSA is registered up oneself ComputeDriver and got final product.

◆ the registration of remote computation node and inquiry

As computing node, must just can join in the grid environment to unified registration body's registration, and the user also is by just can obtain effective computing node tabulation to the register node inquiry.Register node provides two kinds of software interface method: FindService and RegisterService.The same with the interface on the remote computation node, these interface methods are also according to the OGSA standard design, and the user must could visit these interfaces by the standard access method that OGSA gave.

Vector?FindService(String?servicecatalog，String?QoS，int?number)；

The FindService interface method is according to the desired type service servicecatalog of user, service quality QoS and required interstitial content, return to the user the tabulation of operable computing node, the user tabulates according to the computing node that provides in this tabulation then and finishes the calculation task of oneself.

Bool?RegisterService(String?serviceurl，String?servicecatalog，String?QoS)；

Computing node is registered to register node by the RegisterService interface method, register node can be according to the node address serviceurl that it transmitted, and type service servicecatalog and service quality QoS are registered to this computing node in the system database.

◆ user node calculates interface

With the interface difference on the remote computation node, calculating interface on the user node provides the DLL (dynamic link library) to the user side programmer, because we have encapsulated the standards service browsing process of OGSA in the code of these interfaces, the programmer need not to know the standard of OGSA, just can come with the computational resource under the collaborative use grid environment by these interfaces.

The interface that we far provide for the user side program mainly is made of two parts, a part is the Task routine interface that is used to write user task, system is when this Task program of execution, just and the ComputeService on the concrete computing node carry out alternately, the DLL (dynamic link library) of the Task program that the user provides by us realize and computing node on ComputeService communicate, reached the purpose of collaborative use computing node calculation services.Another part is and the direct mutual ComputePool of user application that ComputerPool searches effective node for the user provides, initialization node, interface functions such as submission Task program.Introduced this two parts DLL (dynamic link library) below respectively.

1.ComputePool defined following interface function:

Vector FindService (String catalog, String softname) // search the current effective computing node to the service registry node.

Initialize () //, be established to the connection of each computing node according to customer requirements.

Submit (String taskclassname, int nodenum) // submission user Task program

Wait () // wait task is carried out and is finished

Finalize () // finish connection to each computing node

2. the routine interface that is used for the Task file

By ComputePool, the user only need resemble and write a Task program the MPI user, submits to ComputePool then and carries out just passable.Write the Task program, the routine interface that the user need use us to provide can be worked in coordination with and be used computational resource on a plurality of computing nodes.

Interface function is described below:

A. nodal information interface

Getnodeid () // obtain node serial number

B. carry out data transmission interface with node

Upload (localfile, remotefile) // upload data file

Download (localfile, remotefile) // download data files

Localfile: local file absolute path

Remotefile: remote target file relative path

C. task executive's interface

Execute (commandline, type) // the obstruction mode executes the task

Synexecute (commandline, type) // the unblock mode executes the task

Under isjobover () // unblock mode, whether query task carries out end

Under waitexecute () // unblock mode, wait task is carried out and is finished

String getresult () // obtain task action result

Commandline: command string

Type: character string type

D. node interactive interface

Sendfile (sorucefile, targetid, targetfile) // send file to another node

Receivefile (targeted) // receive file from another node

Sendvalue (targeted, message) // send data to another node

Receivevalue (targeted) // receive data from another node

Sourcefile: source node file relative path

Targeted: destination node number

Targetfile: destination node file relative path

Message: the message of transmission

E. reported information interface

Reportstatus (message) // to clients report task implementation status

Message: the information of repayment

Client programming example (simple case of a symbolic computation)

Below we provide a distributed symbolic computation example, the key problem in the middle of the is-symbol that this example calculates is calculated: polynomial expression greatest common factor (GCD) is calculated.Infinite precision book system and polynomial system that this computational problem must provide with symbolic computation software are that finish on the basis, and common programming language is not supported.We are the computing engines of computing node with symbolic computation software systems ELIMINO, the collaborative using method of the many computing engines that utilize us to realize then, be implemented in a plurality of ELIMINO of deployment system in the grid, coarse grain parallelism is finished the environment of finding the solution of polynomial expression GCD problem.

The client master routine:

Public class ModApp{ public static void main (String[] args) { ComputePool pool=ComputePool.getInstance (); // obtain ComputePool interface accessing inlet String[] hostlist=pool.FindServiee (" MathService/Elimo ");=null﹠amp; Amp; ﹠amp; Amp; Hostlist.size ()＞0) { pool.Initialize (hostlist); // initialization ComputePool pool.Submit (hostneeded, " MyTask ", app); // submission Task program pool.Wait (); Pool.Finalize ();

User Task program:

Public class MyTask extends Task{ public void run () { int id=getnodeid (); // obtain the subtask to number String[] commands=new String[3]; Commands[0]=" pmod_gcd (P1, P2,2003) "; Polynomial expression GCD on the // Galois field calculates commands[1]=" pmod_gcd (P1, P2,2011) "; Commands[2]=" pmod_gcd (P1, P2,2017) "; Synexecute (" elimo command[id-1] ", 3); // with the command line mode waitexecute () that executes the task;＜!--SIPO＜DP n=" 6 "〉--〉＜dp n=" d6 "/String r=getresult (); If (id==1) { String r2=receivevalue (2); The result of calculation String r3=receivevalue (3) that // receiving node 2 transmits; The result of calculation that // receiving node 3 transmits //, be lifted out the real greatest common factor command=of polynomial expression according to the result of calculation of each node on Galois field " GCDlift ([2003,2011; 2017]; [" + r+ ", "+r2+ ", "+r3+ "]) "; Execute (" elimo command ", 3); Waitexecute (); // wait result of calculation r=getresult (); // obtain result of calculation } else if (id＞1﹠amp; Amp; ﹠amp; Amp; Id＜4) { sendvalue (1, r); // transmission result of calculation } } }

The specific implementation method is shown in Fig. 8-10, and the distribution of data in storer is Fig. 9-11

1. the realization of each interface on the remote computation node

The hardware environment that the remote computation node needs: CPU 800MHZ, internal memory 128M.

The software environment that needs: the operating system, Java1.4 runtime environment and the globus toolkit 3.0 that support JDK1.4.

At server end, we design each service interface of realizing us on the architecture of globus toolkit 3.0, because globus toolkit can help us to finish from the client-requested to the physical interface, as long as we provide corresponding configuration file at server end therefore, and design concrete interface code, just can be written into internal memory to our interface for client-access during globus system start-up.

According to the standard of OGSA, we realize each interface at server end with the java language.

For each interface, represent with an interface class in the iava respectively, just can describe as the ServiceInfo interface with following interface:

interface?class?ServiceInfo{

Vector?ListService()；

ServiceStatus?getServiceStatus(String?catalog，String?softname)；

Also can being described in a like fashion of DriverManager and ComputeService interface.

To associate above interface and corresponding interface sign by following statement in configuration file, the user just can have access to corresponding interface by interface identifier.

<service?name＝″tsinghua/ServiceInfo″provider＝″Handler″style＝″wrapped″>

<parameter name＝″instance-schemaPath″value＝″schema/ServiceInfo/ServiceInfoService.wsdl″/>

Wherein " tsinghua/ServiceInfo " is exactly the sign of this interface, and following " schema/ServiceInfo/ServiceInfoService.wsdl " represents that the corresponding interface of this sign describes in the schema/ServiceInfo/ServiceInfoService.wsdl file that leaves under the current directory.

The interface description has been arranged, the realization of interface also must have been arranged, according to the form of java language, the realization of each interface as follows:

  　public class ServiceInfoImpl implements ServiceInfo{　　       Vector ListService(){　　                Enumeration drivers＝DriverManager.getDrivers()；　　                Vector list＝new Vector()；　　                While(drivers.hasMoreElements()){　　                   List.add(drivers.nextElement())；        <!-- SIPO <DP n="7"> -->        <dp n="d7"/>　　                }　　                return list；　　        }　　      ServiceStatus getServiceStatus(String catalog，String softname){　　             ComputeDriver driver＝DriverManager.getDriver(catalog，softname)；　　             ServiceStatus status＝new ServiceStatus()；　　             Status.setName(driver.getName())；　　              Status.setQos(driver.getQos())；　　              Status.setState(driver.getState())；　　             Status.setValid(driver.isValid())；　　       }　　}

Here implements ServiceInfo is the standard of iava language, represents that this class must realize the total interface method of this interface of ServiceInfo.The realization of other interface and ServiceInfo are similar.

In configuration file and the interface related configuration of ServiceInfo, add the deposit position that the code of interface correspondence described in following statement then.

<parameter?name＝″instance-baseClassName″value＝″org.tsinghua.impl.ServiceInfoImpl″/>

Just the interface of front is described with actual interface code and associated.

2. the implementation method of register node

The hardware environment that register node needs: CPU 800MHZ, internal memory 128M.

Software environment: the operating system, Java1.4 runtime environment, the globus toolkit 3.0 that support JDK1.4.

Can provide service registry and query interface as long as register node has been installed Globus Toolkit3.O, so we need not install any other software in register node.

3. client-side interface implementation method

According to the standard of OGSA, client must visit the interface on the remote computation node with following standard:

OGSIServiceGridLocator?factoryService＝new?OGSIServiceGridLocator()；

Factory?factory＝factoryService.getFactoryPort(new?URL(serviceuri))；

GridServiceFactory?gridFactory＝new?GridServiceFactory(factory)；

LocatorType locator=gridFactory.createService (); New service of // generation

OGSIServiceGridLocator?gridLocator＝new?OGSIServiceGridLocator()；

Computer=gridLocator.getGridServicePort (locator); // obtain access entrance to the remote computation interface

Annotate: serviceuri refers to the interface identifier of remote node here, and how concrete sign represents the configuration file decision by a preceding part.

As mentioned before, when specific implementation, we are encapsulated in the mode of above-mentioned access interface in our designed the client DLL (dynamic link library), and client-side program person calls in our DLL (dynamic link library) just can reach the function that visit remote computation node is served.

The environmental requirement of client-side program operation is as follows:

Hardware environment: CPU 800MHZ, internal memory 128M;

Software environment: support operating system, Javal.4 runtime environment, the globus toolkit 3.0 of JDKl.4 and the client software bag that we are designed.

Client-side interface is realized mainly containing two parts and is constituted: ComputePool and ComputeTask.

Wherein to be us be encapsulated into our designed corresponding DLL (dynamic link library) with the front to the browsing process of remote computation node interface to ComputeTask, and the user must inherit from ComputeTask when designing own Task program, and realizes its run method.As follows:

　　public class MyTask extends ComputeTask{　　   public void run(){　　       upload(datafile)；　　       execute(“elimo gcd(20032011，13)”，3)；　　       String result＝getresult()；　　       System.out.println(result)；　　    }　　}

ComputeTask can convert the visit of user to DLL (dynamic link library) to ComputeService interface on the remote computation node visit.ComputeTask can obtain the access entrance of ComputeService interface on the remote computation node earlier initialized the time, then when each user calls DLL (dynamic link library), user's request is forwarded to the remote computation node and gets on by changing this access entrance.The partial code of ComputeTask is as follows:

　　abstract class ComputeTask{　　    GridService         obj；　　    ComputerService       computer；　　    public init(String serviceuri){　　        OGSIServiceGridLocator factoryService＝new OGSIServiceGridLocator()；　　        Factory factory＝factoryService.getFactoryPort(new URL(serviceuri))；　　        GridServiceFactory gridFactory＝new GridServiceFactory(factory)；　　        LocatorType locator＝gridFactory.createService()；　　       OGSIServiceGridLocator gridLocator＝new OGSIServiceGridLocator()；　　        obi＝gridLocator.getGridServicePort(locator)；　　       ComputerServiceGridLocator computerlocator＝new ComputerServiceGridLocator()；　　        computer＝computerlocator.getComputerService(locator)；　　       uid＝computer.getuid()；　　    }　　    public fina1ize()throws throwable{　　       obj.destroy()；　　    }　　    ......　　    public Boolean upload(String filename){　　       TransferTask task＝new TransferTask(filename，TransferTask.TASK_PUT，null)；　　        task.start()；　　        boolean r＝computer.upload(remotefile，task.getHostPort())；　　        if(r){　　               transferlock＝new Object()；　　               synchronized(transferlock){　　                   transferlock.wait()；　　            }　　       }　　       task.stop()；　　      retum  r；　　  }　　  ......        <!-- SIPO <DP n="9"> -->        <dp n="d9"/>　　}

ComputePool is another part of our designed client DLL (dynamic link library), and by the DLL (dynamic link library) method that ComputePool provided, client-side program person can realize the inquiry to the remote computation node, and the submission of task and multinode calculate collaborative the execution.The interface of ComputePool is realized fairly simple, and wherein the realization of FindService interface is very similar with ComputeTask, and just the FindService visit is FindService interface on the register node.Initialize and Finalize interface are mainly finished the function that discharges resource when the initialization of internal data and program withdraw from.

When mainly introducing the user here and submitting the Task program to, the groundwork of ComputePool.

When the user called the submit interface of ComputePool, it was available can telling ComputePool which remote computation node will be arranged, and the name of task program and task program run need several nodes.ComputePool finishes following a few step work then: 1. the task program name of being given according to the node number and the user of user's needs, generate the example of corresponding number, and as follows

Code:

for(I＝0；I＜neednum；I++){

Node[I]=Class.forName (taskname) .newInstance (); 2. these examples of initialization

for(I＝0；I＜neednum；I++){

node[I].initialize(host[I％hostnum])；

3. set up a thread operation for each example

for(I＝0；I＜neednum；I++){

Thread[I]＝new?Thread(node[I])；

Thread[I].start()；

4. wait for all example end of runs

for(I＝0；I＜neednum；I++){

Thread[I].wait()；

}

Because this method is the collaborative use that is used for the many computing engines under the grid environment, so depositing and using of software interface had suitable dirigibility.The software package of remote computation node can place the arbitrary position on the computing node, needs only to start the service routine that software package provided, and gets final product to the address of service of register node registration oneself.Writing and moving of the program of client is also very flexible, as long as the DLL (dynamic link library) that provides according to us is write the Task file, start Task by ComputePool then and just can work in coordination with a plurality of computing nodes under the use grid environment and finish the calculation task of oneself.

Claims (1)

1, based on the collaborative using method of many computing engines of grid environment, it is characterized in that, under the support of Open Grid Service framework GlobusToolkit 3.0 versions, the remote computation node is by means of the support of the operating system that JDK1.4 and java 1.4 runtime environments have been installed, use the reliable file host-host protocol GridFTP under the grid environment, after unified register node computing machine registration, join in the above-mentioned grid environment, the user node computing machine is equally by means of the support of the operating system that JDK1.4 and java1.4 runtime environment have been installed, by tabulating to obtain effective computing node to the register node computer inquery, the collaborative calculating interface that provides by this locality visits the respective remote computing node again, uses the various computational resources that are distributed on the grid thereby can work in coordination with; Above-described each process comprises following steps successively:

Step 1 user inquires about effective node to register node;

Step 2 is then obtained node listing if effectively node exists;

Step 3 is obtained the ComputePool interface and is entered the mouth and start computing, and this step 3 contains following steps successively:

Step 3.1 is established to the connection of remote computation node;

Task program and desired node number that step 3.2 is submitted to according to the user are created the execution thread of respective number, and are the node corresponding in remote computation node listing of each thread distribution number;

Step 3.3 starts each thread, in each thread, will carry out user Task program;

Step 3.4 waits for that all thread execution finish;

Being connected of step 3.5 release and remote computation node;

The task termination of step 4 user node;

Program on the step 5 remote computation node provides service to use to the user according to the following steps:

Step 5.1 remote computation node receives that the user asks;

Step 5.2 remote computation node is judged user's request;

If step 5.3 DriverManager interface requests then according to the request of registration of request type executive software or cancellation, is returned waiting status;

If step 5.4 ServiceInfo interface requests, then query software returns lookup result and gives the user;

If step 5.5 ComputeService interface requests is then carried out corresponding operating respectively according to request type:

If step 5.5.1 sets up or eliminate example, return waiting status after then operation is finished to listen attentively to user's request;

If step 5.5.2 operates example,, carry out corresponding operating respectively then according to action type;

If step 5.5.3 file operation, the reliable file host-host protocol GridFTP that then calls under the grid environment carries out file transfer;

If step 5.5.4 task is carried out, then select corresponding software to execute the task by the ComputeDriver interface;

If step 5.5.5 Mission Monitor is then carried out monitor task.

Images