Seite drucken

Holger Machens

Foto von Holger Machens
Dr. rer. nat. Holger Machens
E-Mail

Publikationen

Holger Machens. Cloned Transactions: A New Execution Concept for Transactional Memory. PhD Thesis, Hamburg University of Technology, Hamburg, Germany, 2015.
@PhdThesis{Telematik_Machens_2015_Diss, author = {Holger Machens}, title = {Cloned Transactions: A New Execution Concept for Transactional Memory}, school = {Hamburg University of Technology}, address = {Hamburg, Germany}, year = 2015, }
Abstract: Transactional memory aims to replace mutual exclusion in critical sections with transactions on shared data to improve the scalability of concurrent applications and eliminate traditional issues of parallel programming such as deadlocks/livelocks. One key aspect of transaction processing is the concurrency control, which is responsible to find an interleaving or overlapping schedule for running transactions accessing the same shared data and provide a result equal to some serial execution of the same transactions. In this regard, former research focused on single-threaded concurrency control schemes using trial and error approach: The transaction repeats executing the critical section until no conflict with other transactions was detected. This thesis proposes the application of helper threads in transactional memory to achieve a parallelised transaction processing, which is able to compute the same critical section in respect to different serialisation orders with other transactions. While traditional concurrency control has to rollback and start another attempt in the same thread, this approach aims to compute the next attempt in a helper thread in a parallel to current attempt computed by a leading thread. Due to the nature of transactions and concurrent shared memory applications in general, the introduction of helper threads comes with several new aspects to be considered on the conceptional and the implementation level. The work presents concepts for helper thread aided concurrency controls independently executing the same transaction in parallel instead of sharing information of the leader thread, to lower the contention. For example, the detection of conflicts is delegated to a helper thread which executes the same transaction on the same state of shared data in parallel instead of validating the data read by the leader. In this manner parallelised transaction processing has been proposed which executes a transaction in parallel with different validation schemes: lazy and eager validation. Because the reaction time on conflicts and execution time differ, they drift apart and compute results for different serialisation orders. The work also presents several requirements and sub-systems needed to run parallelised transactions: The use of so-called transactional wrappers or pure functions to speedup access to thread private data in transactional sections cannot be granted, because the provate data of the application thread is now concurrently accessed by the helper thread. Also, a concept has been developed to clone the state of the transaction start and transfer the state of the helper committed transaction back to the leader. The existing sandboxing approach of Dalessandro and Scott to suppress and prevent errors in transactions resulting from lazy validation has been improved and memory management inside transactions was adapted. While the development approaches can compete in some cases and show good scalability especially in higher concurrency, the evaluation shows an unexpected large loss of performance, too. An investigation of hardware characteristics in respect to memory and cache read/write latency revealed several scalability issues with concurrent access to the same address.These issues have significant impact on highly concurrent applications, which seriously affects the use of transaction in general and parallelised transactions in particular.
Holger Machens und Volker Turau. Opacity of Memory Management in Software Transactional Memory. Technical Report Report arXiv:1308.2881, arXiv.org e-Print archive, Cornell University, August 2013.
@TechReport{Telematik_MT_2013_OPACITY_of_MM_in_TM, author = {Holger Machens and Volker Turau}, title = {Opacity of Memory Management in Software Transactional Memory}, number = {Report arXiv:1308.2881}, institution = {arXiv.org e-Print archive}, address = {Cornell University}, month = aug, year = 2013, }
Abstract: Opacity of Transactional Memory is proposed to be established by incremental validation. Quiescence in terms of epoch-based memory reclamation is applied to deal with doomed transactions causing memory access violations. This method unfortunately involves increased memory consumption and does not cover reclamations outside of transactions. This paper introduces a different method which combines incremental validation with elements of sandboxing to solve these issues.
Holger Machens und Volker Turau. Avoiding Publication and Privatization Problems on Software Transactional Memory. In 17th GI/ITG Conference on Communication in Distributed Systems (KiVS 2011), Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik, Februar 2011, pp. 97–108. Kiel, Germany.
@InProceedings{Telematik_MT_2011_KIVS, author = {Holger Machens and Volker Turau}, title = {Avoiding Publication and Privatization Problems on Software Transactional Memory}, booktitle = {17th GI/ITG Conference on Communication in Distributed Systems (KiVS 2011)}, pages = {97-108}, series = {OpenAccess Series in Informatics (OASIcs)}, volume = {17}, publisher = {Schloss Dagstuhl--Leibniz-Zentrum fuer Informatik}, day = {25}, month = feb, year = 2011, location = {Kiel, Germany}, }
Abstract: This paper presents a new approach to exclude problems arising from dynamically switching between protected concurrent and unprotected single-threaded use of shared data when using software transactional memory in OO languages such as Java. The approach is based on a simple but effective programming model separating transactions from non-transactional operation. It prevents the application programmer from errors but does not force the software transactional memory library to observe non-transactional access and thereby preserves modularity of the software. A prototypical toolchain for validation and source code instrumentation was implemented as a proof of concept.

Die vollständige Publikationsliste ist separat verfügbar.

Betreute Arbeiten

Abgeschlossene Arbeiten