论文部分内容阅读
摘 要：网格计算是分布式计算的一种方式，它的目的是要实现虚拟组织中资源（如CPU、存储器等）的共享。针对计算密集型应用中传统的分布式计算模式的不足，利用Java程序的跨平台特性，提出了网格计算中代码上载的思想，并给出了其一个模型的设计和实现。
关键词：网格计算 计算密集 Java 代码上载
中图分类号：TP302.1 文献标识码：A 文章编号：1673-8454（2008）23-0022-03
根据共享资源的不同，网格计算可以分为计算密集型和数据密集型等（即计算网格和数据网格）。计算网格对CPU和存储器资源要求较高，而计算中需要的数据较少。[1] 传统的分布式计算技术，例如CORBA，RMI和DCOM中资源共享通常局限于一个固定的组织，这种共享是静态的，并且开销较大。[2] 本文针对计算密集型应用中传统的分布式计算模式的不足，提出了网格计算中代码上载的思想，并给出了一个支持代码上载的网格模型的设计和实现。
一、网格模型设计
支持代码上载的网格模型如图1所示。为了实现网格服务的透明性，本模型设计中在用户所在的机器上设置了一个用户代理。
用户代理具有以下职责：（1）与用户交互：接收用户执行某程序代码请求,最后将计算结果呈现给用户；（2）与信息服务交互：根据用户提供的要求向信息服务查询，并收到符合要求的计算引擎的IP地址和服务端口；（3）与计算引擎交互，将用户提交的程序代码传送给计算引擎，并接收计算结果。
每当有一个新的计算引擎启动时，它就会自动连接信息服务，并将它的信息发送给信息服务，并请求在信息数据库中注册；当有用户代理查询符合某要求的计算引擎时，信息服务根据该要求从信息数据库中查询和选择负载较轻的计算引擎，并将该引擎的IP地址和端口发送给用户代理；当某计算引擎的当前负载状况等特征改变时，它也将这些改变通知信息服务，信息服务及时更新信息数据库中的相关信息。这样信息数据库就实时地动态反映了网格环境中的计算资源。
本模型的实现基于客户/服务器模式，利用了现有的广泛存在的TCP/IP通信协议，并采用Java语言进行开发。
二、实现细节
由于篇幅有限，本文只介绍计算引擎、用户代理和相关辅助类的实现，并且假定用户代理已经从信息服务那里查询到了计算引擎所在的IP地址和服务端口。
1.辅助类的实现
用户代理将编译过的用户程序（扩展名为class）发送给计算引擎，计算引擎接收该代码文件并存于本地，然后JVM中的解释器加载该代码文件中的类并执行。大致框架如下：
Class c = cl.loadClass(classname,bytecode, 0, bytecode.length);
Object o=c.newInstance();
((SomeInterface)o).someClassMethod();
不能将引用 o 转换到someClass，因为这时计算引擎还不直接知道传送来的类名（通过后面所讲的类Task的属性TaskName可以间接知道）。为此用户程序必须继承一个抽象类或实现一个接口（这里用接口），并且在用户代理和计算引擎所在的机器上部署该接口，由于接口名称是事先已知的，从而可以动态执行用户代理传来的任何用户代码。接口定义Skeleton.java如下：
import java.net.*;
public interface Skeleton {
void run(Socket s);}
用户程序类必须实现该接口，给出方法run的具体实现。假设用户程序类用来计算fibonacci数列中的第40项，则用户程序类Compute.java的代码如下（本文代码省略了相应的import语句）：
public class Computeimplements Skeleton{
public void run(Socket s){
DataOutputStream os = null;
try{
os = new DataOutputStream(s.getOutputStream());
long a=fib(40);
String output="The fib(40) is " a;
System.out.println(output);
os.writeBytes(output); }
catch(IOException e) {
System.out.println("Erorr io: " e);}
}
public long fib(long n)
{if (n<3)
return(1);
else
return(fib(n-2) fib(n-1));}
}
还有一个辅助类Task.java，它封装了一个字符串和byte数组，用来传送用户的代码文件，由于要通过Socket发送Task对象，所以类Task必须实现Serializable接口。Task.java的代码如下：
public class Task implements Serializable{
public String TaskName;
public byte ByteCode[];
public Task (String n,byte b[])
{this.TaskName=n;
this.ByteCode=b;}
}
和Skeleton.java一样，必须将Task.java编译后得到的Task.class部署在用户代理和计算引擎所在的机器上。
2.用户代理的实现
用户代理程序非常简单，它所要做的就是接收用户提交的代码文件名，打开一个到位于指定IP地址和服务端口的计算引擎的连接，用一个Task对象封装该代码文件，并通过Socket发送该对象。最后接收计算引擎返回的结果，并在控制台上将结果呈现给用户。用户代理程序可以基于GUI实现，为了简单和说明方便，这里给出基于命令行的实现，代码UserAgent.java如下：
public class UserAgent {
public static void main(String[] argv)
{ public String IP=”202.114.20.44”;
publice SERVICE_PORT=4000;
Socket s=null;
ObjectOutputStream os=null;
BufferedReader is = null;
String output=null;
try {
s = new Socket(IP, SERVICE_PORT);
os = new ObjectOutputStream(s.getOutputStream());
is=new BufferedReader(new InputStreamReader(s.getInputStream()));
System.out.println("transimiting file....");
// 读取用户提交的代码文件，并将它封装在一个Task对象中。
String filename=argv[0];
int l=filename.length();
FileInputStream fis = new FileInputStream(filename);
byte[] bytecode = new byte[fis.available()];
fis.read(bytecode);
Task obj = new Task(filename, bytecode);
// 通过Socket发送Task对象
os.writeObject(obj);
//接收计算引擎发送来的计算结果，并在控制台上显示
output=is.readLine();
System.out.println("Got from server: " output);
fis.close();
os.close();
s.close();
} catch (Exception e) {
e.printStackTrace(); }
}}
这里使用Socket类建立了基于TCP的网络连接是为了使用户代理和计算引擎之间的通信更可靠。
3.计算引擎的实现
计算引擎在端口（此处为4000）监听，使用ServerSocket对象接受用户代理的连接。每当一个用户代理连接到所监听的端口，ServerSocket就分配一个新的Socket对象，然后将这个新Socket对象的引用传递给一个新产生的线程（线程类Connects的一个实例）处理，主线程在端口4000继续监听更多的连接请求，这种在服务端口的不断监听是通过一个While循环实现的，代码Server.java如下所示：
public class Server {
public static final int SERVICE_PORT=4000;
public static void main(String argv[]) throws IOException
{ServerSocket service = new ServerSocket(SERVICE_PORT);
Socket clientSocket;
System.out.println("Server is started!");
while(true){
clientSocket = service.accept();
new Connects(clientSocket);
}}}
线程类Connects的方法run包含了计算引擎与各个用户代理的具体交互操作。首先接收用户发送来的Task对象，将Task对象中封装的代码文件恢复成文件的形式；然后从该代码文件中加载用户程序类并执行；最后将计算结果发送给用户代理。线程类的代码Connects.java如下所示：
class Connects extends Thread{
Socket client;
ObjectInputStream ois ;
FileOutputStream fos;
public Connects(Socket s){
client = s;
this.start();}
public void run(){
try {
CL cl=new CL();
ois = new ObjectInputStream(client.getInputStream());
// 通过Socket读取Task对象，并还模得到完整的代码文件
Task obj = (Task) ois.readObject();
byte bytecode[] = obj.ByteCode;
String filename = obj.TaskName;
int l=filename.length();
String classname=filename.substring(0,l-6);
fos = new FileOutputStream(filename);
fos.write(bytecode);
fos.close();
System.out.println("the file " filename " is received!");
// 从代码文件加载类并执行其中的方法run
Class c = cl.loadClass(classname,bytecode, 0, bytecode.length);
Object o=c.newInstance();
((Skeleton) o).run(client);
}
catch(Exception e) {
e.printStackTrace();
}
try {
ois.close();
client.close();}
catch(IOException ex) {
ex.printStackTrace();}
}}
class CL extends ClassLoader{
public Class loadClass(String name, byte[] b, int off,int len)
{ return super.defineClass(name,b,off,len); }}
其中的类CL是ClassLoader类的子类，它的方法loadClass用来加载类，之所以不直接使用ClassLoader类的方法defineClass是因为ClassLoader是抽象类，不能实例化。
4.代码执行
启动计算引擎后，执行用户代理的代码如图2所示（Compute.class是用户代码文件名）。
三、结论
本文提出的计算网格模型的设计及其实现，利用了Java程序跨平台执行的特性和现有的广泛存在的TCP/IP的通信协议，它可以随时利用计算网格中高性能计算机的CPU和内存快速运算处理用户各种特定的计算密集型应用，实现了跨组织的计算资源的动态共享。
参考文献：
[1]I. Foster, C. KesselmanThe Grid: Blueprint for a New Computing Infrastructure [M] Morgan Kaufmann Pub.,1998
[2] I. Foster, C. Kesselman, S.TueckeThe Anatomy of the Grid [J] Intl.J.Supercomputer Applications,2001
[3]The Globus Project home page, http://www.globus.org
[4]都志辉，陈渝，刘鹏. 网格计算[M].北京：清华大学出版社，2002.
[5](美) Bruce Eckel 著 Java编程思想（英文版.第二版）[M].北京：机械工业出版社，2002.
[6]（澳）David Reilly著，沈凤 等译. Java网络编程与分布式计算[M].北京：机械工业出版社，2003.
关键词：网格计算 计算密集 Java 代码上载
中图分类号：TP302.1 文献标识码：A 文章编号：1673-8454（2008）23-0022-03
根据共享资源的不同，网格计算可以分为计算密集型和数据密集型等（即计算网格和数据网格）。计算网格对CPU和存储器资源要求较高，而计算中需要的数据较少。[1] 传统的分布式计算技术，例如CORBA，RMI和DCOM中资源共享通常局限于一个固定的组织，这种共享是静态的，并且开销较大。[2] 本文针对计算密集型应用中传统的分布式计算模式的不足，提出了网格计算中代码上载的思想，并给出了一个支持代码上载的网格模型的设计和实现。
一、网格模型设计
支持代码上载的网格模型如图1所示。为了实现网格服务的透明性，本模型设计中在用户所在的机器上设置了一个用户代理。
用户代理具有以下职责：（1）与用户交互：接收用户执行某程序代码请求,最后将计算结果呈现给用户；（2）与信息服务交互：根据用户提供的要求向信息服务查询，并收到符合要求的计算引擎的IP地址和服务端口；（3）与计算引擎交互，将用户提交的程序代码传送给计算引擎，并接收计算结果。
每当有一个新的计算引擎启动时，它就会自动连接信息服务，并将它的信息发送给信息服务，并请求在信息数据库中注册；当有用户代理查询符合某要求的计算引擎时，信息服务根据该要求从信息数据库中查询和选择负载较轻的计算引擎，并将该引擎的IP地址和端口发送给用户代理；当某计算引擎的当前负载状况等特征改变时，它也将这些改变通知信息服务，信息服务及时更新信息数据库中的相关信息。这样信息数据库就实时地动态反映了网格环境中的计算资源。
本模型的实现基于客户/服务器模式，利用了现有的广泛存在的TCP/IP通信协议，并采用Java语言进行开发。
二、实现细节
由于篇幅有限，本文只介绍计算引擎、用户代理和相关辅助类的实现，并且假定用户代理已经从信息服务那里查询到了计算引擎所在的IP地址和服务端口。
1.辅助类的实现
用户代理将编译过的用户程序（扩展名为class）发送给计算引擎，计算引擎接收该代码文件并存于本地，然后JVM中的解释器加载该代码文件中的类并执行。大致框架如下：
Class c = cl.loadClass(classname,bytecode, 0, bytecode.length);
Object o=c.newInstance();
((SomeInterface)o).someClassMethod();
不能将引用 o 转换到someClass，因为这时计算引擎还不直接知道传送来的类名（通过后面所讲的类Task的属性TaskName可以间接知道）。为此用户程序必须继承一个抽象类或实现一个接口（这里用接口），并且在用户代理和计算引擎所在的机器上部署该接口，由于接口名称是事先已知的，从而可以动态执行用户代理传来的任何用户代码。接口定义Skeleton.java如下：
import java.net.*;
public interface Skeleton {
void run(Socket s);}
用户程序类必须实现该接口，给出方法run的具体实现。假设用户程序类用来计算fibonacci数列中的第40项，则用户程序类Compute.java的代码如下（本文代码省略了相应的import语句）：
public class Computeimplements Skeleton{
public void run(Socket s){
DataOutputStream os = null;
try{
os = new DataOutputStream(s.getOutputStream());
long a=fib(40);
String output="The fib(40) is " a;
System.out.println(output);
os.writeBytes(output); }
catch(IOException e) {
System.out.println("Erorr io: " e);}
}
public long fib(long n)
{if (n<3)
return(1);
else
return(fib(n-2) fib(n-1));}
}
还有一个辅助类Task.java，它封装了一个字符串和byte数组，用来传送用户的代码文件，由于要通过Socket发送Task对象，所以类Task必须实现Serializable接口。Task.java的代码如下：
public class Task implements Serializable{
public String TaskName;
public byte ByteCode[];
public Task (String n,byte b[])
{this.TaskName=n;
this.ByteCode=b;}
}
和Skeleton.java一样，必须将Task.java编译后得到的Task.class部署在用户代理和计算引擎所在的机器上。
2.用户代理的实现
用户代理程序非常简单，它所要做的就是接收用户提交的代码文件名，打开一个到位于指定IP地址和服务端口的计算引擎的连接，用一个Task对象封装该代码文件，并通过Socket发送该对象。最后接收计算引擎返回的结果，并在控制台上将结果呈现给用户。用户代理程序可以基于GUI实现，为了简单和说明方便，这里给出基于命令行的实现，代码UserAgent.java如下：
public class UserAgent {
public static void main(String[] argv)
{ public String IP=”202.114.20.44”;
publice SERVICE_PORT=4000;
Socket s=null;
ObjectOutputStream os=null;
BufferedReader is = null;
String output=null;
try {
s = new Socket(IP, SERVICE_PORT);
os = new ObjectOutputStream(s.getOutputStream());
is=new BufferedReader(new InputStreamReader(s.getInputStream()));
System.out.println("transimiting file....");
// 读取用户提交的代码文件，并将它封装在一个Task对象中。
String filename=argv[0];
int l=filename.length();
FileInputStream fis = new FileInputStream(filename);
byte[] bytecode = new byte[fis.available()];
fis.read(bytecode);
Task obj = new Task(filename, bytecode);
// 通过Socket发送Task对象
os.writeObject(obj);
//接收计算引擎发送来的计算结果，并在控制台上显示
output=is.readLine();
System.out.println("Got from server: " output);
fis.close();
os.close();
s.close();
} catch (Exception e) {
e.printStackTrace(); }
}}
这里使用Socket类建立了基于TCP的网络连接是为了使用户代理和计算引擎之间的通信更可靠。
3.计算引擎的实现
计算引擎在端口（此处为4000）监听，使用ServerSocket对象接受用户代理的连接。每当一个用户代理连接到所监听的端口，ServerSocket就分配一个新的Socket对象，然后将这个新Socket对象的引用传递给一个新产生的线程（线程类Connects的一个实例）处理，主线程在端口4000继续监听更多的连接请求，这种在服务端口的不断监听是通过一个While循环实现的，代码Server.java如下所示：
public class Server {
public static final int SERVICE_PORT=4000;
public static void main(String argv[]) throws IOException
{ServerSocket service = new ServerSocket(SERVICE_PORT);
Socket clientSocket;
System.out.println("Server is started!");
while(true){
clientSocket = service.accept();
new Connects(clientSocket);
}}}
线程类Connects的方法run包含了计算引擎与各个用户代理的具体交互操作。首先接收用户发送来的Task对象，将Task对象中封装的代码文件恢复成文件的形式；然后从该代码文件中加载用户程序类并执行；最后将计算结果发送给用户代理。线程类的代码Connects.java如下所示：
class Connects extends Thread{
Socket client;
ObjectInputStream ois ;
FileOutputStream fos;
public Connects(Socket s){
client = s;
this.start();}
public void run(){
try {
CL cl=new CL();
ois = new ObjectInputStream(client.getInputStream());
// 通过Socket读取Task对象，并还模得到完整的代码文件
Task obj = (Task) ois.readObject();
byte bytecode[] = obj.ByteCode;
String filename = obj.TaskName;
int l=filename.length();
String classname=filename.substring(0,l-6);
fos = new FileOutputStream(filename);
fos.write(bytecode);
fos.close();
System.out.println("the file " filename " is received!");
// 从代码文件加载类并执行其中的方法run
Class c = cl.loadClass(classname,bytecode, 0, bytecode.length);
Object o=c.newInstance();
((Skeleton) o).run(client);
}
catch(Exception e) {
e.printStackTrace();
}
try {
ois.close();
client.close();}
catch(IOException ex) {
ex.printStackTrace();}
}}
class CL extends ClassLoader{
public Class loadClass(String name, byte[] b, int off,int len)
{ return super.defineClass(name,b,off,len); }}
其中的类CL是ClassLoader类的子类，它的方法loadClass用来加载类，之所以不直接使用ClassLoader类的方法defineClass是因为ClassLoader是抽象类，不能实例化。
4.代码执行
启动计算引擎后，执行用户代理的代码如图2所示（Compute.class是用户代码文件名）。
三、结论
本文提出的计算网格模型的设计及其实现，利用了Java程序跨平台执行的特性和现有的广泛存在的TCP/IP的通信协议，它可以随时利用计算网格中高性能计算机的CPU和内存快速运算处理用户各种特定的计算密集型应用，实现了跨组织的计算资源的动态共享。
参考文献：
[1]I. Foster, C. KesselmanThe Grid: Blueprint for a New Computing Infrastructure [M] Morgan Kaufmann Pub.,1998
[2] I. Foster, C. Kesselman, S.TueckeThe Anatomy of the Grid [J] Intl.J.Supercomputer Applications,2001
[3]The Globus Project home page, http://www.globus.org
[4]都志辉，陈渝，刘鹏. 网格计算[M].北京：清华大学出版社，2002.
[5](美) Bruce Eckel 著 Java编程思想（英文版.第二版）[M].北京：机械工业出版社，2002.
[6]（澳）David Reilly著，沈凤 等译. Java网络编程与分布式计算[M].北京：机械工业出版社，2003.