Abstract
This paper presents the integration of the Amadeus distributed object system with the RelaX transaction facility, providing a language-independent framework for atomic objects. By decoupling transaction management from specific programming languages and utilizing a generalized transaction model, the system supports advanced features such as nested transactions and relaxed isolation. We describe the modular architecture, the mechanism for runtime object promotion, and performance benchmarks demonstrating the efficiency of group commitment in distributed environments.
1. Introduction
In the early 1990s, the development of reliable distributed applications faced a significant architectural divide. Developers were forced to choose between language-specific research systems, such as Argus or Arjuna, which provided high-level "atomic object" abstractions but lacked interoperability, and commercial transaction monitors like Tuxedo, which followed the X/Open DTP model but were ill-suited for object-oriented paradigms.
This paper addresses the gap by proposing a system that is language-independent, extensible to various resource types, and portable across UNIX platforms. The core contribution is the synthesis of the Amadeus platform for distributed, persistent objects and the RelaX extensible transaction facility.
2. System Architecture
The architecture relies on a clear separation of concerns between object management and transaction logic.
2.1 Amadeus: Distributed Object Management
Amadeus provides the infrastructure for distributed and persistent objects. It utilizes a two-tier runtime approach:
- Generic Runtime (GRT): Handles the underlying complexities of distribution and persistence.
- Language Specific Runtimes (LSR): Maps GRT features to specific languages, such as C++ or Eiffel, through a set of standardized "upcalls."
2.2 RelaX: Generalized Transactions
RelaX serves as an extensible transaction facility. Unlike traditional monitors that enforce strict ACID properties, RelaX supports a generalized transaction model. This model allows transactions to utilize uncommitted data by tracking dependencies, thereby increasing concurrency without compromising system safety.
3. Technical Innovations
The integration of Amadeus and RelaX introduced several key technical mechanisms:
- Access Trapping via Class Versioning: To avoid performance penalties for non-atomic objects, the system generates two versions of a class. When an object is "promoted" to an atomic state at runtime, its function table pointer is swapped. This ensures that standard objects incur zero overhead from the transaction system.
- Modular Resource Managers: The Amadeus runtime acts as a Resource Manager (RM), communicating with a Transaction Manager (TM) via an extended version of the X/Open XA interface.
- Volatile Recovery Points: To optimize performance, the system creates recovery points in volatile memory rather than performing synchronous disk writes for every change. Data is only forced to a stable log during the commit phase.
4. Evaluation and Results
The system was evaluated using a distributed interactive calendar application and synthetic performance benchmarks. The testing environment consisted of three DECStation 2100s connected via 10Mbit/sec Ethernet.
4.1 Performance Metrics
The benchmarks revealed the following latencies:
- Local Invocation: ~0.8 ms.
- Completing Transaction (Pre-commit): ~185 ms.
- Distributed Commit (3 sites): ~826 ms.
4.2 Group Commitment
A significant finding was the impact of "Group Commitment." By batching multiple transactions into a single disk write, the system reduced the average overhead per transaction for a 3-site distributed task from ~826 ms to ~734 ms.
5. Discussion
The Amadeus/RelaX integration demonstrates that atomicity can be treated as an orthogonal property of an object's type. By allowing objects to be promoted to atomic status at runtime, developers can selectively apply transaction overhead only where necessary. Furthermore, the use of "upcalls" between the GRT and LSR proves that transaction support can be implemented as a library-level service rather than being hard-coded into a compiler.
6. Limitations and Future Work
Despite its successes, the system exhibits a substantial latency gap between standard and transactional method calls. Additionally, the C++ implementation requires object access to occur via function tables, meaning direct member variable access is not automatically protected. Future work includes the integration of relational databases into the object model and the implementation of replicated objects to enhance fault tolerance.
7. Conclusion
The integration of Amadeus and RelaX represents a milestone in distributed systems, offering a flexible, language-independent framework for building reliable applications. Its modular approach to transaction management and object persistence remains a foundational concept in the evolution of distributed middleware.
Summary updated