Context-Aware Adaptive Object Migration

Download PDF
0 downloads 0 Views 902KB Size Report
Comment
Aug 30, 2006 - system) and wireless communication of all kinds, push this trend. Accompanied .... cation, request marshalling and message transmission are performed by the ..... finally sorted out in order to support lightweight agents. As.
Universität Ulm Fakultät für Informatik Verteilte Systeme

Context-Aware Adaptive Object Migration

Rüdiger Kapitza Holger Schmidt Franz J. Hauck

Bericht Nr. VS-R04-2006 2006-08-30

Context-Aware Adaptive Object Migration Rudiger Kapitza ¨

Holger Schmidt

Franz J. Hauck

Dept. of Comp. Sciences Informatik 4 University of Erlangen-Nurnberg ¨ Germany

Distributed Systems Laboratory University of Ulm Germany

Distributed Systems Laboratory University of Ulm Germany

[email protected]

[email protected]

[email protected] ABSTRACT

Current systems restrict object migration support to a certain language and environment. Only few systems support heterogeneous environments by specifying a languageindependent state transfer format and requiring the same implementation in every target language. In the context of Ambient Computing with mobile applications and users and context-aware adaptive software, a more platformindependent, flexible and adaptive approach for object migration is required. This paper presents a novel approach for adaptive object migration in heterogeneous systems. It is also based on language-independent state transfer but uses standard mechanisms using CORBA value types. This offers ORB- and platform-independent object migration between all CORBA-supported programming languages. Adaptive object-based migration is achieved by providing flexible mechanisms for reducing, expanding or transforming the state of an object before and after migration, respectively, and for adapting the provided functionality according to the current context’s requirements (e.g. resource limitations or different steps in a workflow). For this purpose, we introduce a separation of state, functionality and code instead of mapping particular state on particular code. Our prototype system is based on our recent platformindependent CORBA-compliant Life-Cycle–Service implementation. So far, we support Java and C++, but an implementation for any other CORBA-supported programming language is possible.

1.

INTRODUCTION

There is an ongoing trend to integrate and link the physical world to the virtual world of computing resources and applications. Techniques like RFID (radio frequency identifications), sensors (e.g. BTNodes 1 ) and mobile devices, 1

http://www.btnode.ethz.ch

but also positioning systems like GPS (global positioning system) and wireless communication of all kinds, push this trend. Accompanied with this evolution and the rising diversity of systems, new concepts and techniques to provide adaptable and context-aware applications are required. Often, these applications will migrate between different platforms during their lifetime. As a typical example, a “follow me” application (e.g. personal information manager application ) can have a different interface and state on a laptop, a cellular phone or a publicly accessible web-terminal. In the first case, the full set of features is provided, whereas in case of the cellular phone some data-intensive parts are left out. Finally, in the last case, one would only provide the essential parts of the state to fulfil the demanded task for privacy reasons. In all cases, different hardware and software systems can be expected. In other words, we expect that a mobile application has to adapt its state, the provided functionality and the implementation basis to its execution context, the target system and application-dependent restrictions. Most recent object-based middleware and agent platforms restrict migration support to a certain programming language and environment. Only a few systems provide support for migration in heterogeneous environments such as AgentFactory [1] or ATS [2]. These rely on a custom languageindependent serialisation format for state transfer and require an implementation providing the same functionality in every target language. This results in high implementation costs in terms of porting the system to a new platform and providing a fully-fledged implementation of a mobile object for each supported target language. The latter is especially the case if only parts of the functionally should be provided or are required on certain systems. In scenarios where the ability to adapt the provided functionality and state is needed like outlined by the “follow me” example a more platform-independent, flexible and adaptive approach for object migration is required. In this paper, we propose the concept of adaptable mobile objects. These objects are capable of adapting their state, functionality and underlying code basis during migration to the requirements of the target platform and the needs of the object itself. We focus on weak migration. This means that only the state of an object is migrated but no executiondependent state like, e.g., values on the stack. We build on our recent platform- and ORB-independent implementation of the CORBA Life-Cycle Service [3] that is based

on CORBA value types [4], a standard CORBA mechanism for passing objects by value. This service combined with a logical separation of the mobile object’s state, functionality and code enables support for adaptive object migration in heterogeneous environments. In fact, our current prototype of a dynamic adaptation service for mobile objects, the adaptive object migration (AOM) service, supports the migration of objects between Java and C++. Supporting other CORBA-supported languages requires only moderate implementation effort. To assist the developer during the implementation process, we provide a tool—the AOM tool. Additionally, we offer support for mobile objects acting as mobile agents (an object having an own thread that executes autonomously on behalf of a user). The paper is structured as follows: In Section 2, we give an overview of mobile object systems and the CORBA LifeCycle-Service specification. Then, we present our approach of implementing adaptive object migration for mobile objects. In Section 4, we show related work. Finally, we conclude and discuss future work in Section 5.

2.

MOBILE OBJECTS

In the following section, we give a brief overview about systems providing object mobility in homogeneous and heterogeneous environments. Then, we introduce our recent realisation of the CORBA Life-Cycle–Service specification. Based on this approach, we built our platform that supports adaptation of an object’s state and code.

2.1

Providing Object Mobility

In the past, a lot of mobile agent systems have been developed, like MOA [5], Mole [6] or Aglets [7], to name a few. However, all of them only provide mechanisms for migration in homogeneous environments. Most of these systems are Java-based and rely on the Java serialization mechanism. Using Java serialization the whole agent object is transferred to the agent’s new location. In this case, the state of an agent is tightly attached to the actual implementation. Thus, migrating a specific version to a new place with another implementation version will probably lead to serialization errors. Furthermore, no adaptation of the mobile agent’s state or code is supported at all. Nevertheless, mobile agent systems for heterogeneous environments have been developed as well. In [1] a platformneutral approach of agent migration is presented, based on transferring a blueprint instead of the code. This approach can be realised by assuming that an agent consists of a set of different components. For the creation of such an agent, a special AgentFactory is specified, which is responsible for creating an executable agent consisting of the right components from a received blueprint. Thus, migration is based on transferring the blueprint and the state of an object. However, the AgentFactory approach does not provide any support for the adaptation of state or functionality. Choy et al. describe a CORBA environment supporting mobile agents based on mobile CORBA objects [8]. Based on the Life-Cycle Service and the Externalization Service a concept was developed, but apparently not implemented. Furthermore, the concept does not support adaptation of the mobile agent’s state or code.

For gaining higher interoperability of heterogeneous mobile agent systems, the Object Management Group (OMG) developed a standard for agent communication: the Mobile Agent System Interoperability Facility (MASIF) [9]. The Foundation for Intelligent Physical Agents (FIPA)1 is another standardisation approach for mobile agent systems. Both, MASIF and FIPA, provide only support for interoperability of agent platforms of different vendors, but lack support for inter-platform migration. Furthermore, they provide no support for adaptation of agents.

2.2

CORBA Life-Cycle Service

CORBA is a standardized architecture defined by the Object Management Group (OMG). This architecture enables programmers to create and access objects deployed in a distributed system and provides platform- and languagetransparency. Common middleware tasks like object location, request marshalling and message transmission are performed by the Object Request Broker (ORB). A server object is specified by describing the object’s interface using the Interface Definition Language (IDL). This interface is used to generate platform-specific stubs for the client and skeletons for the server side. Both entities act as surrogates dealing with heterogeneity and handle remote invocations and marshalling for the object. Objects are actually implemented by servants that are registered with an object adapter. For invoking remote methods, a client only needs a valid object reference that can be bound by the local ORB instance. CORBA specifies a set of CORBA services. These services represent optional ORB extensions and address general needs of CORBA applications. The Life-Cycle Service [10] is such a CORBA service, as it enables application-controlled object management including mobility and other life-cycle operations. Recently, we proposed a platform-independent implementation of the CORBA Life-Cycle–Service specification [3]. Although our initial prototype implementation is based on Java, it is easily portable to any other CORBA-supported language and can be used in different ORBs as it just relies on standard CORBA without any ORB-specific extensions. This has been verified by a further interoperable implementation in C++. The CORBA Life-Cycle Service describes the interfaces of all required components for enabling object mobility in great detail. However, the specification leaves open important issues. For migrating a mobile object, the state and the code have to be transfered (this implies determining the state of the mobile object dynamically at runtime). In principle, the specification describes these processes as an object-specific task that should be handled by the object developer. This has various disadvantages as state transfer methods have to be implemented from scratch for each object. This is error-prone and leads to serious interoperability problems in heterogeneous environments. For state transfer in heterogeneous environments we introduced value types. Value types are a well-known part of the 1

http://www.fipa.org/

3.

ADAPTIVE OBJECT MIGRATION

In this section, we present our approach of object migration supporting adaptation of state and functionality. First, we give basic background information and outline our basic concept. Then, we sketch possible implementation realisations.

3.1 Figure 1: Object Migration using the Life-Cycle Service (UML Communication Diagram)

CORBA specification [4]. In contrast to standard CORBA objects, value types are transferred by value (call-by-value semantics), leading to a complete copy of the value type at the receiving side. Using value types enables an easy description of an object’s state using standard IDL syntax. Furthermore, developers do not have to write special methods for state transfer, as value types are marshalled and demarshalled automatically by the ORB. Like standard CORBA objects, value types can also be activated. In this case, a value type has to support a standard CORBA interface which enables a call-by-reference semantics. Thus, weak heterogeneous object migration can be realised using the CORBA Life-Cycle Service in combination with value types. The Life-Cycle–Service specification defines a LifeCycleObject-interface that is implemented by our mobile object. The mobile object is actually a value type that supports the LifeCycleObject-interface, which, beside other methods, offers a move()-method. In conjunction with a remote factory (GenericFactory), that enables the creation of objects on remote servers, the move()-method implements object migration. For this process, another entity—a FactoryFinder—is needed for searching for an appropriate factory on a remote server. The appropriate location is determined by evaluating parameterized criteria that specify possible target locations. After having found such a factory, the object aka value type can be passed by value as a method-parameter using standard marshalling and demarshalling mechanisms. The created value type has to be activated by the factory using the original object’s objectidentifier. Then, the original object has to be removed. Fig. 1 shows the basic workflow of an object migration using the CORBA Life-Cycle Service. As we also intented to support heterogeneous systems, in which the object’s code might not be present at the final location, we provided a solution to dynamic code provision as well. Based on our previous work, the Dynamic Loading Service (DLS) [11], we developed a special type of GenericFactory that transparently enables loading of appropriate platform-specific code on demand. This allows dynamic instantiation of previously unknown objects. Furthermore, our solution enables persistent object references by maintaining the object identifier for the whole lifetime of a mobile object. We achieve this by providing a special type of location service that manages the system’s object references. For avoiding a bottleneck we enable the usage of arbitrary location services.

Basic Definitions

For transferring a mobile object in homogeneous environments usually the state and the code of this object have to be transferred. Therefore, recent systems only separate the state and the code of an object. For addressing heterogeneous platforms we introduce another abstraction: the separation of state, functionality, and the realising code. Thereby, the functionality of an object is defined by its most derived supported interface. This enables a selection of an appropriate implementation based on a supported interface as already described in Section 2.2. Migration in heterogeneous environments enforces differentiating between implementation-dependent and -independent state. For example, a java.util.Hashtable object from the Java class library contains many implementation-dependent state-variables, e.g., a set of diverse constants regarding the used hash-function. In heterogeneous systems it does not make sense to transfer state that is highly specific for a certain implementation, as other implementations are not able to understand these values. This is especially the case if an object is migrated between different programming languages (enabled by our implementation of the CORBA Life-Cycle Service). In such systems, just the implementation-independent state should be transferred; in case of a Hashtable-Object, this state is represented by the actual -pairs. To sum it up we consider: • Implementation-dependent state as values that are specific for a certain implementation variant of an interface • Implementation-independent state as values that are needed by any possible implementation to provide the functionality defined by an interface and values that would be considered as information loss if they were omitted We identified the fact that in various scenarios only parts of the object state are accessed, can be available or should be accessible. If a mobile object moves from one host to another one for fulfilling various steps in a complex workflow, there is data which is not needed on every target platform. Thus, there is state that we call passive on these platforms. Going back to the “follow me” example from the introduction, the whole state of the personal information manager (PIM) application can be considered as active state on a laptop, as all data can be accessed and modified. As this application object moves to a cellular phone certain data items might not be accessible due to device limitations, like private movies or pictures from the last holiday. In this case, the movies and pictures are passive state that is not available. If the PIM application is accessed from a public web-terminal, huge parts of state might not be transferred due to privacy reasons. Thus, this information can also be

Figure 3: Basic Concept of Adaptive State Transfer Mechanism Figure 2: Adaptation of State According to an Object’s Functionality

considered as passive state as it should not be accessible. We define active and passive state as follows: • Active state is represented by the state variables that are used and needed for fulfilling the object’s functionality at a certain location • Passive state is the state of an object that is not needed, not available or not accessible at a certain location. We believe that in all these three exemplary cases not only the state of an object changes or should be changed but also the interface and the implementation that are provided at the target platform. Fig. 2 shows the adaptation of state and interface on demand according to an object’s functionalities’ requirements. For this purpose, parts of the full state might become passive. However, this passive state might become active again, whenever the object migrates to another location. Thus, even the passive state should be stored, as it might be used again later.

3.2

Basic Concept

Fig. 3 shows our concept of adaptive object migration (AOM). We enable adaptation of an object’s state according to the required functionality as specified by the interface (cf. Section 3.1). In contrast to previous work, we enable attaching state to a special functionality instead of attaching an object’s state to a special implementation (represented by code). For migrating a mobile object, just the state and a description of the required functionality have to be transferred to the new location (cf. Fig. 2). At the new location, our factory is able to create an object that fulfills these requirements containing the active state, which is specified by the required functionality. Our infrastructure supports passivating parts of the state in special state repositories

that might be local or remote regarding the current object. We support adaptation of the mobile object whenever it enters or leaves a location. At these intervention points (State Adaptors), we enable activating and passivating state for future implementations of the required functionality. Supporting adaptation on the origin side enables a secure transfer of sensitive data and supports target-systems that are not capable of our adaptive object migration implementation2 . On the other side, the possibility of adaptation on the target side minimizes adaptation efforts on the origin side and, in case of bad network connectivity, allows receiving and storing the complete state for further local adaptation steps. This requires a local state repository as shown on Host D in Fig. 3.

3.3

Implementation Draft

In this section, we present an implementation draft for realising our introduced concept for adaptive object migration. As a first step, the developer has to decide which kinds of functionalities should be supported. These kinds of functionalities represent the different facets3 , which the mobile object can adopt during it’s life cycle (this affects the behaviour of the object but not the actual object identifier; cf. Section 1). For any functionality, an IDL interface and the corresponding value type (supporting the interface and containing the active and implementation-independent state) has to be specified. For supporting our adaptive object-migration service the value type has to support the LifeCycleObject interface as well. In the next step, the developer has to run a tool—our AOM tool —that will create a union value type called 2

However, these target-systems have to support the CORBA Life-Cycle Service. Then, migration of already adapted value types is possible. 3 According to the current context, an object with a specific object identifier can have different facets represented by different functionality, state and code

valuetype A { private i n t c o u n t e r ; private S t r i n g message ; }; valuetype B { private i n t c o u n t e r ; private S t r i n g l o g i n ; }; valuetype private private private };

aom full { int counter ; S t r i n g message ; String login ;

Figure 4: Two Value Types and the resulting aom full Value Type

Figure 5: Process of Object Migration on the Origin Side (UML Communication Diagram)

aom full containing the union set of state variables of all defined value types (representing the facets of a mobile object—represented by the same object identifier but offering different functionality). This is done using a simple name matching algorithm, i.e., if a state variable has the same name in different value types, then we assume that these state variables represent identical data (cf. Fig 4). Defining value types containing states with identical names but different types results in an error. Thus, our AOM tool creates a value type that contains the complete set of state variables. This state might become active and passive during runtime, respectively. After having run the AOM tool, the developer has to implement the actual value type realisations for all the programming languages and platforms that should be supported (supporting all facets of the mobile object). This also includes the implementation of the life-cycle operations. However, this effort is quite moderate because the whole migration functionality is provided by the move()-method of the provided AOMManager (cf. Figure 5). This method just has to be called from within the LifeCycleObject’s move()method. An implementation of the other life-cycle operations is simple as well. In [3], we describe this process in detail.

3.3.1

Figure 6: Exemplary Hierarchy of Possible Keys in the FactoryFinder’s Repository

more, it is also responsible for searching for an appropriate target location for a pending migration. For this task, a known FactoryFinder is queried on possible factories representing possible migration targets within the scope of the FactoryFinder. These factories have to fulfill given criteria. Our offered FactoryFinders support criteria defining concrete locations (e.g., DNS-Name, IP-Address) and discrete locations specified by a required functionality (see Section 3.3.2). The result of the query is a list of appropriate factories, which are able to create a copy of the mobile object for realising the migration. Our AOMManager is able to select the “best” factory that is used for object migration. In our prototype implementation, we use the factory at the head of the list, but obiously user-defined policies can be implemented by providing a custom selectFactory() method as well (cf. Fig. 5). For supporting adaptation on the origin side our AOMManager is able to save the active state of the value type to a trusted state repository. Therefore, a saveState()-method of the value type, which has been generated by our AOM tool before, is called. Then, this state is stored to the state repository containing the current aom full value type. In the next step, the AOMManager either adapts the value type to the target value type or sends the original value type—which can be adapted at the target side by the factory—to the factory by invoking the remote method createFromValueType. Passing the value type as a parameter results in transferring a description of the functionality and the affected state to the factory. The application developer decides which variant is processed by passing a boolean parameter (local adaptation). If the mobile object has been created successfully at the factory, the original object is removed and the reference in the location service is updated (see [3]).

3.3.2

FactoryFinder

As already mentioned in Section 3.3.1, the FactoryFinder represents some kind of abstract location within the CORBA Life-Cycle–Service specification. It provides methods for querying for appropriate factories acting as targets for object migration. For fulfilling this task, the FactoryFinder has to maintain a repository of possible factories within the FactoryFinder’s domain.

AOMManager

The AOMManager is responsible for the adaptation process on the origin side (cf. State Adaptors, Fig. 3). Further-

Fig. 6 shows our realisation of the repository. Our repository is able to store factories according to their location and

provided functionality. Therefore, our factory enables registering and deregistering factories including their metadata. The FactoryFinder’s find factories method allows to search for registered factories residing at particular locations and providing particular functionalities, respectively (a list containing every appropriate factory is returned). For this purpose, find factories receives a CORBA Naming Service NameComponent sequence. A NameComponent consists of an -pair of strings. We specified two possible kind -values for our FactoryFinder. For a functionality we specified “IFC” and for a location we specified “LOC”. The particular identifier represents the functionality and the location, respectively. As find factories receives a NameComponent-sequence, searching for specific functionalities at specific locations within the FactoryFinder’s repository is possible as well.

3.3.3

Factory

On the factory side, a value type is automatically created according to the transferred specifications during the unmarshalling process. Our factory is able to use the Dynamic Loading Service (DLS) to load locally unavailable code on demand. This enables instantiating previously unknown objects. If needed, the factory is able to adapt the value type according to the actual platform’s and criteria’s requirements. In this case, the passivated part of the state is stored to the trusted state repository again. The active state is then loaded from the repository into the adapted value type implementation using the value type’s loadState()-method (generated by the AOM tool as well). After this process, the value type is activated, which enables accessing the object from remote clients.

3.3.4

State Repository

The State Repository is an entity that is able to store the current state of a mobile object. This entity is a plain CORBA object that can be located locally or remotely to the mobile object. The state repository contains the current aom full value type and offers two methods for loading and saving the state, respectively (load state(), save state()). The load state() method takes the description of the desired value type as a parameter and, thus, is able to return the appropriate part of the state. The actual implementation of the State Repository is left open to the developer. E.g., the State repository can be realised by serialising the mobile object’s state to external storage (reducing the actual memory load). For reducing communication costs on mobile pervasive devices, it can be useful to have a local State Repository. Then, further adaptations can be done locally.

3.4

Persistent Object References

In heterogeneous environments containing mobile objects, persistent object references are needed for clients to access the mobile object anytime. We realised these object references using a special location service (see [3]). However, adapting the functionality (interface) of a mobile object might result in remote call exceptions on the client side, as particular methods might not be present any more. This problem can be solved by asuming that the mobile object

Figure 7: Public and Location-Dependend Interface of a Mobile Object

has a public interface that does not change and a locationdependend interface that might change (cf. Fig. 7). This can be realised by a value type that has to support the public interface while optionally supporting other locationdependend interfaces. Thus, the location-dependend interface is just used for platform-internal purposes. Nevertheless, this interface is remotely accessible and can be used by clients (these have to handle exceptions if a special locationdependend interface is not existent). As already mentioned in Section 1, our system is able to realise an agent that is able to adapt to the current location’s needs. An adaptive mobile agent (AOM-agent) will have management methods for intervening into the agents workflow (public interface). Furthermore, that agent will also offer methods that can be used on the current local node, e.g., for collecting data (location-dependend interface). “Careful” persistent references can be realised by a mobile object that is just accessed using an object-specific adapter. This adapter is able to throw exceptions in case of nonexistent methods. For supporting the client, these exceptions contain the interfaces offering the needed method4 . Thus, the client is able to adapt the mobile object to current needs.

4.

RELATED WORK

Almeida et al. propose a dynamic reconfiguration service for CORBA [12]. This service is able to upgrade objects without taking them offline. This entails operations for migration, replacement, addition and removal of managed objects. Objects should provide methods for inspecting and modifying the state. This breaks the OOP concept of encapsulation, as internal state is publicly accessible, and in contrast to our approach object developers have to implement these methods on their own. Furthermore the dynamic reconfiguration service does not allow switching the object’s interface or state adaptation. The work of Garbinato et al. introduces Frugal Objects (FROBs) for mobile computing [13]. FROBs are objects within an event-based computing model, which provide adaptability according to their interface (which is represented by events that can be accepted) and their code. These objects support migration as well, but a drawback of this solution is the requirement of using a special non-intuitive 4 The adapter can automatically be generated by our AOM tool and has to catch CORBA BAD OPERATION exceptions and forward system-defined exceptions containing the needed interface. Nevertheless, by calling the remote object’s get interface def()-method the currently supported interface can be obtained.

There exist also a distributed Self variant called dSelf [18]. However, there is no support for heterogeneous object migration supporting other programming languages.

5.

Figure 8: Overview of Capabilities of Related Migration Approaches

FROB programming model that does not allow any loops, forks or synchronization primitives. An Agent Transport Service (ATS) was specified in [14]. There, the CORBA Life-Cycle Service was considered, but finally sorted out in order to support lightweight agents. As in our solution, all migration methods are offered entirely by the platform. In contrast to our approach, ATS does not provide support for adaptation of the agent’s state or interface. Bellavista et al. propose the SOMA programming framework for mobile agents [2]. This work offers compliance to CORBA, and to the mobile agent standards MASIF and FIPA. Through this, SOMA achieves a good interoperability with many other mobile agent systems which are also based on these standards. However, SOMA does neither support adaptation of the mobile agent’s interface nor of the agent’s state. Brandt et al. suggest reassambling agents from smaller subcomponents [15, 16]. This allows exchanging environmentdependent implementations at runtime by selecting an appropriate implementation for a specific environment at runtime. Our approach is even better compared to this solution as our Dynamic Loading Service (DLS) [11] also allows selecting appropriate implementations for specific environments. Furthermore, we support adaptation of the object at the origin side and at the target side; Brand et al. just support adaptation at the target side (this bears the risk of transporting sensible data). Last but not least, we also support changing the object’s interface during runtime.

As our service implementation is based on standard CORBA and the CORBA Life-Cycle Service, we try to simplify the development process of alternative implementations of our AOM service for any programming languages by taking advantage of the CORBA interface repository in the future. This standardised entity allows introspection of a value type’s state and methods. Thus, the generation of the helper methods for loading and saving the state from/to the value type, respectively, are not needed any more. As this is early work, we will further investigate the development model. It is quite complex for a developer to define the state of an adaptive mobile object beforehand. Furthermore, by acting on the assumption of a separation of state and functionality we break the concept of object encapsulation during migration. As shown in this paper, this has many advantages. Nevertheless, we will reconsider this issue. CORBA is not per se a platform for ubiquitous and ambient computing as it is a fully-fledged middleware originally targeting at arbitrary distributed applications running on standard computers. However, there are CORBA implementations like TAO1 that address small and also embedded devices even under realtime conditions. Thus, using our approach in context of ambient computing applications is already possible. Despite this fact, we will investigate to transfer our approach to other technologies, like, e.g., XML RPC and Web Services, for providing an infrastructure that needs less resources.

6.

REFERENCES

[1] F.M.T. Brazier et al. Agent factory: generative migration of mobile agents in heterogeneous environments. In Proceedings of the 2002 ACM symposium on Applied computing , pages 101–106, Madrid, Spain, 2002. ACM Press.

Fig. 8 shows an overview of the capabilities of the presented related work. Our approach is the only one supporting dynamic migration of code and state in heterogeneous environments. The programming language Self [17] allows dynamic adaptation of local objects during runtime. Self is an objectoriented programming language based on the prototype concept. This concept allows manipulation of an object’s methods and state at runtime. Instead of using inheritance for specialisation, an object developer would just copy an existent object and modify the behaviour to the current needs.

CONCLUSION AND FUTURE WORK

We presented a novel approach of a dynamic adaptive object migration service for CORBA. Our service is based on the CORBA Life-Cycle–Service specification and, thus, provides compatibility to other Life-Cycle–Service implementations. In contrast to previous implementations we propose a separation of state, functionality and code. This enables us to provide a service that is capable of supporting heterogeneous platforms and programming languages. Last but not least, we support the user by offering a tool that is able to support the whole development process.

[2] P. Bellavista, A. Corradi, and C. Stefanelli. CORBA Solutions for Interoperability in Mobile Agent Environments. In 2nd International Symposium on Distributed Objects and Applications (DOA’00), pages 283–292. IEEE Computer Society Press, Sep 2000. [3] R. Kapitza, H. Schmidt, and F. J. Hauck. Platform-Independent Object Migration in CORBA. 1

http://www.cs.wustl.edu/ schmidt/TAO.html

In On the Move to Meaningful Internet Systems 2005: CoopIS, DOA, and ODBASE, LNCS 3760, pages 900–917. Springer Verlag, Oct 2005. [4] Object Management Group (OMG). Common Object Request Broker Architecture. Object Management Group (OMG), 3.0.3 edition, March 2004. [5] D.S. Milojicic, W. LaForge, and D. Chauhan. Mobile Objects and Agents (MOA). In 4th USENIX Conference on Object-Oriented Technologies and Systems, pages 179–194, Santa Fe, New Mexico, 1998. [6] M. Strasser, J. Baumann, and F. Hohl. Mole: A Java based mobile agent system. Proceedings of the 2nd ECOOP Workshop on Mobile Object Systems, 1997. [7] D.B. Lange and M. Oshima. Programming and Deploying Java Mobile Agents Aglets, 1998. [8] Choy, Breust, and Magedanz. A CORBA Environment Supporting Mobile Objects. Technical Report White Paper Draft Version 1, IKV++ GmbH, 1999. [9] D.S. Milojicic et al. MASIF: The OMG Mobile Agent System Interoperability Facility. In Mobile Agents: Second International Workshop, MA’98, volume 1477/1998, page 50, Stuttgart, Germany, 1998. Springer LNCS. 1477. [10] Object Management Group (OMG). Life Cycle Service Specification. OMG Document formal/2002-09-01, 2002. [11] R. Kapitza and F.J. Hauck. DLS: a CORBA service for dynamic loading of code. In Proceedings of the OTM Confederated International Conferences, Sicily, Italy, 2003. [12] J. Almeida, M. Wegdam, M. van Sinderen, and L. Nieuwenhuis. Transparent Dynamic Reconfiguration for CORBA. In 3rd International Symposium on Distributed Objects and Applications, pages 197–207. IEEE Computer Society, Sept 2001. [13] Benoit Garbinato, Rachid Guerraoui, Jarle Hulaas, Ole Lehrmann Madsen, Maxime Monod, and Jesper Honig Spring. Mobile Computing with Frugal Objects . Technical report, EPFL I&C, 2005. [14] Carlos Arias Mendez and Manuel Mendes. Agent Migration Issues in CORBA Platforms. In 5th International Symposium on Autonomous Descentralized Systems ISADS’99, Mar 1999. [15] R. Brandt, C. H¨ ortnagel, and H. Reiser. Dynamically Adaptable Mobile Agents for Scaleable Software and Service Management. Journal of Communications and Networks, 3(4):307–316, dec 2001. [16] R. Brandt and H. Reiser. Dynamic Adaptation of Mobile Agents in Heterogenous Environments. In Mobile Agents: Fifth International Conference (MA 2001), pages 70–87. Springer LNCS 2240, Dec 2000. [17] R. B. Smith and D. Ungar. Programming as an Experience: The Inspiration for Self. In ECOOP ’95 Conference, Aug 1995.

[18] R. Tolksdorf and K. Knubben. Programming Distributed Systems with the Delegation-based Object-Oriented Language dSelf. In ACM 2002 SYMPOSIUM ON APPLIED COMPUTING—SAC02, Technical Track on Programming Languages and Object Technologies, 2002.