Transactional Memory Bibliography

[Shavit and Touitou, 1995]

Nir Shavit and Dan Touitou (Aug 1995).
Software Transactional Memory.
In: Proceedings of the 14th ACM Symposium on Principles of Distributed Computing. pp. 204--213.

[Moir, 1997]

Mark Moir (Sep 1997).
Transparent Support for Wait-Free Transactions.
In: 11th International Workshop on Distributed Algorithms. pp. 305--319.

[Herlihy et al., 2003]

Maurice Herlihy and Victor Luchangco and Mark Moir and III William N. Scherer (Jul 2003).
Software Transactional Memory for Dynamic-Sized Data Structures.
In: PODC~'03: Proc. 22nd ACM Symposium on Principles of Distributed Computing. pp. 92--101.

[Harris and Fraser, 2003]

Tim Harris and Keir Fraser (Oct 2003).
Language Support for Lightweight Transactions.
In: Object-Oriented Programming, Systems, Languages, and Applications. pp. 388--402.

[Fraser, 2003]

Keir Fraser ( 2003).
Practical lock freedom.
PhD thesis, Cambridge University Computer Laboratory. Also available as Technical Report UCAM-CL-TR-579.

[Marathe and Scott, 2004]

Virendra J. Marathe and Michael L. Scott (Jun 2004).
A Qualitative Survey of Modern Software Transactional Memory Systems.
Technical Report Nr. TR 839. University of Rochester Computer Science Dept..

[Cole and Herlihy, 2004]

Christopher Cole and Maurice Herlihy (Jul 2004).
Snapshots and Software Transactional Memory.
In: Proceedings of the ACM PODC Workshop on Concurrency and Synchronization in Java Programs.

[Scherer III and Scott, 2004]

William N. Scherer III and Michael L. Scott (Jul 2004).
Contention Management in Dynamic Software Transactional Memory.
In: Proceedings of the ACM PODC Workshop on Concurrency and Synchronization in Java Programs. St. John's, NL, Canada. In conjunction with PODC'04. Please also download errata from www.cs.rochester.edu/u/scott/papers/2004_CSJP_contention_mgmt_errata.pdf.

[Marathe et al., 2004]

Virendra J. Marathe and William N. Scherer III and Michael L. Scott (Oct 2004).
Design Tradeoffs in Modern Software Transactional Memory Systems.
In: Proceedings of the 7th Workshop on Languages, Compilers, and Run-time Systems for Scalable Computers. Houston, TX.

[Welc et al., 2004]

Adam Welc and Suresh Jagannathan and Antony L. Hosking ( 2004).
Transactional monitors for concurrent objects.
In: (ed.), Proceedings of the European Conference on Object-Oriented Programming. Volume 3086 of Lecture Notes in Computer Science. pp. 519--542. Published by Springer-Verlag.

[Lev and Moir, 2004]

Yossi Lev and Mark Moir ( 2004).
Fast read sharing mechanism for software transactional memory (poster).
In: PODC~'04: Proc. 23rd ACM Symposium on Principles of Distributed Computing.

[Shinnar et al., 2004]

Avraham Shinnar and David Tarditi and Mark Plesko and Bjarne Steensgaard (dec 2004).
Integrating support for undo with exception handling.
Technical Report Nr. MSR-TR-2004-140. Microsoft Research.

[Ennals, 2005]

Robert Ennals (Jan 2005).
Efficient Software Transactional Memory.
Technical Report Nr. IRC-TR-05-051. Intel Research Cambridge Tech Report.

[Marathe and Scott, 2005]

Virendra J. Marathe and Michael L. Scott (Jul 2005).
Using LL/SC to Simplify Word-based Software Transactional Memory (POSTER).
In: Proceedings of the 24th ACM Symposium on Principles of Distributed Computing. Las Vegas, NV.

[Moir, 2005]

Mark Moir (Jul 2005).
Hybrid Transactional Memory.
Unpublished manuscript.

[Scherer III and Scott, 2005]

William N. Scherer III and Michael L. Scott (Jul 2005).
Advanced Contention Management for Dynamic Software Transactional Memory.
In: Proceedings of the 24th ACM Symposium on Principles of Distributed Computing. Las Vegas, NV.

[Scherer III and Scott, 2005]

William N. Scherer III and Michael L. Scott (Jul 2005).
Randomization in STM Contention Management (POSTER).
In: Proceedings of the 24th ACM Symposium on Principles of Distributed Computing. Las Vegas, NV. Winner, most popular poster presentation award.

[Marathe et al., 2005]

Virendra J. Marathe and William N. Scherer III and Michael L. Scott (Sep 2005).
Adaptive Software Transactional Memory.
In: Proceedings of the 19th International Symposium on Distributed Computing. Cracow, Poland. Earlier but expanded version available as TR 868, University of Rochester Computer Science Dept., May2005.

[Ananian and Rinard, 2005]

C. Scott Ananian and Martin Rinard (Oct 2005).
Efficient Object-Based Software Transactions.
In: Proceedings, Workshop on Synchronization and Concurrency in Object-Oriented Languages. San Diego, CA. In conjunction with OOPSLA'05.

[Cachopo and Rito-Silva, 2005]

Joao Cachopo and Antonio Rito-Silva (oct 2005).
Versioned Boxes as the Basis for Memory Transactions.
In: OOPSLA 2005 Workshop on Synchronization and Concurrency in Object-Oriented Languages (SCOOL).

[Guerraoui et al., 2005]

Rachid Guerraoui and Maurice Herlihy and Michal Kapalka and Bastian Pochon (October 2005).
Robust Contention Management in Software Transactional Memory.
In: Proceedings of the OOPSLA Workshop on Synchronization and Concurrency in Object-Oriented Languages (SCOOL).

[Lev and Maessen, 2005]

Yossi Lev and Jan-Willem Maessen (October 2005).
Toward a Safer Interaction with Transactional Memory by Tracking Object Visibility.
In: Proceedings, Workshop on Synchronization and Concurrency in Object-Oriented Languages. San Diego, CA.

[Luchangco and Marathe, 2005]

Victor Luchangco and Virendra J. Marathe (oct 2005).
Transaction Synchronizers.
In: OOPSLA 2005 Workshop on Synchronization and Concurrency in Object-Oriented Languages (SCOOL).

[Ennals, 2006]

Robert Ennals (Jan 2006).
Software Transactional Memory Should Not Be Obstruction-Free.
Technical Report Nr. IRC-TR-06-052. Intel Research Cambridge Tech Report.

[Carlstrom et al., 2006]

Brian D. Carlstrom and JaeWoong Chung and Christos Kozyrakis and Kunle Olukotun (Mar 2006).
The Software Stack for Transactional Memory: Challenges and Opportunities.
In: Proc. 1st Workshop on Software Tools for Multi-Core Systems.

[Kumar et al., 2006]

Sanjeev Kumar and Michael Chu and Christopher J. Hughes and Partha Kundu and Anthony Nguyen (Mar 2006).
Hybrid Transactional Memory.
In: Proceedings of Symposium on Principles and Practice of Parallel Programming.

[Marathe et al., 2006]

Virendra J. Marathe and Michael F. Spear and Christopher Heriot and Athul Acharya and David Eisenstat and William N. Scherer III and Michael L. Scott (Mar 2006).
Lowering the Overhead of Software Transactional Memory.
Technical Report Nr. TR 893. Computer Science Department, University of Rochester. Condensed version submitted for publication.

[Saha et al., 2006]

Bratin Saha and Ali-Reza Adl-Tabatabai and Richard L. Hudson and Chi Cao Minh and Benjamin Hertzberg (Mar 2006).
McRT-STM: a High Performance Software Transactional Memory System for a Multi-core Runtime.
In: Proc. 11th ACM SIGPLAN Symp. on Principles and Practice of Parallel Programming (PPoPP '06). pp. 187-197.

[Hindman and Grossman, 2006]

B. Hindman and D. Grossman (may 2006).
Strong atomicity for Java without virtual-machine support.
Technical Report Nr. 2006-05-01catId1 = {SW},. University of Washington, Dept. Computer Science.

[Adl-Tabatabai et al., 2006]

Ali-Reza Adl-Tabatabai and Brian T. Lewis and Vijay Menon and Brian R. Murphy and Bratin Saha and Tatiana Shpeisman (Jun 2006).
Compiler and Runtime Support for Efficient Software Transactional Memory.
In: Proceedings of the 2006 Conference on Programming language design and implementation. pp. 26--37.

[Hudson et al., 2006]

Richard L. Hudson and Bratin Saha and Ali-Reza Adl-Tabatabai and Benjamin C. Hertzberg (jun 2006).
McRT-Malloc: a scalable transactional memory allocator.
In: ISMM~'06: Proc. 5th International Symposium on Memory Management. pp. 74--83.

[Dice and Shavit, 2006]

David Dice and Nir Shavit (Jun 2006).
What Really Makes Transactions Faster?
In: Proceedings of the First ACM SIGPLAN Workshop on Languages, Compilers, and Hardware Support for Transactional Computing.

[Harris et al., 2006]

Tim Harris and Mark Plesko and Avraham Shinnar and David Tarditi (Jun 2006).
Optimizing Memory Transactions.
In: Proceedings of the 2006 Conference on Programming language design and implementation. pp. 14-25. ACM Press.

[Marathe et al., 2006]

Virendra J. Marathe and Michael F. Spear and Christopher Heriot and Athul Acharya and David Eisenstat and William N. Scherer III and Michael L. Scott (Jun 2006).
Lowering the Overhead of Software Transactional Memory.
In: ACM SIGPLAN Workshop on Transactional Computing. Held in conjunction with PLDI 2006. Expanded version available as TR 893, Department of Computer Science, University of Rochester, March 2006.

[Riegel et al., 2006]

Torvald Riegel and Christof Fetzer and Pascal Felber (Jun 2006).
Snapshot Isolation for Software Transactional Memory .
In: Proceedings of the First ACM SIGPLAN Workshop on Languages, Compilers, and Hardware Support for Transactional Computing.

[Welc et al., 2006]

Adam Welc and Antony L. Hosking and Suresh Jagannathan (Jul 2006).
Transparently Reconciling Transactions with Locking for Java Synchronization.
In: European Conference on Object-Oriented Programming. pp. 148--173.

[Cachopo and Rito-Silva, 2006]

Jo\~ao Cachopo and Ant\'onio Rito-Silva (jul 2006).
Combining software transactional memory with a domain modeling language to simplify web application development.
In: ICWE~'06: Proc. 6th international conference on Web engineering. pp. 297--304.

[Dice et al., 2006]

Dave Dice and Ori Shalev and Nir Shavit (sep 2006).
Transactional Locking II.
In: DISC~'06: Proc. 20th International Symposium on Distributed Computing. pp. 194--208. Springer-Verlag Lecture Notes in Computer Science volume 4167.

[Riegel et al., 2006]

Torvald Riegel and Pascal Felber and Christof Fetzer (Sep 2006).
A Lazy Snapshot Algorithm with Eager Validation.
In: (ed.), Proceedings of the 20th International Symposium on Distributed Computing, DISC 2006. Volume 4167 of Lecture Notes in Computer Science. pp. 284--298. Springer.

[Herlihy et al., 2006]

Maurice Herlihy and Mark Moir and Victor Luchangco (oct 2006).
A Flexible Framework for Implementing Software Transactional Memory.
In: Proceedings of the 21th ACM SIGPLAN Conference on Object-Oriented Programing, Systems, Languages, and Applications. pp. 253-262.

[Adl-Tabatabai et al., 2006]

Ali-Reza Adl-Tabatabai and Christos Kozyrakis and Bratin Eswaran Saha (Dec 2006).
Unlocking Concurrency: Multicore Programming with Transactional Memory.
In: ACM Queue, 4(10):24--33.

[Saha et al., 2006]

Bratin Saha and Ali-Reza Adl-Tabatabai and Quinn Jacobson ( 2006).
Architectural Support for Software Transactional Memory.
In: MICRO 39: Proceedings of the 39th Annual IEEE/ACM International Symposium on Microarchitecture. pp. 185--196. Published by IEEE Computer Society.

[Damron et al., 2006]

Peter Damron and Alexandra Fedorova and Yossi Lev and Victor Luchangco and Mark Moir and Dan Nussbaum ( 2006).
Hybrid Transactional Memory.
In: Proceedings of the 12th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS). pp. 336-346.

[Larus and Rajwar, 2006]

James R. Larus and Ravi Rajwar ( 2006).
Transactional Memory.
Morgan & Claypool.

[Dice and Shavit, 2007]

Dave Dice and Nir Shavit (mar 2007).
Understanding Tradeoffs in Software Transactional Memory.
In: CGO~'07: Proceedings of the International Symposium on Code Generation and Optimization. pp. 21--33.

[Ni et al., 2007]

Yang Ni and Vijay S. Menon and Ali-Reza Adl-Tabatabai and Antony L. Hosking and Richard L. Hudson and J. Eliot B. Moss and Bratin Saha and Tatiana Shpeisman (mar 2007).
Open nesting in software transactional memory.
In: PPoPP~'07: Proc. 12th ACM SIGPLAN symposium on Principles and practice of parallel programming. pp. 68--78.

[Saha et al., 2007]

Bratin Saha and Ali-Reza Adl-Tabatabai and Anwar Ghuloum and Mohan Rajagopalan and Richard L. Hudson and Leaf Petersen and Vijay Menon and Brian Murphy and Tatiana Shpeisman and Eric Sprangle and Anwar Rohillah and Doug Carmean and Jesse Fang (mar 2007).
Enabling scalability and performance in a large scale CMP environment.
In: EuroSys~'07: Proc. 2nd ACM SIGOPS/EuroSys European Conference on Computer Systems 2007. pp. 73--86.

[Sonmez et al., 2007]

Nehir Sonmez and Cristian Perfumo and Srdan Stipic and Osman Unsal and Adrian Cristal and Mateo Valero (apr 2007).
UnreadTVar: Extending Haskell Software Transactional Memory for Performance.
In: Symposium on Trends in Functional Programming.

[Isard and Birrell, 2007]

Michael Isard and Andrew Birrell (may 2007).
Automatic Mutual Exclusion.
In: HotOS~'07: Proc. 11th Workshop on Hot Topics in Operating Systems.

[Elmas et al., 2007]

Tayfun Elmas and Shaz Qadeer and Serdar Tasiran (jun 2007).
Goldilocks: a race and transaction-aware Java runtime.
In: PLDI~'07: Proc. 2007 ACM SIGPLAN conference on Programming language design and implementation. pp. 245--255.

[Zilles and Rajwar, 2007]

Craig Zilles and Ravi Rajwar (jun 2007).
Transactional memory and the birthday paradox (brief announcement).
In: SPAA~'07: Proc. 19th Symposium on Parallel Algorithms and Architectures. pp. 303--304. A longer version is available as Technical Report UIUCDCS-R-2007-2835, March 2007.

[Cao Minh et al., 2007]

Chi Cao Minh and Martin Trautmann and JaeWoong Chung and Austen McDonald and Nathan Bronson and Jared Casper and Christos Kozyrakis and Kunle Olukotun (Jun 2007).
An Effective Hybrid Transactional Memory System with Strong Isolation Guarantees.
In: Proceedings of the 34th Annual International Symposium on Computer Architecture.

[Riegel et al., 2007]

Torvald Riegel and Christof Fetzer and Pascal Felber (Jun 2007).
Time-based Transactional Memory with Scalable Time Bases.
In: 19th ACM Symposium on Parallelism in Algorithms and Architectures (SPAA) .

[Lev et al., 2007]

Yosef Lev and Mark Moir and Dan Nussbaum (aug 2007).
PhTM: Phased Transactional Memory.
In: TRANSACT~'07: 2nd Workshop on Transactional Computing.

[Lourenco and Cunha, 2007]

Joao M.S. Lourenco and Goncalo T. Cunha ( 2007).
Testing patterns for software transactional memory engines.
In: PADTAD '07: Proceedings of the 2007 ACM workshop on Parallel and distributed systems: testing and debugging. New York, NY, USA, pp. 36--42. Published by ACM.

[Ferri et al., 2007]

Cesare Ferri and Tali Moreshet and R. Iris Bahar and Luca Benini and Maurice Herlihy ( 2007).
A hardware/software framework for supporting transactional memory in a MPSoC environment.
In: SIGARCH Comput. Archit. News, 35(1):47--54.

[Bai et al., 2007]

Tongxin Bai and Xipeng Shen and Chengliang Zhang and William N. Scherer III and Chen Ding and Michael L. Scott ( 2007).
A Key-based Adaptive Transactional Memory Executor.
In: IPDPS~'07: Proc. 21st International Parallel and Distributed Processing Symposium. Also available as TR 909, Department of Computer Science, University of Rochester, December 2006.

[Lev et al., 2007]

Yossi Lev and Mark Moir and Dan Nussbaum ( 2007).
PhTM: Phased Transactional Memory.
In: Workshop on Transactional Computing (TRANSACT).

[Tabba et al., 2007]

Fuad Tabba and Cong Wang and James R. Goodman and Mark Moir ( 2007).
NZTM: Nonblocking, Zero-Indirection Transactional Memory.
In: Workshop on Transactional Computing (TRANSACT).

[Marathe and Moir, 2008]

Virendra J. Marathe and Mark Moir (feb 2008).
Toward high performance nonblocking software transactional memory.
In: PPoPP~'08: Proc. 13th ACM SIGPLAN Symposium on Principles and practice of parallel programming. pp. 227--236.

[Felber et al., 2008]

Pascal Felber and Christof Fetzer and Torvald Riegel (feb 2008).
Dynamic performance tuning of word-based software transactional memory.
In: PPoPP~'08: Proc. 13th ACM SIGPLAN Symposium on Principles and practice of parallel programming. pp. 237--246.

[Bocchino et al., 2008]

Robert L. Bocchino and Vikram S. Adve and Bradford L. Chamberlain (feb 2008).
Software transactional memory for large scale clusters.
In: PPoPP~'08: Proc. 13th ACM SIGPLAN Symposium on Principles and practice of parallel programming. pp. 247--258.

[Herlihy and Koskinen, 2008]

Maurice Herlihy and Eric Koskinen (feb 2008).
Dreadlocks: Efficient Deadlock Detection for STM.
In: TRANSACT~'08: 3rd Workshop on Transactional Computing.

[Riegel and Brum, 2008]

Torvald Riegel and Diogo B. D. Brum (feb 2008).
Making Object-Based STM Practical in Unmanaged Environments.
In: TRANSACT~'08: 3rd Workshop on Transactional Computing.

[Spear et al., 2008]

Michael F. Spear and Maged Michael and Michael L. Scott (feb 2008).
Inevitability Mechanisms for Software Transactional Memory.
In: TRANSACT~'08: 3rd Workshop on Transactional Computing.

[Vallejo et al., 2008]

Enrique Vallejo and Tim Harris and Adri\'an Cristal and Osman S. Unsal and Mateo Valero (feb 2008).
Hybrid Transactional Memory to accelerate safe lock-based transactions.
In: TRANSACT~'08: 3rd Workshop on Transactional Computing.

[Liu et al., 2008]

Yu David Liu and Xiaoqi Lu and Scott F. Smith (mar 2008).
Coqa: Concurrent Objects with Quantized Atomicity.
In: CC~'08: Proc. International Conference on Compiler Construction. pp. 260-275.

[Cunningham et al., 2008]

Dave Cunningham and Khilan Gudka and Susan Eisenbach (mar 2008).
Keep Off the Grass: Locking the Right Path for Atomicity.
In: CC~'08: Proc. International Conference on Compiler Construction. pp. 276--290.

[Wang et al., 2008]

Cheng Wang and Victor Ying and Youfeng Wu (mar 2008).
Supporting Legacy Binary Code in a Software Transaction Compiler with Dynamic Binary Translation and Optimization.
In: CC~'08: Proc. International Conference on Compiler Construction. pp. 291-306.

[Perfumo et al., 2008]

Cristian Perfumo and Nehir S\"onmez and Srdjan Stipic and Osman S. Unsal and Adri\'an Cristal and Tim Harris and Mateo Valero (may 2008).
The limits of software transactional memory (STM): dissecting Haskell STM applications on a many-core environment.
In: CF~'08: Proc. 5th conference on Computing frontiers. pp. 67--78.

[Avni and Shavit, 2008]

Hillel Avni and Nir Shavit (jun 2008).
Maintaining Consistent Transactional States Without a Global Clock.
In: SIROCCO~'08: Proc.15th International Colloquium on Structural Information and Communication Complexity. pp. 131--140. Springer-Verlag Lecture Notes in Computer Science volume 5058.

[Yoo and Lee, 2008]

Richard M. Yoo and Hsien-Hsin S. Lee (jun 2008).
Adaptive transaction scheduling for transactional memory systems.
In: SPAA~'08: Proc. twentieth annual symposium on Parallelism in algorithms and architectures. pp. 169--178.

[Kulkarni et al., 2008]

Milind Kulkarni and Patrick Carribault and Keshav Pingali and Ganesh Ramanarayanan and Bruce Walter and Kavita Bala and L. Paul Chew (jun 2008).
Scheduling strategies for optimistic parallel execution of irregular programs.
In: SPAA~'08: Proc. twentieth annual symposium on Parallelism in algorithms and architectures. pp. 217--228.

[Yoo et al., 2008]

Richard M. Yoo and Yang Ni and Adam Welc and Bratin Saha and Ali-Reza Adl-Tabatabai and Hsien-Hsin S. Lee (jun 2008).
Kicking the tires of software transactional memory: why the going gets tough.
In: SPAA~'08: Proc. twentieth annual symposium on Parallelism in algorithms and architectures. pp. 265--274.

[Spear et al., 2008]

Michael F. Spear and Maged M. Michael and Christoph von Praun (jun 2008).
RingSTM: scalable transactions with a single atomic instruction.
In: SPAA~'08: Proc. twentieth annual symposium on Parallelism in algorithms and architectures. pp. 275--284.

[Koskinen and Herlihy, 2008]

Eric Koskinen and Maurice Herlihy (jun 2008).
Dreadlocks: efficient deadlock detection.
In: SPAA~'08: Proc. twentieth annual symposium on Parallelism in algorithms and architectures. pp. 297--303.

[Zhang et al., 2008]

Rui Zhang and Zoran Budimli\'c and William N. Scherer III (jun 2008).
Commit phase in timestamp-based STM.
In: SPAA~'08: Proc. twentieth annual symposium on Parallelism in algorithms and architectures. pp. 326--335.

[Ziarek et al., 2008]

Lukasz Ziarek and Adam Welc and Ali-Reza Adl-Tabatabai and Vijay Menon and Tatiana Shpeisman and Suresh Jagannathan (jul 2008).
A Uniform Transactional Execution Environment for Java.
In: ECOOP~'08: Proc. 22nd European Conference on Object-Oriented Programming. pp. 129--154. Springer-Verlag Lecture Notes in Computer Science volume 5142.

[Spear et al., 2008]

Michael F. Spear and Andrew Sveikauskas and Michael L. Scott (aug 2008).
Transactional memory retry mechanisms (brief announcement).
In: PODC~'08: Proceedings of the twenty-seventh ACM symposium on Principles of distributed computing. pp. 453--453. Expanded version available as TR 935, University of Rochester Computer Science Dept., June 2008.

[Ansari et al., 2008]

Mohammad Ansari and Christos Kotselidis and Kim Jarvis and Mikel Luj\'an and Chris Kirkham and Ian Watson (aug 2008).
Advanced Concurrency Control for Transactional Memory using Transaction Commit Rate.
In: EUROPAR~'08: Proc. 14th European Conference on Parallel Processing. pp. 719--728. Springer-Verlag Lecture Notes in Computer Science volume 5168.

[Dolev et al., 2008]

Shlomi Dolev and Danny Hendler and Adi Suissa (August 2008).
CAR-STM: scheduling-based collision avoidance and resolution for software transactional memory.
In: Proceedings of the Twenty-Seventh Annual ACM Symposium on Principles of Distributed Computing (PODC). pp. 125--134.

[Schneider et al., 2008]

Florian T. Schneider and Vijay Menon and Tatiana Shpeisman and Ali-Reza Adl-Tabatabai (sep 2008).
Dynamic optimization for efficient strong atomicity.
In: OOPSLA~'08: Proc. 23rd ACM SIGPLAN conference on Object-oriented programming systems languages and applications. pp. 181--194.

[Guerraoui et al., 2008]

Rachid Guerraoui and Thomas Henzinger and Vasu Singh (sep 2008).
Permissiveness in Transactional Memories.
In: DISC~'08: Proc. 22nd International Symposium on Distributed Computing. pp. 305--319. Springer-Verlag Lecture Notes in Computer Science volume 5218.

[Marathe et al., 2008]

Virendra J. Marathe and Michael F. Spear and Michael L. Scott (sep 2008).
Scalable Techniques for Transparent Privatization in Software Transactional Memory.
In: ICPP~'08: Proc. 37th International Conference on Parallel Processing.

[Romano et al., 2008]

Paolo Romano and Nuno Carvalho and Lu\'\is Rodrigues (sep 2008).
Towards distributed software transactional memory systems.
In: LADIS~'08: Proc. 2nd Workshop on Large-Scale Distributed Systems and Middleware.

[Spear et al., 2008]

Michael F. Spear and Michael Silverman and Luke Dalessandro and Maged M. Michael and Michael L. Scott (sep 2008).
Implementing and Exploiting Inevitability in Software Transactional Memory.
In: ICPP~'08: Proc. 37th International Conference on Parallel Processing.

[Cascaval et al., 2008]

Calin Cascaval and Colin Blundell and Maged Michael and Harold W. Cain and Peng Wu and Stefanie Chiras and Siddhartha Chatterjee (nov 2008).
Software transactional memory: why is it only a research toy?
In: Communications of the ACM, 51(11):40--46.

[Gramoli et al., 2008]

Vincent Gramoli and Derin Harmanci and Pascal Felber (Dec 2008).
Toward a Theory of Input Acceptance for Transactional Memories.
In: Proceedings of the 12th International Conference On Principles Of Distributed Systems (OPODIS'08). Volume 5401 of LNCS. pp. 527--533. Published by Springer-Verlag.

[Carvalho et al., 2008]

Nuno Carvalho and Joao Cachopo and Luis Rodrigues and Antonio Rito Silva ( 2008).
Versioned transactional shared memory for the FenixEDU web application.
In: Proceedings of the 2nd workshop on Dependable distributed data management. SDDDM '08. New York, NY, USA, pp. 15--18. Published by ACM.

[Lev and Maessen, 2008]

Yossi Lev and Jan-Willem Maessen ( 2008).
Split hardware transactions: true nesting of transactions using best-effort hardware transactional memory.
In: PPoPP '08: Proceedings of the 13th ACM SIGPLAN Symposium on Principles and practice of parallel programming. New York, NY, USA, pp. 197--206. Published by ACM.

[Kotselidis et al., 2008]

Christos Kotselidis and Mohammad Ansari and Kim Jarvis and Mikel Luj\'an and Chris C. Kirkham and Ian Watson ( 2008).
Investigating software Transactional Memory on clusters.
In: IPDPS~'08: Proc. 22nd International Parallel and Distributed Processing Symposium.

[Guerraoui et al., 2008]

Rachid Guerraoui and Thomas A. Henzinger and Vasu Singh ( 2008).
Permissiveness in Transactional Memories.
In: DISC. Published by Springer.

[Ansari et al., 2009]

Mohammad Ansari and Mikel Luj\'an and Christos Kotselidis and Kim Jarvis and Chris Kirkham and Ian Watson (jan 2009).
Steal-on-abort: Improving Transactional Memory Performance through Dynamic Transaction Reordering.
In: HIPEAC~'09: Proc. 4th International Conference on High Performance and Embedded Architectures and Compilers. pp. 4--18. Springer-Verlag Lecture Notes in Computer Science volume 5409.

[Bronson et al., 2009]

Nathan G. Bronson and Christos Kozyrakis and Kunle Olukotun (jan 2009).
Feedback-directed barrier optimization in a strongly isolated STM.
In: POPL~'09: Proc. 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages. pp. 213--225.

[Ansari et al., 2009]

Mohammad Ansari and Christos Kotselidis and Mikel Luj\'an and Chris Kirkham and Ian Watson (jan 2009).
Investigating Contention Management for Complex Transactional Memory Benchmarks.
In: MULTIPROG~'09: Proc. 2nd Workshop on Programmability Issues for Multi-Core Computers.

[Schindewolf et al., 2009]

Martin Schindewolf and Albert Cohen and Wolfgang Karl and Andrea Marongiu and Luca Benini (jan 2009).
Towards Transactional Memory Support for GCC.
In: GROW~'09: GCC Research Opportunities Workshop. Affiliated to HiPEAC'09.

[Spear et al., 2009]

Michael F. Spear and Luke Dalessandro and Virendra J. Marathe and Michael L. Scott (feb 2009).
A comprehensive strategy for contention management in software transactional memory.
In: PPoPP~'09: Proc. 14th ACM SIGPLAN symposium on Principles and practice of parallel programming. pp. 141--150.

[Agrawal et al., 2009]

Kunal Agrawal and I-Ting Angelina Lee and Jim Sukha (feb 2009).
Safe open-nested transactions through ownership.
In: PPoPP~'09: Proc. 14th ACM SIGPLAN symposium on Principles and practice of parallel programming. pp. 151--162.

[Ramadan et al., 2009]

Hany E. Ramadan and Indrajit Roy and Maurice Herlihy and Emmett Witchel (feb 2009).
Committing conflicting transactions in an STM.
In: PPoPP~'09: Proc. 14th ACM SIGPLAN symposium on Principles and practice of parallel programming. pp. 163--172.

[Abadi et al., 2009]

Martin Abadi and Tim Harris and Mojtaba Mehrara (feb 2009).
Transactional memory with strong atomicity using off-the-shelf memory protection hardware.
In: PPoPP~'09: Proc. 14th ACM SIGPLAN symposium on Principles and practice of parallel programming. pp. 185--196.

[Attiya et al., 2009]

Hagit Attiya and Eshcar Hillel and Alessia Milani (feb 2009).
Inherent limitations on transactional memory implementations.
In: TRANSACT~'09: 4th Workshop on Transactional Computing. A later version appeared at SPAA~'09.

[Koskinen and Herlihy, 2009]

Eric Koskinen and Maurice Herlihy (feb 2009).
Concurrent Non-commutative Boosted Transactions.
In: TRANSACT~'09: 4th Workshop on Transactional Computing.

[Lev et al., 2009]

Yossi Lev and Victor Luchangco and Virendra Marathe and Mark Moir and Dan Nussbaum and Marek Olszewski (feb 2009).
Anatomy of a Scalable Software Transactional Memory.
In: TRANSACT~'09: 4th Workshop on Transactional Computing.

[Pant and Byrd, 2009]

Salil Pant and Greg Byrd (feb 2009).
A Case for using Value Prediction to improve performance of transactional memory.
In: TRANSACT~'09: 4th Workshop on Transactional Computing.

[Ramadan and Witchel, 2009]

Hany Ramadan and Emmett Witchel (feb 2009).
The Xfork in the Road to Coordinated Sibling Transactions.
In: TRANSACT~'09: 4th Workshop on Transactional Computing.

[Tabba et al., 2009]

Fuad Tabba and Andrew W. Hay and James R. Goodman (feb 2009).
Transactional Value Prediction.
In: TRANSACT~'09: 4th Workshop on Transactional Computing.

[Spear et al., 2009]

Michael F. Spear and Maged M. Michael and Michael L. Scott and Peng Wu (mar 2009).
Reducing Memory Ordering Overheads in Software Transactional Memory.
In: CGO~'09: Proceedings of the 2009 International Symposium on Code Generation and Optimization. pp. 13--24.

[Fahmy et al., 2009]

Sherif F. Fahmy and Binoy Ravindran and E. D. Jensen (mar 2009).
Response time analysis of software transactional memory-based distributed real-time systems.
In: SAC~'09: Proc. 2009 ACM symposium on Applied Computing. pp. 334--338.

[Roy et al., 2009]

Amitabha Roy and Steven Hand and Tim Harris (apr 2009).
A runtime system for software lock elision.
In: EuroSys~'09: Proc. 4th ACM European Conference on Computer Systems. pp. 261--274.

[Korland et al., 2009]

Guy Korland and Nir Shavit and Pascal Felber (may 2009).
Noninvasive Java Concurrency with Deuce STM (poster).
In: SYSTOR~'09: The Israeli Experimental Systems Conference. Further details at \urlhttp://www.deucestm.org/.

[Sturzrehm et al., 2009]

Heiko Sturzrehm and Pascal Felber and Christof Fetzer (may 2009).
TM-Stream: An STM framework for distributed event stream processing.
In: IWJacPDC~'09: Proc. 11th International Workshop on Java and Components for Parallelism.

[Birgisson and Erlingsson, 2009]

Arnar Birgisson and \'Ulfar Erlingsson (jun 2009).
An implementation and semantics for transactional memory introspection in Haskell.
In: PLAS~'09: Proc. 4th Workshop on Programming Languages and Analysis for Security. pp. 87--99.

[Mankin et al., 2009]

Jennifer Mankin and David Kaeli and John Ardini (jun 2009).
Software transactional memory for multicore embedded systems.
In: LCTES~'09: Proc. 2009 conference on Languages, compilers, and tools for embedded systems. pp. 90--98.

[Dragojevi\'c et al., 2009]

Aleksandar Dragojevi\'c and Rachid Guerraoui and Micha\l Kapa\lka (jun 2009).
Stretching transactional memory.
In: PLDI~'09: Proc. 2009 ACM SIGPLAN conference on Programming language design and implementation. pp. 155--165.

[He and Hong, 2009]

Zhengyu He and Bo Hong (jun 2009).
On the Performance of Commit-Time-Locking Based Software Transactional Memory.
In: HPCC~'09: Proc. 11th Conference on High Performance Computing and Communications.

[Volos et al., 2009]

Haris Volos and Adam Welc and Ali-Reza Adl-Tabatabai and Tatiana Shpeisman and Xinmin Tian and Ravi Narayanaswamy (jun 2009).
NePaLTM: Design and Implementation of Nested Parallelism for Transactional Memory Systems.
In: ECOOP~'09: Proc. 23rd European Conference on Object-Oriented Programming. Springer-Verlag Lecture Notes in Computer Science volume 5653.

[Gottschlich et al., 2009]

Justin E. Gottschlich and Jeremy G. Siek and Manish Vachharajani and Dwight Y. Winkler and Daniel A. Connors (jul 2009).
An efficient lock-aware transactional memory implementation.
In: ICOOOLPS~'09: Proc. 4th workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages and Programming Systems. pp. 10--17.

[Attiya et al., 2009]

Hagit Attiya and Eshcar Hillel and Alessia Milani (aug 2009).
Inherent Limitations on Disjoint-Access Parallel Implementations of Transactional Memory.
In: SPAA~'09: Proc. 21st Symposium on Parallelism in Algorithms and Architectures. An earlier version appeared at TRANSACT~'09.

[Dragojevi\'c et al., 2009]

Aleksandar Dragojevi\'c and Yang Ni and Ali-Reza Adl-Tabatabai (aug 2009).
Optimizing Transactions for Captured Memory.
In: SPAA~'09: Proc. 21st Symposium on Parallelism in Algorithms and Architectures.

[Dragojevi\'c et al., 2009]

Aleksandar Dragojevi\'c and Rachid Guerraoui and Anmol V. Singh and Vasu Singh (aug 2009).
Preventing versus Curing: Avoiding Conflicts in Transactional Memories.
In: PODC~'09: Proc. 28th ACM Symposium on Principles of Distributed Computing.

[Lev et al., 2009]

Yossi Lev and Victor Luchangco and Marek Olszewski (aug 2009).
Scalable Reader-Writer Locks.
In: SPAA~'09: Proc. 21st Symposium on Parallelism in Algorithms and Architectures.

[Oancea et al., 2009]

Cosmin E. Oancea and Alan Mycroft and Tim Harris (aug 2009).
A Lightweight In-Place Implementation for Software Thread-Level Speculation.
In: SPAA~'09: Proc. 21st Symposium on Parallelism in Algorithms and Architectures.

[Perelman and Keidar, 2009]

Dmitri Perelman and Idit Keidar (aug 2009).
On Avoiding Spare Aborts in Transactional Memory.
In: SPAA~'09: Proc. 21st Symposium on Parallelism in Algorithms and Architectures.

[Tabba et al., 2009]

Fuad Tabba and Mark Moir and James R. Goodman and Andrew Hay and Cong Wang (aug 2009).
NZTM: Nonblocking Zero-indirection Transactional Memory.
In: SPAA~'09: Proc. 21st Symposium on Parallelism in Algorithms and Architectures.

[Felber et al., 2009]

Pascal Felber and Vincent Gramoli and Rachid Guerraoui (Sep 2009).
Elastic Transactions.
In: Proceedings of the 23rd International Symposum on Distributed Computing (DISC'09). Volume 5805 of LNCS. pp. 93--107. Published by Springer-Verlag.

[Abadi and Harris, 2009]

Martin Abadi and Tim Harris (sep 2009).
Perspectives on Transactional Memory (invited paper).
In: CONCUR~'09: Proc. 20th Conference on Concurrency Theory.

[Attiya and Milani, 2009]

Hagit Attiya and Alessia Milani (sep 2009).
Transactional Scheduling for Read-Dominated Workloads (brief announcement).
In: DISC~'09: Proc. 23rd International Symposium on Distributed Computing.

[Couceiro et al., 2009]

M. Couceiro and P. Romano and N. Carvalho and L. Rodrigues (nov 2009).
D2STM: Dependable Distributed Software Transactional Memory.
In: PRDC~'09: Proc. 15th Pacific Rim International Symposium on Dependable Computing.

[Sridharan et al., 2009]

S. Sridharan and J. S. Vetter and P. M. Kogge (nov 2009).
Scalable Software Transactional Memory for Global Address Space Architectures.
Technical Report Nr. FTGTR-2009-04. Future Technologies Group, Oak Ridge National Lab.

[Wu et al., 2009]

Peng Wu and Maged M. Michael and Christoph von Praun and Takuya Nakaike and Rajesh Bordawekar and Harold W. Cain and Calin Cascaval and Siddhartha Chatterjee and Stefanie Chiras and Rui Hou and Mark F. Mergen and Xiaowei Shen and Michael F. Spear and Huayong Wang and Kun Wang ( 2009).
Compiler and runtime techniques for software transactional memory optimization.
In: Concurrency and Computation: Practice and Experience, 21(1):7-23.

[Romano et al., 2009]

Paolo Romano and Nuno Carvalho and Maria Couceiro and Luis Rodrigues and Joao Cachopo ( 2009).
Towards the Integration of Distributed Transactional Memories in Application Servers Clusters.
In: (ed.), Quality of Service in Heterogeneous Networks. Volume 22 of Lecture Notes of the Institute for Computer Sciences, Social Informatics and Telecommunications Engineering. pp. 755-769. Springer Berlin Heidelberg. (Invited paper).

[Dalessandro et al., 2010]

Luke Dalessandro and Michael F. Spear and Michael L. Scott (jan 2010).
NOrec: Streamlining STM by Abolishing Ownership Records.
In: PPoPP~'10: Proc. 15th ACM Symp. on Principles and Practice of Parallel Programming.

[Gramoli et al., 2010]

Vincent Gramoli and Derin Harmanci and Pascal Felber (mar 2010).
On the Input Acceptance of Transactional Memory.
In: Parallel Processing Letters (PPL), 20(1):31--50.

[Palmieri et al., 2010]

Roberto Palmieri and Francesco Quaglia and Paolo Romano and Nuno Carvalho (april 2010).
Evaluating database-oriented replication schemes in Software Transactional Memory systems.
In: Parallel Distributed Processing, Workshops and Phd Forum (IPDPSW), 2010 IEEE International Symposium on. Volume . pp. 1 -8.

[Romano et al., 2010]

Paolo Romano and Luis Rodrigues and Nuno Carvalho and Joao Cachopo (April 2010).
Cloud-TM: harnessing the cloud with distributed transactional memories.
In: SIGOPS Oper. Syst. Rev., 44:1--6.

[Bieniusa and Fuhrmann, 2010]

Annette Bieniusa and Thomas Fuhrmann ( 2010).
Consistency in hindsight: A fully decentralized STM algorithm.
In: Proceedings of the 2010 IEEE International Symposium on Parallel Distributed Processing (IPDPS), April 19-23, 2010, Atlanta, Georgia, USA. pp. 1-12.

[Palmieri et al., 2010]

Roberto Palmieri and Francesco Quaglia and Paolo Romano ( 2010).
AGGRO: Boosting STM Replication via Aggressively Optimistic Transaction Processing.
In: Network Computing and Applications, IEEE International Symposium on, 0:20-27.

[Noel, 2010]

Cyprien Noel ( 2010).
Extensible software transactional memory.
In: C3S2E '10: Proceedings of the Third C* Conference on Computer Science and Software Engineering. New York, NY, USA, pp. 23--34. Published by ACM.

[Romano et al., 2010]

Paolo Romano and Roberto Palmieri and Francesco Quaglia and Nuno Carvalho and Luis Rodrigues ( 2010).
Brief announcement: on speculative replication of transactional systems.
In: Proceedings of the 22nd ACM symposium on Parallelism in algorithms and architectures. SPAA '10. New York, NY, USA, pp. 69--71. Published by ACM.