In this project, protocols, mechanisms, and a Java implementation of nested distributed transactional memory (TM) are developed. Distributed TM promises to alleviate the programmability, scalability, and performance challenges of lock-based distributed concurrency control. Emerging distributed TM implementations export a simple programming interface that precludes locks and are yielding performance comparable to, or better than lock-based distributed concurrency control. Nesting is essential to distributed TM for composability, functionality, fault-management, and performance.
The project is developing protocols and mechanisms to support closed and open nesting in distributed TM. Closed nesting allows a nested transaction to be aborted without aborting the parent transaction, but not vice versa. Open nesting allows a parent transaction to be aborted without aborting the nested transaction, and vice versa, permitting greater concurrency. To support these nesting models, the project is developing distributed transactional conflict resolution protocols, distributed cache coherence protocols, and mechanisms for transparently executing compensating transactions to undo the effects of committed transactions. The project is implementing these techniques in the open-source, HyFlow distributed TM Java package (hyflow.org).
The project is also transitioning this technology (techniques and HyFlow implementation) to US Navy's Aegis Combat System, which uses distributed concurrency control. Additionally, the project's results are being incorporated into advanced graduate courses at Virginia Tech that includes students at Blacksburg, VA, scientists and engineers at US Naval Surface Warfare Center Dahlgren Division (NSWCDD), VA (through Virginia Tech's graduate outreach program at NSWCDD), and students in the Middle East and North Africa through Virginia Tech's VT-MENA program at Egypt.
Nesting is a technique for managing the execution of a transaction that is activated within the context of other transactions. This project focuses on exploiting nesting in distributed systems, where multiple nodes (or processes) interconnected through network links cooperate to atomically execute distributed transactions. The project's research results confirm that employing distributed nested transactions have a direct and significant impact on several aspects of transactional processing. In addition to guaranteeing code composability, functionality, and fault-management, the results show that nesting can improve the performance of distributed transactions. The project extensively investigated two nesting techniques: closed nesting and open nesting. In the closed nesting space, the projectâ€™s most innovative accomplishment is a technique that makes closed-nesting completely transparent to programmers through an automatic nesting framework. This way, programmers can benefit from a fast partial rollback mechanism without the burden of decomposing transactions into closed-nested transactions. In addition, such an automatic nesting framework maximizes the effectiveness of the compositions of nested transactions according to the workload at hand. The project's results showed that open nesting is an effective solution for mitigating the potential performance degradation due to false conflicts in distributed data structures (those that place data structure items on multiple nodes) by releasing read and non-modified objects early in the execution. The process of releasing accessed objects is costly when done by globally committing a part of the transaction (as is the case with open nesting). The project developed a speculative commit scheme for overlapping the transaction's execution with the commit phase of an open-nested transaction, which alleviates the overhead of open nesting. All of the projectâ€™s distributed concurrency control protocols have been implemented and integrated into the HyFlow distributed transactional memory (DTM) middleware software. HyFlow is a software framework for DTM, written in Java, with pluggable support for policies for directory lookup, transactional synchronization and recovery (e.g., nested concurrency control protocols), contention management, and cache coherence. To cope with different programming models and challenges, HyFlow was extended for the Scala (HyFlow2), C++ (HyflowCPP), and Go (Hyflow-go) programming languages. HyFlow exports a distributed programming model that excludes the usage of locks: a programmer can define atomic sections as transactions, in which reads and writes to shared, local and remote objects appear to take effect instantaneously. No changes are needed to the underlying virtual machine or compiler. HyFlow is freely available as open-source software at: http://hyflow.org. The open and closed nesting techniques developed in the project have also been transitioned into Red Hatâ€™s Infinispan (http://infinispan.org/), a production-level, open-source distributed transactional system infrastructure. Infinispan is a distributed in-memory key-value repository with transactional capabilities. The integration of the project's results with Infinispan increases the potential impact of the projectâ€™s nesting techniques, given Infinispanâ€™s large user base. The project's techniques and the HyFlow DTM middleware framework have also been transitioned to US Naval Surface Warfare Center Dahlgren Division (NSWCDD) for production use. The project has contributed to the scientific training of one postdoctoral scholar, four PhD students, one MS student, and two undergraduate students. Additionally, the project has contributed to the development and enhancement of research and teaching skills of two PhD students from the Middle East and North Africa region, as part of Virginia Techâ€™s VT-MENA program. To summarize, the projectâ€™s research results conclusively demonstrate that, it is possible to construct distributed software systems with ease, efficiency, and high performance, using the technology of distributed transactional memory, in particular, by employing the technique of transactional nesting.