Abstract for Fabian Bustamante
|
|
|
Abstract for Fabian Bustamante
|
TITLE: Objent : A Framework for High-end Collaborative Applications
AUTHORS: Mustaque Ahamad, Raja Das, Karsten Schwan, Fabian Bustamante, Todd Rose and Dong Zhou
ADRESS: College of Computing, Georgia Institute of Technology, Atlanta, GA 30332 {mustaq,raja,schwan}@cc.gatech.edu
ABSTRACT:
Over the last few years, the World-wide Web has emerged as a popular vehicle for developing distributed collaborative applications. For example, a Web browser enhanced with support for Java applets and Java remote method invocation (RMI) can be used to structure an application where many nodes can perform local computations and cooperate by invoking remote object methods. Although this approach is viable for applications that have limited computational and communication needs, new application are emerging that allow widely distributed users to share rich 3D environments (e.g., complex shared visualizations, VR based distributed games, etc.). To meet the requirements of such applications, it is necessary to provide support for their efficient execution and for low latency access to state shared by distributed application components.
We posit that object and agent technologies should be integrated in future middleware not only because this will result in a single programming model for application developers but more importantly, because these technologies provide complementary functionalities. Namely, distributed objects can offer high performance across wired platforms, using their invocation mechanisms for shipping data to remote nodes, assuming those platforms are able to run their compiled code. Agents, on the other hand, facilitate the use of a wide variety of platforms in both connected and disconnected operation, using their remote evaluation mechanisms via code shipped to those platforms and interpreted on them. Clearly, an agent running interpreted code cannot be assumed to carry out tasks with the same performance as a compiled object.
We propose the Objent framework that can meet the quality-of-service (QoS) requirements of resource intensive and dynamic collaborative applications. The framework includes the following support:
1.Morphing objects/agents into agents/objects
The remote evaluation mechanism that allows a node A to ship code to another node B (via Java applets or the more general agent paradigm) is valuable in dealing with the mobile and highly dynamic nature of application interactions. However, if significant computation needs to be performed (e.g. to generate a complex visualization or mine interesting data), interpretive execution of the agent code at node B may be inefficient. It is necessary to develop techniques that provide more efficient ways of code execution than what are currently available. Object representations of the agent code (when possible) and combining into a single agent the executions of multiple, cooperating agents that have common computations (e.g., mining the same source of data or performing multiple operations on such data) are some of the techniques that can be used to improve performance . Thus, a flexible framework must include support for both object and agent based executions and mechanisms for switching from one to the other.
2.Flexible sharing of state
The agent/object infrastructure addresses the problem of how the code of applications structured using objects and agents be executed flexibly. Once mechanisms are in place to allow an application's code to be executed as an object or agent at a node, the system must make the state accessed by the code available at that node. Furthermore, in a complex distributed collaborative application, the same state could be accessed and shared among multiple application components executing at different nodes. Therefore, to support the full flexibility offered by the integrated object and agent mechanisms, a state sharing system has to be developed. Such a system can employ a variety of techniques that include replication, fragmentation and caching of the shared state that is accessed by object and agent computations.
3.Runtime configuration via events and attributes
The runtime management of mixed agent and object based implementations of dynamic distributed applications requires the availability of light-weight mechanisms that can aid in reconfiguring these implementations. Toward this end, we propose the use of 'distributed events' which can monitor application behaviors and enact changes, by activating configuration services that perform tasks like object adaptation and agent composition. Configuration services rely on support which allows objects and agents to be configured via 'hooks' into their implementations, called 'attributes'. Attributes express selected implementation detail and associated resource needs. Resource management services may be attached to such attributes by being encapsulated in 'configuration objects', which may be invoked synchronously with accesses to objects or agents, or as stated earlier, their execution may be triggered by events in response to external factors or to changes in object, agent, or execution platform state.