No full-text available
To read the full-text of this research,
you can request a copy directly from the author.
Transparent Migration of Java-based Mobile Agents
Abstract
. In this paper we describe a way to save and restore the state of a running Java program. We achieve this on the language level, without modifying the Java virtual machine, by instrumenting the programmer 's original code with a preprocessor. The automatically inserted code saves the runtime information when the program requests state saving and reestablishes the program's runtime state on restart. The current preprocessor prototype is used in a mobile agent scenario to offer transparent agent migration for Java based mobile agents, but could generally be used to save and reestablish the execution state of any Java program. 1 Introduction Mobile agents are programs that can move from one host to another. These programs can initiate their own transfer by executing a special instruction in their code. To migrate an agent, some state information of the agent program has to be saved and shipped to the new destination. At the target destination the agent program is restarted. Ideally, the...
... As such, it is necessary to support object relocation with migration of execution-state. Migration of execution-state is in the literature often referred to as strong thread migration [6]. The fact that the Voyager ORB does not support strong thread migration is not just a missing feature, but the real problem is that migration of the execution-state is simply not supported by current Java technology. ...
... Some require the modification of the JVM [2]. Others are based on the modification of source code [6]. Some models rely on byte code rewrite schemes, e.g., [10][15]. ...
... Several researchers developed mechanisms for strong thread migration in the context of Mobile Agents. S. Funfrocken at TU Darmstadt [6] has implemented a transparent serialization mechanism for local JVM threads by processing the source code of the application. He used the Java exception mechanism to capture the state of an ongoing computation. ...
In this paper we present a mechanism for serializing the execution- state of a distributed Java application that is implemented on a conventional Object Request Broker (ORB) architecture such as Java Remote Method Invocation (RMI). To support capturing and reestablishment of distributed execution-state, we developed a byte code transformer that adds this functionality to a Java application by extracting execution-state from the application code. An important benefit of the serialization mechanism is its portability. It can transparently be integrated into any legacy Java application. Furthermore, it does require no modifications to the Java Virtual Machine (JVM) nor to the underlying ORB. The serialization mechanism can serve many purposes such as migrating execution-state over the network or storing it on disk. In particular, we describe the implementation of a prototype for repartitioning distributed Java applications at runtime. Proper partitioning of distributed objects over the different machines is critical to the global performance of the distributed application. Methods for partitioning exist, and employ a graph-based model of the application being partitioned. Our serialization mechanism enables then applying these methods at any point in an ongoing distributed computation.
... Generally, there is a trade off between efficacity and portability in most works dealing with strong mobility. Indeed, solutions suggested to solve this problem are either non portable solutions but offering good performances like those which are implemented on operating system level [BSA05], [BHKP04], [DO91], and solutions operating on virtual machine level [BHKP04],[SBB + 00], [ZWL02], or more portable solutions but not very powerful like those which operate on compiled code level [GBB05], [TRV + 00], [SSY01], or solutions which operate on process source code level [BN01], [CWHB03], [Fun98], [CLG05]. ...
... Finally, other solutions act on Source Code level [BN01], [CWHB03], [CB06], [DR98], [GYHP06], [Fun98], [CLG05], [SMY99]. This approach has the advantage, to be independent of the operating system, to not modify neither the interpreter, nor the programming language. ...
... In fact, many works use a specific platform [CWHB03], [CB06], or impose the use of a procedural language [BN01], or MPI based program [GYHP06], [CLG05]. Others do not allow a forced migration made by an external application [Fun98], [SMY99], or specifies static checkpoints in the process source code [DR98]. [BSA05] x v x System Virtual [SBB + 00] [BHKP04] x v Java ...
We present in this paper a generic, transparent and portable approach for process transformation into mobile entity. Our approach is based on processes Serialisation using source code transformation, which generates a mobile process with a great portability. Our approach is suitable for transforming distributed applications into mobile applications where every process can be migrated independently. We applied our approach to Java Thread by designing a grammar describing the generated mobile code. The evaluation results of generated
... As such, it is necessary to support object relocation with migration of execution-state. Migration of execution-state is in the literature often referred to as strong thread migration [7]. The fact that the Voyager ORB does not support strong thread migration is not just a missing feature, but the real problem is that migration of execution-state is simply not supported by current Java technology. ...
... Some require the modification of the JVM [3]. Others are based on the modification of source code [7]. Some algorithms rely on byte code rewrite schemes, e.g. ...
... Several researchers developed mechanisms for strong thread migration in the context of Mobile Agents. Stefan Fünfrocken at TU Darmstadt [7] has implemented a transparent serialization mechanism for local JVM threads by processing the source code of the application. In this approach the Java exception mechanism is used to capture the state of an ongoing computation. ...
In this paper we present a mechanism for serializing the execution{state of a distributed Java application that is implemented on a conventional Object Request Broker (ORB) architecture such as Java Remote Method Invocation (RMI). To support serialization of distributed execution{state, we developed a byte code transformer and associated management subsystem that adds this functionality to a Java application by extracting execution{state from the application code. An important bene t of our mechanism is its portability. It can transparently be integrated into any legacy Java application. Furthermore, it does require no modi cations to the Java Virtual Machine (JVM) or to the underlying ORB. Our serialization mechanism can serve many purposes such as migrating execution{state over the network or storing it on disk. In particular, we describe the implementation of a prototype for repartitioning distributed Java applications at run{time. Proper partitioning of distributed objects over the dierent machines is critical to the global performance of the distributed application. Methods for partitioning exist, and employ a graph-based model of the application being partitioned. Our mechanism enables then applying these methods at any point in an ongoing distributed computation. In the implementation of the management subsystem, we experienced the problem of losing logical thread identity when the distributed control ow crosses address space boundaries. We solved this well known problem by introducing the generic notion of distributed thread identity in Java programming. Propagation of a globally unique, distributed thread identity provides a uniform mechanism by which all the program's constituent objects involved in a distributed control ow can uniquely refer to that di...
... As such, it is necessary to support object relocation with migration of execution-state. Migration of execution-state is in the literature often referred to as strong thread migration [7]. The fact that the Voyager ORB does not support strong thread migration is not just a missing feature, but the real problem is that migration of the execution-state is simply not supported by current Java technology. ...
... [3]. Others are based on the modification of source code [7]. Some models rely on byte code rewrite schemes, e.g. ...
... Several researchers developed mechanisms for strong thread migration in the context of Mobile Agents. Stefan Fűnfrocken at TU Darmstadt [7] has implemented a transparent serialization mechanism for local JVM threads by processing the source code of the application. In this approach the Java exception mechanism is used to capture the state of an ongoing computation. ...
In this paper we present a mechanism for serializing the executionstate of a distributed Java application that is implemented on a conventional Object Request Broker (ORB) architecture such as Java Remote Method Invocation (RMI). To support capturing and reestablishment of distributed execution-state, we developed a byte code transformer that adds this functionality to a Java application by extracting execution-state from the application code. An important benefit of the serialization mechanism is its portability. It can transparently be integrated into any legacy Java application.
... As such, it is necessary to support object relocation with migration of execution state. Migration of execution state is in the literature often referred to as strong thread migration [7]. The fact that the Voyager ORB does not support strong thread migration is not just a missing feature, but the real problem is that migration of the execution state is simply not supported by current Java technology. ...
... [3]. Others are based on the modification of source code [7]. Some models rely on byte code rewrite schemes [12]. ...
... Several researchers developed mechanisms for strong thread migration in the context of Mobile Agents. Stefan Fűnfrocken at TU Darmstadt [7] has implemented a transparent serialization mechanism for local JVM threads by processing the source code of the application. In this approach the Java exception mechanism is used to capture the state of an ongoing computation. ...
In this paper we present a mechanism for serializing the execution state of a distributed Java application that is programmed by means of an Object Request Broker such as Java RML To support capturing and reestablishment of distributed execution state, we developed a byte code transformer that adds this functionality to a Java application by extracting execution state from the application code. An important benefit of our mechanism is its portability. It can transparently be integrated into any legacy Java application. Furthermore, it does require no modifications to the Java Virtual Machine (JVM) or to the underlying Object Request Broker. Our mechanism can serve many purposes such as migrating execution state over the network or storing it on dislc In particular, we describe the implementation of a prototype for repartitioning distributed Java applications at runtime. Proper partitioning of distributed objects over the different machines is critical to the global performance of the distributed application. Methods for partitioning exist, and employ a graph-based model of the application being partitioned. Our mechanism enables then applying these methods at any point in an on-going distributed computation.
... In all the above examples, the entire continuation on the point of a go expression always migrates to the destination. This form of migration is called transparent migration [40,45]. Denition 2.1.1 (Migration Transparency). ...
... Migration is called transparent [45] if a migrated program resumes its execution at a destination site with exactly the same execution state as that before migration began. Compared to non-transparent migration, transparent migration is more desirable [32,40,45] for writing programs to be migrated and understanding the semantics of migration. The migration transparency of existing mobile systems is, however, not satisfactory. ...
... In the few systems [32,40,45,87] that support transparent migration, the continuation (the complete execution state of the remaining computation) always migrates to the destination, which incurs considerable performance loss, as pointed out by Cejtin et al. [21] We have extended the Java language by adding three constructs for controlling migration. They are based on our mobile calculus [84] and on mobile languages, such as that developed by Watanabe [99], and allow more exible control of migration, including transparent migration. ...
The mobile form of distributed computation, called mobile computation, is investigated from the viewpoints of computational model, programming language and implementation. The emphasis of this thesis compared with the related work is on analyzing existing mobile language systems from a rather implementational point of view. The contribution of this thesis is threefold. (1) We present a computational model in which dynamic transference of code, data and execution state can be represented. Several mobility mechanisms in existing mobile language systems are analyzed in the model. (2) Based on the analysis, a programming language for mobile computation is designed. The distinctive feature of the language is the facility to control the transparency of migration. (3) An implementation of the mobile programming language is presented. The language is implemented as an extension of the Java language. The implementation is so portable that the program runs on any standard Java inte...
... Migration is called transparent [7] if a migrated program resumes its execution at a destination site with exactly the same execution state as that before migration began. Compared to non-transparent migration, transparent migration is more desirable [3,5,7] for writing programs to be migrated and understanding the semantics of migration. The migration transparency of existing mobile systems is, however, not satisfactory. ...
... { In the few systems [3,5,7,13] that support transparent migration, the continuation (the complete execution state of the remaining computation) always migrates to the destination, which incurs considerable performance loss, as pointed out by Cejtin et al. [2] We have extended the Java language by adding three constructs for controlling migration. They are based on our mobile calculus [11] and on mobile languages, such as that developed by Watanabe [16], and allow more exible control of migration, including transparent migration. ...
... Migratory declarations make source-level translation easier. The system proposed by F unfrocken [5] is also based on source-to-source translation, but it requires the xed-point iteration of a call-graph to determine the set of methods that should be translated because it lacks this kind of declaration. ...
. A scheme has been developed that enables a Java program to be migrated across computers while preserving its execution state, such as the values of local variables and the dynamic extents of try-and-catch blocks. This scheme provides the programmer with flexible control of migration, including transparent migration. It is based on source-code-level transformation. The translator takes as input code a Java program written in a Java language extended with language constructs for migration, and outputs pure Java source code that uses JavaRMI. The translated code can run on any Java interpreter and can be compiled by any just-intime compiler. We have measured some execution performance for several application programs, and found that the translated programs are only about 20% slower than the original programs. Because migration is completely controlled by using only three language constructs added to the Java language (go, undock and migratory), the programmer can write pro...
... This scheme works well for most Java constructs except for catch, and finally because resuming execution in those blocks would require either throwing an exception, or explicitly terminating the preceding try block. This is not mentioned in neither of [7, 8, 5] . The difficulty to inline block statements containing variable declarations arises from the fact that block statements provide name scopes for the variables, and inlining them can possibly require changing names to prevent collisions. ...
... The approaches that more closely resemble my scheme were all designed to allow thread migration with the least overhead possible. Funfrocken's scheme [5] was supposedly the first to allow saving the state of thread by relying solely on source-to-source transformations. In their scheme, continuation are saved by throwing special exceptions in which frames are assembled. ...
Implementing first class continuations poses a problem in Java because virtual machines generally provide no facilities to access or replace the run-time stack from the source code. This project report presents a virtual machine independent and compiler independent technique by which the source code of Java programs can be transformed to easily and efficiently manipulate (partial) continuations. The trans-formations aim at preserving as much as possible program readability and resemblance with the original program, and incurring the least execution overhead. On several aspects the approach is compared with JauVM, a virtual machine that provides continuations.
... Our solution is to instrument the SM bytecode in such a way that SMs can capture and restore their own runtime stack before resuming their normal execution at destination. There are numerous reasons for choosing bytecode transformation [7], [8] over source code transformation [9]. First, source code transformation does not provide fine-grained control as provided by a bytecode transformation (e.g., the lack of goto statement in Java, the difficulty of instrumenting compound statements). ...
... Unlike SMs which were designed specifically for networks of resource constrained devices, these systems are too heavy for devices such as cell-phones or PDAs. Funfrocken [9] implements transparent migration using a source code transformation mechanism (pre-processor). Capturing the method stacks is done within exception handlers. ...
Recent advances in wireless technology allow Java-enabled devices, such as Smart Phones and PDAs, to create mobile ad hoc networks, over which distributed applications can be executed. Although Java shields the programmers from the heterogeneity of the hardware platforms, a common middleware architecture is needed to support a cooperative execution environment in these networks. In this paper, we present a portable runtime system for smart messages (SMs), a middleware architecture based on execution migration, that we designed and implemented on top of an unmodified Java virtual machine. To facilitate portability, we have designed a lightweight migration mechanism based on Java bytecode instrumentation. This mechanism is suitable for mobile ad hoc networks where limited bandwidth and mobility impose constraints on the amount of data transferred. The experimental results for applications executed over wireless networks of HP iPAQs demonstrate the feasibility of our portable runtime system.
... It is, however, difficult for a Java program to manipulate the stack because the Java security policy forbids it. Two different approaches have been proposed for realizing transparent thread migration in Java: virtual machine extension [21] and program transformation schemes [1,12,18,19,26]. Migration is called transparent [13] or strong [4] if a program execution is resumed at a destination site with exactly the same execution state as that of the migration time. ...
... The relationship between partial continuation and transparent thread migration was pointed out by Watanabe [28] and Sekiguchi [20]. Fünfrocken [12] pointed out that an exception handling mechanism could be used for notifying occurrence of state capturing with low costs. He developed a scheme of transparent migration for standard Java, but his scheme had difficulties in resumption of control in a compound statement. ...
This paper describes a scheme of manipulating (partial) continuations in imperative languages such as Java and C++ in a portable manner, where the portability means that this scheme does not depend on structure of the native stack frame nor implementation of virtual machines and runtime systems. Exception handling plays a significant role in this scheme to reduce overheads. The scheme is based on program transformation, but in contrast to CPS transformation, our scheme preserves the call graph of the original program. This scheme has two important applications: transparent migration in mobile computation and checkpointing in a highly reliable system. The former technology enables running computations to move to a remote computer, while the latter one enables running computations to be saved into storages.
... Systems that adopted the approach of compilation model modification are JavaGo [9] and WASP [4]. Neither of the systems support forced mobility [7]. ...
Emerging distributed applications are striving hard to attain the features like scalability, fault tolerance and reliability. Code mobility is an approach to help developers to embed these features in distributed systems. Code mobility is the dynamic replacement of software components from one location to another. The evolution of code mobility has reached the stage where an autonomous entity like mobile agent can be moved from one location to another. But the code mobility has two extremes. At one extreme we have weak mobility and at the other there is strong mobility. The main difference between the two extremes is that strong mobile agent takes the full execution state with itself which is very essential in load balancing and optimum utilization of memory resources. Achieving strong code mobility by preserving the software quality parameters like efficiency, fault tolerance, reliability, portability and minimum code over head becomes a non-trivial task. We have designed and developed a generic efficient system for achieving strong mobility for multi-threaded agents by preserving the software quality parameters mentioned above. For this we adapted byte code transformation approach and used Java. But Java even being popular for the development of multi-agent does not provide access to the execution state of its threads and running threads are not serializable so capturing the state of each thread becomes a challenging task. Our architecture is not for any particular MAS but can be used as stand alone and integrated with any multi-agent system.
... ability to manage dynamic class loading would be a strong combination. Stefan Fünfrocken describes in[12]how to transparently migrate the state of a thread in Java. The approach described uses a preprocessor to instrument the Java code so no bytecode rewriting was necessary. ...
In this paper we describe an implementation of mobile processes with polymorphic interfaces in the ProcessJ language. ProcessJ is a process oriented language based on CSP and the π-calculus. In the paper we demon-strate the translation of ProcessJ to Java/JCSP and illus-trate how to implement mobile processes with polymorphic interfaces without rewriting bytecode; this requires some clever code generation in Java since it does not support polymorphic interfaces.
... There are numerous reasons for choosing bytecode transformation [73,79] over source code transformation [33]. First, source code transformation does not provide fine-grained control as provided by a bytecode transformation (e.g., the lack of goto statement in Java, the difficulty of instrumenting compound statements). ...
Pervasive computing is centered around the idea of provisioning computing services to the user anywhere anytime. If realized, pervasive computing can have a significant impact on our daily lives, ranging from the the way we dress to the way we work and travel. Two key hurdles prohibit the widescale adoption of pervasive computing. First, human cognitive bandwidth is a limited resource; the burden of interacting with pervasive computing applications may outweigh the functionality obtained. Second, pervasive computing applications often assume a smart environment which does not exist today; dependency on a ubiquitous computing infrastructure hampers deployment. In this dissertation, we propose location-aware personal computing as a way of getting close to the pervasive computing vision with minimal overhead. Central to locationaware personal computing is the use of smart phones and location information. Smart phones personify a ubiquitous personal device that can execute client frontends, and connect wirelessly to backend services. Location information serves as a proxy for the user. Smart phones and location information can minimize both user involvement and
... From the programmer's viewpoint we currently offer a weak form of mobility, in which an agent can start a migration by a go-command that is parameterized by the name of the destination platform and the name of the method that should be invoked next. We plan to offer strong migration by source code transformation, comparable to Fünfrocken [10], later. A mobile agent can use one of the following commands to start the migration process: ...
... Similar to the original SM implementation , a number of systems [29, 28, 14] have modified the Java VM (JVM) to provide the required state capturing and restoring, at the cost of loss of portability. Funfrocken [17] implements transparent migration using a source code transformation mechanism (pre-processor). Sakamoto et al [32] and Truyen et al [34] implement migration using a bytecode transformation scheme that does bytecode verification. ...
Smart Phone is a recently emerged technology that sup-ports Java program execution and provides both short-range wireless connectivity (Bluetooth/IrDA) and Internet connectivity (GPRS/3G). Smart Phones represent the first viable ubiquitous computing devices because they are be-coming an integral part of our daily life. Although these phones are closed systems with limited resources, we be-lieve that a multitude of distributed applications in which Smart Phones act as peers in ad hoc networks can be devel-oped. To realize the potential, there is a need for a middle-ware that supports such applications and a systematic study of the communication/computation trade-offs. The middle-ware should provide functionality to support service ex-ecution, discovery and migration and should be able to score well on three criteria: portability, security, and per-formance. To achieve this goal, we have implemented and eval-uated Split Smart Messages (SSM), a lightweight middle-ware architecture similar to mobile agents, that exploits dual connectivity on Smart Phones. Services can be exe-cuted, discovered, and migrated on top of the SSM mid-dleware. To facilitate portability, we have designed an ex-ecution migration scheme that works on top of unmodified Java virtual machines. To improve upon security while pre-serving performance, code is uploaded to and downloaded from a trusted web server, while data and state are trans-ferred across the local network. We have implemented an SSM prototype on Sony Ericsson P800/P900 Smart Phones and compared its performance with that achieved on HP iPAQ PDAs.
... There exist a number of experimental code mobility systems in Java (Bouchenak & Hagimont, 2002; Fuad & Oudshoorn, 2001; Funfrocken, 1998; Sekiguchi, Masuhara, & Yonezawa, 1999; Shudo & Muraoka, 1999), with two systems meeting the criterion of resource aware adaptive code mobility. These two systems are described in the following subsections in order to provide a basis for the framework described in section 4, which aims to build upon the strengths and address the limitations of these systems. ...
Application users are becoming more mobile, expecting instant con-nectivity using a diverse range of heterogeneous devices. Despite the supposed 'write once run anywhere' promise of languages such as Java, developers must contend with a variety of API's such as J2EE, J2SE and J2ME. Application and Internet service providers are faced with increasing costs as developers look to thin client solutions to avoid the complexities of client side development on multiple devices. This leaves client resources unused and servers overloaded. Serving two purposes, this paper first describes a set of laboratory tests demon-strating the effect on server load of distributing a typical business application in various client/server configurations. It then reviews existing work and proposes novel techniques for automating the dynamic distribution of application com-ponents using Java. Advantages of the proposed framework are described from the perspective of service providers, application developers and end users.
... ibed in [7]. Pervasive computing which relies heavily on the data accumulated and processed by such sensor systems have been discussed in[8]. One of the application areas for the behavioral analysis of multiagent systems is distributed fault tolerance systems using multiagents to detect faults in the system, such systems have been described in [9]. [10],[12] and [13] discuss the relation of JAVA based technologies in the domain of multiagents, from transparent migration of agents to monitoring systems developed using multiagents based on a JAVA framework. [11] and [14] describe intelligent multiagent communication systems wherein the messages passed themselves contain information relat ...
An agent is a computer software that is capable of taking independent action on behalf of its user or owner. It is an entity with goals, actions and domain knowledge, situated in an environment. Multiagent systems comprises of multiple autonomous, interacting computer software, or agents. These systems can successfully emulate the entities active in a distributed environment. The analysis of multiagent behavior has been studied in this paper based on a specific board game problem similar to the famous problem of GO. In this paper a framework is developed to define the states of the multiagent entities and measure the convergence metrics for this problem. An analysis of the changes of states leading to the goal state is also made. We support our study of multiagent behavior by simulations based on a CORBA framework in order to substantiate our findings.
... Funfroken implemented process migration by mean of source transformation [8] . It uses a specific compiler in order to add threadstate capturing and restoring in methods of the program. ...
Application migration and heterogeneity are inherent issues of pervasive systems. Each implementation of a pervasive system must provide its own migration framework which hides heterogeneity of the different resources. This leads to the development of many frameworks that perform the same functionality. We propose a minimal execution en- vironment, the micro virtual machine, that factorizes process migration implementation and offers heterogeneity, transparency and performance. Systems implemented on top of this micro virtual machine, such as our own Java virtual machine, will therefore automatically inherit process migration capabilities.
... This is then built on, to present a database application scenario in Section 4, which justifies MARIAN's architecture. Section 5, presents innovative experimental results that further prove the applicability of agents in wireless ad-hoc networks89101112. Section 6, concludes this research work. ...
This paper focuses on the design and development of a novel architecture called MARIAN, which utilises static agents, mobile agents, and also a hybrid approach, in order to perform routing, network discovery, and automatic network reconfiguration, in wireless ad-hoc networks. The paper shows that, in most cases, the static agent approach is faster than the mobile agent approach in retrieving data from a wireless remote database. However, if the amount of data to be retrieved is relatively large, such as in the gathering of data for routing information, the mobile agents are more capable of filtering data according to the required preferences. It also shows that the time taken to gather routing information can be significantly reduced using a mobile agent approach, as compared with the static agent approach.
... The thread stacks are not exposed by the Java VM. In order to save thread stacks, existing schemes either modify the Java VM [12], or instrument the Java code [6]. An important issue in implementing shared objects is defining what exactly a shared object access is. ...
The problem of recovering distributed systems from crash failures has been widely studied in the context of traditional non-threaded processes. However, extending those solutions to the multi-threaded scenario presents new problems. We identify and address these problems for optimistic logging protocols. There are two natural extension to optimistic logging protocols in the multi-threaded scenario. The first extension is process-centric, where the points of internal nondeterminism caused by threads are logged. The second extension is thread-centric, where each thread is treated as a separate process. The process-centric approach suffers from false causality while the thread-centric approach suffers from high causality tracking overhead. By observing that the granularity of failures can be different from the granularity of rollbacks, we design a new balanced approach which incurs low causality tracking overhead and also eliminates false causality. 1.
Optimizing memory management is a major challenge of embedded systems programming, as memory is scarce. Further, embedded systems often have heterogeneous memory architectures, complicating the task of memory allocation during both compilation and migration. However, new opportunities for addressing these challenges have been created by the recent emergence of managed runtimes for embedded systems. By imposing structure on memory, these systems have opened the doors for new techniques for analyzing and optimizing memory usage within embedded systems. This paper presents GEM (Graphs of Embedded Memory), a tool which capitalizes on the structure that managed runtime systems provide in order to build memory graphs which facilitate memory analysis and optimization. At GEM's core are a set of fundamental graph transformations which can be layered to support a wide range of use cases, including interactive memory visualization, de-duplication of objects and code, compilation for heterogeneous memory architectures, and transparent migration. Moreover, since the same underlying infrastructure supports all of these orthogonal functionalities, they can easily be applied together to complement each other.
Optimizing memory management is a major challenge of embedded systems programming, as memory is scarce. Further, embedded systems often have heterogeneous memory architectures, complicating the task of memory allocation during both compilation and migration. However, new opportunities for addressing these challenges have been created by the recent emergence of managed runtimes for embedded systems. By imposing structure on memory, these systems have opened the doors for new techniques for analyzing and optimizing memory usage within embedded systems. This paper presents GEM (Graphs of Embedded Memory), a tool which capitalizes on the structure that managed runtime systems provide in order to build memory graphs which facilitate memory analysis and optimization. At GEM's core are a set of fundamental graph transformations which can be layered to support a wide range of use cases, including interactive memory visualization, de-duplication of objects and code, compilation for heterogeneous memory architectures, and transparent migration. Moreover, since the same underlying infrastructure supports all of these orthogonal functionalities, they can easily be applied together to complement each other.
Mobile Agents are autonomous programs that can travel from computer to computer under their own control. They can provide a convenient, efficient, and robust framework for implementing distributed computing systems, including mobile computing systems. Mobile agent technology is promoted as an emerging technology that makes it much easier to design, implement and maintain distributed systems. The paper explains how existing mobile agent systems migrate agents between computers and execute agent programs, and then present practical applications of the technology. Also, it surveys several existing mobile agent systems and briefly describes some future trends of the technology.
Object-oriented programming languages are in current days, the dominant paradigm of application development (mostly Java and .NET languages). Recently, increasingly more Java applications have long (or very long) execution times and manipulate large amounts of data/information, gaining relevance in fields related with e-Science (with Grid and Cloud computing). Significant examples include chemistry, computational biology and bio-informatics, with many available Java-based APIs (e.g., Neobio). Often, when the execution of one of those applications is terminated abruptly due to a failure (regardless of it being caused by hardware of software fault, lack of available resources,...), all of its work already carried out is simply lost and, when the application is later re-executed, it has to restart its work from scratch, wasting resources and time, and being prone to another failure, to delay its completion with no deadline guarantees. A possible solution to solve these problems, is through mechanisms of checkpoint and migration. This makes applications more robust and flexible by being able to move to other nodes, without intervention from the programmer. This article provides a solution to Java applications with long execution times, by incorporating such mechanisms in a Java VM (JikesRVM).
Object-oriented programming languages presently are the dominant paradigm of application development (e.g., Java, .NET). Lately, increasingly more Java applications have long (or very long) execution times and manipulate large amounts of data/information, gaining relevance in fields related with e-Science (with Grid and Cloud computing). Significant examples include Chemistry, Computational Biology and Bio-informatics, with many available Java-based APIs (e.g., Neobio).
Often, when the execution of such an application is terminated abruptly because of a failure (regardless of the cause being a hardware of software fault, lack of available resources, etc.), all of its work already performed is simply lost, and when the application is later re-initiated, it has to restart all its work from scratch, wasting resources and time, while also being prone to another failure and may delay its completion with no deadline guarantees.
Our proposed solution to address these issues is through incorporating mechanisms for checkpointing and migration in a JVM. These make applications more robust and flexible by being able to move to other nodes, without any intervention from the programmer. This article provides a solution to Java applications with long execution times, by extending a JVM (Jikes research virtual machine) with such mechanisms.
Strong migration of mobile agents is a study hotspot of the mobile agent system, which plays a basic and important role in studying and applying the technology of mobile agents. In this paper, we mainly focus on the technique for strong migration of mobile agent, and propose an approach to capture and reestablish the agent runtime state. This is achieved thanks to the use of type inference technique. We introduce the type-inference technique and describe the design and implementation details of agent strong migration prototype. We report on experiments conducted with our prototype, present a comparative performance evaluation of the main strong migration techniques
One of the biggest challenges in future application development is device heterogeneity. In the future, we expect to see a rich variety of computing devices that can run applications. These devices have different capabilities in processors, memory, networking, screen sizes, input methods, and software libraries. We also expect that future users are likely to own many types of devices. Depending on users’ changing situations and environments, they may choose to switch from one type of device to another that brings the best combination of application functionality and device mobility (size, weight, etc.). Based on this scenario, we have designed and implemented a seamless application framework called the Roam system that can both assist developers to build multi-platform applications that can run on heterogeneous devices and allow a user to move/migrate a running application among heterogeneous devices in an effortless manner. The Roam system is based on partitioning of an application into components and it automatically selects the most appropriate adaptation strategy at the component level for a target platform. To evaluate our system, we have created several multi-platform Roam applications including a Chess game, a Connect4 game, and a shopping aid application. We also provide measurements on application performance and describe our experience with application development in the Roam system. Our experience shows that it is relatively easy to port existing applications to the Roam system and runtime application migration latency is within a few seconds and acceptable to most non-real-time applications.
In this work we present a novel architecture for distributed computing in a peer-to-peer network. In particular, we realize the Paderborn University BSP-based Web Computing Library (PUBWCL), which was formerly used as a centralized client-server architecture for scheduling and load balancing, as a pure peer-to-peer system. By using distributed heterogeneous hash tables (DHHT), our architecture features scheduling and load balancing of tightly coupled, massively parallel algorithms in the bulk-synchronous (BSP) style with a minimal number of migrations. Furthermore, our architecture is capable of heterogeneous BSP programs whereas the former version of PUBWCL could only handle homogeneous BSP programs
,Code offloading is a promising,effort for embedded,systems and,load-balancing. Embedded,systems,will be able to offload compu- tation to nearby,computers,and,large-scale applications,will be able to load-balance computation,during,high load. This paper,presents,a run- time infrastructure,that transparently,distributes computation,between interconnected,workstations. Application,source,code,is not,modified: instead, dynamic aspect weaving within an extended virtual machine al- lows to monitor,and distribute entities dynamically. Runtime,policies for distribution can be dynamically,adapted,depending,on the environment. A first evaluation,of the system,shows,that our technique,increases the transaction,rate of a Web,server during,high load by 73%.
Grid computing has enabled pooling a very large number of heterogeneous resource administered by different security domains. Applications are dynamically deployed on the resources available at the time. Dynamic nature of the resources and applications requirements makes needs the grid middleware to support the ability of migrating a running application to a different resource. Especially, Grid applications are typically long running and thus stoping them and starting them from scratch is not a feasible option. This paper presents an overview of migration support in a java based grid middleware called DGET. Migration support in DGET includes multi-threaded migration and asynchronous migration as well.
The ability to migrate executing programs from one machine to another has much applicability in mobile computing technology. Users can have their applications travel with them, as they move from one computing environment to another. This paper presents the overall design of a framework to support migratory applications in a networked-environment, called Camel. The framework for adaptive migratory applications, Camel, is an attempt not only to implement migratory applications in Java, but to do this in a way which provides the support for mobile code. Furthermore, the Camel framework is designed specifically to support dynamic and adaptive migratory applications. Camel supports adaptation by migrating the application to another node to avoid congested link, and thus provide an understanding of the adaptation through migration technique.
The problem of recovering distributed systems from crash failures has been widely studied in the context of traditional non-threaded processes. However, extending those solutions to the multi-threaded scenario presents new problems. We identify and address these problems for optimistic logging protocols. There are two natural extension to optimistic logging protocols in the multi-threaded scenario. The first extension is process-centric, where the points of internal non-determinism caused by threads are logged. The second extension is thread-centric, where each thread is treated as a separate process. The process-centric approach suffers from false causality while the thread-centric approach suffers from high causality tracking overhead. By observing that the granularity of failures can be different from the granularity of rollbacks, we design a new balanced approach which incurs low causality tracking overhead and also eliminates false causality
D'Agents is a general-purpose mobile-agent system that has been used in several informationretrieval applications. In this paper, we rst examine one such application, operational support for military eld personnel, where D'Agents greatly simpli es the task of providing ecient, application-speci c access to remote information resources. After describing the application, we discuss the key dierences between D'Agents and most other mobile-agent systems, notably its support for strong mobility and multiple agent languages. Finally, we derive a small, simple application that is representative of many information-retrieval tasks, including those in the example application, and use this application to compare the scalability of mobile agents and traditional client/server approaches. The results con rm and quantify the usefulness of mobile code, and perhaps more importantly, con rm that intuition about when to use mobile code is usually correct. Although signi cant additional experiments are needed to fully characterize the complex mobile-agent performance space, the results here help answer the basic question of when mobile agents should be considered at all, particularly for information-retrieval applications.
. This paper proposes a Javabytecode transformation algorithm for realizing transparent thread migration in a portable and efficient manner. In contrast to previous studies, our approach does not need extended virtual machines nor source code of target programs. The whole state of stack frames is saved, and then restored at a remote site. Toaccomplish this goal, a type system for Javabytecode is used to correctly determine valid frame variables and valid entries in the operand stack. A target program is transformed based on the type information into a form so that it can perform transparent thread migration. Wehavealso measured execution efficiency of transformed programs and growth in bytecode size, and obtained better results compared to previous studies. 1 Introduction Mobile computation is a promising programming paradigm for network-oriented applications where running computations roam over the network. Various kinds of applications are proposed such as electric commer...
ResearchGate has not been able to resolve any references for this publication.