As related works, OMG's CORBA (Common Object Request Broker Architecture)[2] has been developed for long years. CORBA was intended to realize interope

Transcription

1 HORB: Distributed Execution of Java Programs HIRANO Satoshi Electrotechnical Laboratory and RingServer Project Umezono Tsukuba, 305 Japan Abstract. HORB is a Java ORB (Object Request Broker) that extends Java for distributed object oriented computing. Applications of HORB and HORB itself are network portable and transferable, since HORB provides both portability and interoperability among dierent kinds of OSs. This paper describes the organization and the main features of HORB. It provides remote object creation/connection, remote method call, object passing, security, and so on. The usage of HORB is easy and simple. Performance evaluation shows that HORB is two or three times faster than javarmi. 1 Introduction The importance of the Java language[1] and its related technologies have been arising for two years. Today, Java is regarded as one of the most important technology for network computing. The Java language is an object oriented language and its syntax is rather simple when compare to C++. Although it is designed for network computing, the language itself does not have the feature of distributed execution. It is simply a multi-threaded, single process language. In order to extend Java for distributed computing, we have developed a kind of distributed Java, and named it HORB. The goals of HORB are summarized as follows: { distributed execution of Java programs { no modication of Java syntax { portability of programs among dierent architectures { portability of HORB among dierent architectures { interoperability among dierent architectures { integration of WWW and distributed programming For example, a client object (instance) on Windows 95 creates an object on a UNIX server, then it sends some objects to the server object to display it by another client object on a Macintosh. It is also possible for an HORB object operating in a WWW browser such like the Netscape Navigator to directly receive service without having CGI to mediate from an HORB object on a server machine.

2 As related works, OMG's CORBA (Common Object Request Broker Architecture)[2] has been developed for long years. CORBA was intended to realize interoperability among languages and machine architectures. Products complying with CORBA2's IIOP (Internet Inter-ORB Protocol)[2] such as Sun's NEO has become available. Microsoft's DCOM (Distributed Common Object Model)[3] has also become available in the latest Windows NT. It is also language and machine neutral. Thus, CORBA and DCOM are Common ORBs. These technologies require the denition of objects in the IDL (Interface Denition Language) as well as the implementation of objects in an execution language, such as Java. This will be a burden for programmers since the object model of the language and IDL will be dierent. Also the transfering of objects is limited to passing by reference and not by value, though they can transfer data as just struct. HORB is a Java ORB. While it lacks language interoperability, it is optimized for the Java language. It can pass objects by value among machines and no IDL is needed. Javasoft released javarmi (Remote Method Invocation)[4] with the latest JDK (Java Development Kit)[5] version 1.1 in February javarmi is also a Java ORB and it provides basic functionality such as remote method invocation and object passing. The rst announcement of javarmi was made four month after the rst release of HORB (November 1995). These ORBs are utilized in a wide area. In particular, ORBs are often utilized in 3-tier business applications in Intranet and Internet. Fig. 1 is the structure of a typical 3-tier business application. Inter-Object communication is used between a client (Java applet) and an application server. [6] demonstrated HORB is well suited for such 3-tier applications. Fig tier business application. We will introduce the architecture of HORB in the next section. The main features are described in section 3. In section 4, we will show the results of a performance evaluation on primitive operations. In order to compare the performance of HORB with other works, a plain socket implementation and the latest javarmi were also evaluated.

3 2 HORB Architecture Overview The HORB package consists of the HORBC compiler and the ORB runtime. To ensure operability on existing Java environments, the compiler and ORB is entirely written using Java and HORB, and execution is possible on the nonmodied Java interpreter. The compiler also uses the non-modied javac compiler as the back-end. In other words, HORB is realized on the user level. Hence, HORB will operate on any system which the Java interpreter operates on, and all of Java's features can be accessed from an HORB program. Fig. 2. HORB architecture. Fig. 3. HORBC compiler. The overview of the HORB architecture is illustrated on Fig.2. A client object in a client system calls methods of the server object (remote object) in a server

4 system, as if the server object exists locally. In order to realize that, a proxy object of the server object in the client system acts as if it is the server object[7]. The proxy object oers server function to the Client object as the proxy for the Server object. Marshalling of data by a stub routine occurs in proxies/skeleton objects when transmitting between objects and use mid-expressions that are not dependent of the architecture on the network. The HORBC compiler creates a proxy class and a skeleton class that includes the object code and stub of the class from the program that denes the Java class (Fig. 3). There is no need to write an IDL program. The class inheritance is realized by corresponding the inheritance tree of the proxy object and skeleton object of the meta level of inheritance tree as in Fig.4. Fig. 4. Inheritance Tree. 3 Main Features and Program Examples In this section, we will describe the main features of HORB by showing some small examples. The main features can be summarized as follows: { Dynamic remote object creation { Remote object connection { URL based object naming { Object transfer { Asynchronous method { Security by distributed access control list A remote class of HORB does not need to inherit a specic class such like RemoteObject or to implement a specic interface such like Remote as javarmi. A usual java class can be a remote class. That means the java class can be a subclass of any class. This is a very important feature of HORB for building object systems using design patterns[8]. If a remote class had to be a subclass of a specic class, the class couldn't be a subclass of a design pattern. In case of HORB, there is no such restriction.

5 3.1 Dynamic Remote Object Creation The Internet terminals (Intranet terminals) that will become popular in the future will only be equipped with a small memory as compared to standard PCs. Making all objects possible for remote access is a waste of resources, and there is no need. For this, objects necessary of remote access will be created as remote objects and the remaining objects will be regarded as local Java objects. The programmer is not required to take into consideration the distinction of the two. Here is an example to create a remote object. In HORB, a remote server class is written as follows: class Server { String greetings(string name){ return "hello,"+name; The above code is exactly the same as Java code. There is no need to add anything to the Java code. Programs when creating a Server instance locally as a standard Java object are written like this: class Client { public static void main(string[]) { Server server = new server(); System.out.println(server.greetings("Baby!")); Programs when creating a Server instance remotely on an HORB process which operates on the port 8887 of are written like this: class Client { public static void main(string[]) { Server_Proxy server = new Server_Proxy("horb:// System.out.println(server.greetings("World!")); The proxy class of Server is Server Proxy. The instance server is a remote object reference. In the above example, TCP/IP connection is established when the Server is created, and the remote object is created. The fourth line is a remote method call. One TCP/IP connection is required for remote object access between a remote object and a proxy object. HORB can inherit classes for remote objects as well. This is the same as Java's single inheritance.

6 3.2 URL based Object Naming All remote objects require names distinguishable from anywhere in the world. In order to conduct name management that is exible and universal on the Internet, the name management of HORB uses the URL (Uniform Resource Locator) notation. Here are some examples of object names: //Above mentioned temporary object horb:// // Named Remote Object horb:// 3.3 Daemon object and Remote Object Connection To operate an object of the Server class as a daemon instead of creating it each and every time, register it as a 'daemon object' on the server's side. This makes accessing possible from other machines by using the URL. Server server = new Server(); HORBServer.registerObject("Server",server,"MyServer",8887); The last line of code registers a Server instance so that it can be accessed under the object name, horb:// Clients who wish to access this object may obtain the remote object reference by creating a proxy object using the object name as the URL. As client connections are made to the remote object, corresponding threads are attached for each client. As a result, a remote object can serve multiple clients simultaneously. Since the programming style of this model is similar to that of the present Internet servers, it is easy for programmers to become familiarized. Fig. 5 illustrates the dierence of remote object creation (left) and remote object connection (right). In case of the remote object connection model, all clients share one remote object. While the clients can share data in the instance variables of the remote object, there is no room to keep client's dedicated data such like user names and bank account numbers. Such data must be transferred in each remote method call or be stored in a special data storage such like hashtables. In case of the remote object creation model, a remote object is created for each client. Thus, a remote object can have client's specic data. Class variable of the remote object is used to share data between clients. Since one object serves one client, programming is much easier than the remote object connection model. HORB supports both models. CORBA and javarmi supports only the remote object connection model.

7 Fig. 5. Remote object creation and Remote object connection. 3.4 Integration of Reference Using Interface The example used in a previous subsection consisted of a locally created Server object of object reference type Server, with remote object reference type Server Proxy. This situation lacks distribution transparency. By using interface denition, these are handled as the same type. Local object access and remote object access on the program are transparent. interface Server{ String greetings(string name); The interface of the Java language denes the method to be prepared by the class which implements the interface. An example of Serve Impl to realize Server is as follows: class Server_Impl implements Server{ public String greetings(string name){... The code for creating Server objects for each local and remote objects is as follows. The object reference types are integrated. Server local = new Server_Impl() Server remote = new Server_Proxy(url); 3.5 Object Passing by Value and by Reference In HORB, it is possible to specify the arbitrary type for the argument and return value of a remote method. In other words, it is possible to pass basic types, objects, interfaces, and arrays of them. Transferring of inherited objects is also possible. Object passing means either class passing or instance passing.

8 Class passing is a feature inherited from Java and the class of the HORB program which is operating within the WWW browser as well as the ORB is automatically downloaded from the server. Automatic passing of classes is also possible with standalone programs by the user oering a network loader class. The runtime for downloading has been kept to a minimum with only 30KB making possible smooth Internet accessing for users using modems. An object can be passed by value orx by reference for argument or return value of the remote method. If the object for transferring is a local object, then passing by value is used. If the object for transferring is a remote object, then passing by reference is used. In case of passing by value, all instance variables in the range possible to attain recursively within the transferring object, with the exception of private and transient attributes, are copied (if the object includes an object, then the object is also transferred). The shape of object graphs are kept when transferring. For example, objects with complicated loop congurations are transferred intact. Due to security restriction, private variables are not copied (This restriction will be cleared when Java's built-in serializer becomes available). In case of reference passing, the transferred object is usable as remote object reference. In the same way, in the case of remote object reference included in the object being passed by value, the connection is recovered automatically after transference. HORB fully supports object polymorphism. The object type is correctly transferred even if it is casted. 3.6 Asynchronous Method Call A remote method is executed as one of the following: { Synchronous method { Asynchronous method Asynchronous method is used for processing correspondences from users in an interactive application, and for the realization of various synchronization with parallel programs. To call a method as an asynchronous method, add Async to the method name. class Server{ String work_async(type args) { // do some work here return value; The code to execute method work Async as an asynchronous method is as follows:

9 server.work_request(arg); //do some work here value = server.work_receive(timeout); Request is issued by the method with the added Request to its method name and receives value from the method with the added Receive. Since Receive takes timeout consisting of milliseconds, the asynchronous method is convenient for processing using such timeout function. Polling is conducted using available(). Use the asynchronous method handler when describing parallel processing or multiple waits. Set callback object as the asynchronous method handler for automatic calling of the object at the point when value is conrmed. 3.7 WWW Programming using the HORB Applet Client programs that operate within the WWW browser such as Netscape Navigator are called HORB Applets. Direct object access with the HORB server program is possible without having CGI to mediate. Advantages in comparison to methods using the CGI are: coding amount is zero for transmission (no CGI script), high-speed in comparison to CGI which is reloaded for each process, there are sessions, the ability to use HORB's powerful security. An applet cannot accept connections from other machines for security reasons. \Invitation" must be proceeded by both the Server and the Client when calling the Client's method from Server's end. \Invitation" is a procedure in which enables calling of Client's method from the Server's end by Client setting a connection to the Server. 3.8 Global Garbage Collection HORB objects with the exception of Daemon objects are automatically deleted from the system once all of the remote object references to the object are no longer used. The global garbage collection is realized by reference counting in consideration of the demand for real time applications. 3.9 Persistent Objects By using HORB's persistent object function, the internal condition of objects can be stored in les. Due to this, it is possible to revive objects from les at a later time. Files may also be located on other machines. The procedure for storing objects is as follows: obj is the object to be stored. ObjectStorage os = new ObjectStorage_Proxy("horb://bungo/"); os.saveobject("filename.fof", obj); Revival of objects are proceeded in the following manner: obj = os.loadobject("filename.fof");

10 As with object passing, objects stored into a le are all traceable objects with the exception of private and transient. If the remote object reference is included, the connection is recovered during the revival. The object may have hook methods called freezehook() and revivehook(). The rst method is called when storing objects and the second method is called when reviving objects, for a completion processing and recovery processing. lock() method is used for the transaction Security by Distributed Access Control List HORB oers security features that originate from Java as well as its own unique distributed ACL (Access Control List). Distributed ACL for server side security is used for the following: { Access control to class by host name, domain name, network address of clients. { Access control and authentication using user names and passwords. myclass.host=etl.go.jp * myclass.host_exclude=gw.etl.go.jp myclass.user=* myclass.user_exclude=anonymous myclass.format.user=administrator In this example, access is granted to those of etl.go.jp or of * network host and not gw and anonymous users. Especially, the format method can only be executed by the administrator. At the client side, a remote object is created or connected as follows: server = new Server_Proxy(url, username, passwd); No modication is needed at the server side. Just specify the ACL le as a parameter of the HORB server. The HORB server has features to read the ACL from multiple les as well as inherit ACL from other existing HORB servers. For this, it is possible to manage ACL hierarchically on large-scale networks. Modication of an ACL le in a HORB server propagates other HORB servers. 4 Performance Evaluation In this section, we show the results of the conducted performance evaluation. The evaluation was done for three basic remote operations: remote object creation/connection, remote method call, and object passing. In order to compare the performance of HORB with other works, a plain socket implementation and the latest javarmi were also evaluated. The result shows HORB is that two or three times faster than javarmi. Evaluation Environment:

11 { Client machine: Pentium Pro 200MHz RAM 64MB { Server machine: Pentium Pro 200MHz RAM 64MB { Network: 10Base-T { Operating system: Microsoft Windows NT 4.0 { Java Compiler and Interpreter: JDK1.1 (nal) { javarmi: JDK1.1 (nal) { Native code converter: jexegen (Microsoft SDK for Java 1.5) We used two machines connected by a 10Mb Ethernet. The latest Java Development Kit(JDK) were installed on both machines. We used a native code converter as well as a Java interpreter in order to evaluate the speed penalty of the Java interpreter. The jexegen utility generates an executable (exe) le from class les. This utility can be considered as a variant of the Just In Time compiler (JIT). 4.1 Remote Object Creation/Connection For the remote object creation test, a client object residing in the client machine creates a new remote object on the server machine. Just after the creation, the client object destroys the remote object. These operations are repeated for calculating the average elapsed time. For the remote object connection test, a client object residing in the client machine connects to an existing remote object residing in the server machine. The following table and gure summarize the result. In this section, all units are in milliseconds. HORB(exe) HORB(java) javarmi Object creation 15.6msec 14.8 NA Object connection Fig. 6. Remote object creation/connection (msec). For the remote object connection, HORB is two times faster than javarmi. Since javarmi does not support dynamic remote object creation, its result is not available.

12 The numbers of HORB(java) and javarmi were measured with the Java interpreter of JDK 1.1. HORB(exe) is the native code version of the HORB(java). User code and the HORB runtime were converted into i386 native code. However, system classes were executed by the interpreter. The exe version of javarmi failed due to an unexpected exception. Thus, there is no data of it. Since system classes are interpreted in the exe version, speed up might be very small. 4.2 Remote Method Call This test evaluated the performance of remote method call by using some remote methods. The remote methods take some integers as arguments and returns one integer. The number of arguments is a variable. A client object calls the methods remotely. int method1(int a1); int method2(int a1, int a2);... int method6(int a1, int a2, int a3, int a4, int a5, int a6); 'Socket' is an equivalent implementation using the Java socket classes. The socket client sends some integers to socket server and receives one integer. The following table and g. 7 show the result. number of arguments Socket HORB(exe) HORB(java) javarmi Fig. 7. Remote method call (msec).

13 HORB is two to three times faster than javarmi and HORB(exe) is as fast as the socket version. We can summarize that the overhead of remote object call is very small. 4.3 Object Passing This text evaluates the performance of object passing by value. A class 'Data' consists of one integer. Some objects of Data are passed as arguments of remote method call. The following table and g. 8 show the result. public class Data { int a; void method1(data a1); void method2(data a1, Data a2);... void method6(data a1, Data a2, Data a3, Data a4, Data a5, Data a6); number of objects HORB(exe) HORB(java) javarmi Fig. 8. Object passing (msec). We can summarize that HORB is two to three times faster than javarmi and the overhead of object passing is small.

14 5 Conclusion HORB is a Java ORB that extends Java for distributed object oriented computing. Applications of HORB and HORB itself are network portable and transferable, since HORB provides both portability and interoperability among dierent kinds of OSes. This paper described the organization and the main features of HORB. { Dynamic remote object creation { Remote object connection { URL based object naming { Object transfer { Asynchronous method { Security by distributed access control list In the previous section, we showed the result of performance evaluation for basic remote operations. The result showed HORB was two or three times faster than javarmi. HORB is freely distributed at the address given on the title for non-commercial purposes, and is used for system development and research purposes such as agent systems[6, 9]. The package can be used for development just by decompressing les and setting two environment variables. Installing is unnecessary for the use with the WWW browser. The usage of HORB is quite simple and easy. The author encourage you enjoy network computing with HORB. References 1. Sun Microsystems, The Java language specication, Object Management Group, CORBA2 Universal Networked Objects, Brown, N., Kindel, C., Distributed Component Object Model Protocol { DCOM/1.0, Internet Draft ( Sun Microsystems, Remote Method Invocation Specication, Sun Microsystems, JDK 1.1 Documentation, Dual, N., Distributed Database Access in a Corporate Environnement Using Java, 5th Int. WWW conference, 1995, html/papersessions.html#ps8 7. Shapiro, M., Structure and Encapsulation in distributed Systems: The Proxy Principle, ICDCS, pp , Gamma, E., Helm, R., Johnson, R., Vlissides, J., Design Patterns, Addison-Wesley Publishing, Yamanaka, A., Nakajima, S., Tomono, M., Tonouchi, T., A HORB-Based Network Management System, ICODP'97 (to be appeared), 1997 This article was processed using the LATEX macro package with LLNCS style