Enforcing isolation and ordering in STM

Transactional memory provides a new concurrency control mechanism that avoids many of the pitfalls of lock-based synchronization. High-performance software transactional memory (STM) implementations thus far provide weak atomicity : Accessing shared data both inside and outside a transaction can res...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Veröffentlicht in:ACM SIGPLAN Notices 2007-06, Vol.42 (6), p.78-88
Hauptverfasser: Shpeisman, Tatiana, Menon, Vijay, Adl-Tabatabai, Ali-Reza, Balensiefer, Steven, Grossman, Dan, Hudson, Richard L., Moore, Katherine F., Saha, Bratin
Format: Artikel
Sprache:eng
Online-Zugang:Volltext
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page 88
container_issue 6
container_start_page 78
container_title ACM SIGPLAN Notices
container_volume 42
creator Shpeisman, Tatiana
Menon, Vijay
Adl-Tabatabai, Ali-Reza
Balensiefer, Steven
Grossman, Dan
Hudson, Richard L.
Moore, Katherine F.
Saha, Bratin
description Transactional memory provides a new concurrency control mechanism that avoids many of the pitfalls of lock-based synchronization. High-performance software transactional memory (STM) implementations thus far provide weak atomicity : Accessing shared data both inside and outside a transaction can result in unexpected, implementation-dependent behavior. To guarantee isolation and consistent ordering in such a system, programmers are expected to enclose all shared-memory accesses inside transactions. A system that provides strong atomicity guarantees isolation even in the presence of threads that access shared data outside transactions. A strongly-atomic system also orders transactions with conflicting non-transactional memory operations in a consistent manner. In this paper, we discuss some surprising pitfalls of weak atomicity, and we present an STM system that avoids these problems via strong atomicity. We demonstrate how to implement non-transactional data accesses via efficient read and write barriers, and we present compiler optimizations that further reduce the overheads of these barriers. We introduce a dynamic escape analysis that differentiates private and public data at runtime to make barriers cheaper and a static not-accessed-in-transaction analysis that removes many barriers completely. Our results on a set of Java programs show that strong atomicity can be implemented efficiently in a high-performance STM system.
doi_str_mv 10.1145/1273442.1250744
format Article
fullrecord <record><control><sourceid>proquest_cross</sourceid><recordid>TN_cdi_proquest_miscellaneous_30958541</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>30958541</sourcerecordid><originalsourceid>FETCH-LOGICAL-c302t-1375ddaf7d8eb78c0fe4c09c16f5c4fc4303982996e512a073da814f8fe6a6db3</originalsourceid><addsrcrecordid>eNotkLtPwzAYxC0eEmlhZs0EU9rv8yOxR1SVh1TEQJkt1w8UlMbFTgf-ewLNdNLpdKf7EXKLsEDkYom0YZzTBVIBDednpEAhZIVYwzmZoVBCMQaKXZACWE0rZByuyCznLwBgQGVB7td9iMm2_WfZ5tiZoY19aXpXxuR8-rf78n37ek0ug-myv5l0Tj4e19vVc7V5e3pZPWwqO_YN40IjnDOhcdLvGmkheG5BWayDsDxYzoApSZWqvUBqoGHOSORBBl-b2u3YnNydeg8pfh99HvS-zdZ3nel9PGY93hFScByDy1PQpphz8kEfUrs36Ucj6D86eqKjJzrsFyIJU14</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype><pqid>30958541</pqid></control><display><type>article</type><title>Enforcing isolation and ordering in STM</title><source>ACM Digital Library Complete</source><creator>Shpeisman, Tatiana ; Menon, Vijay ; Adl-Tabatabai, Ali-Reza ; Balensiefer, Steven ; Grossman, Dan ; Hudson, Richard L. ; Moore, Katherine F. ; Saha, Bratin</creator><creatorcontrib>Shpeisman, Tatiana ; Menon, Vijay ; Adl-Tabatabai, Ali-Reza ; Balensiefer, Steven ; Grossman, Dan ; Hudson, Richard L. ; Moore, Katherine F. ; Saha, Bratin</creatorcontrib><description>Transactional memory provides a new concurrency control mechanism that avoids many of the pitfalls of lock-based synchronization. High-performance software transactional memory (STM) implementations thus far provide weak atomicity : Accessing shared data both inside and outside a transaction can result in unexpected, implementation-dependent behavior. To guarantee isolation and consistent ordering in such a system, programmers are expected to enclose all shared-memory accesses inside transactions. A system that provides strong atomicity guarantees isolation even in the presence of threads that access shared data outside transactions. A strongly-atomic system also orders transactions with conflicting non-transactional memory operations in a consistent manner. In this paper, we discuss some surprising pitfalls of weak atomicity, and we present an STM system that avoids these problems via strong atomicity. We demonstrate how to implement non-transactional data accesses via efficient read and write barriers, and we present compiler optimizations that further reduce the overheads of these barriers. We introduce a dynamic escape analysis that differentiates private and public data at runtime to make barriers cheaper and a static not-accessed-in-transaction analysis that removes many barriers completely. Our results on a set of Java programs show that strong atomicity can be implemented efficiently in a high-performance STM system.</description><identifier>ISSN: 0362-1340</identifier><identifier>ISBN: 1595933093</identifier><identifier>ISBN: 9781595933096</identifier><identifier>EISSN: 1558-1160</identifier><identifier>DOI: 10.1145/1273442.1250744</identifier><language>eng</language><ispartof>ACM SIGPLAN Notices, 2007-06, Vol.42 (6), p.78-88</ispartof><woscitedreferencessubscribed>false</woscitedreferencessubscribed><citedby>FETCH-LOGICAL-c302t-1375ddaf7d8eb78c0fe4c09c16f5c4fc4303982996e512a073da814f8fe6a6db3</citedby><cites>FETCH-LOGICAL-c302t-1375ddaf7d8eb78c0fe4c09c16f5c4fc4303982996e512a073da814f8fe6a6db3</cites></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>314,776,780,27903,27904</link.rule.ids></links><search><creatorcontrib>Shpeisman, Tatiana</creatorcontrib><creatorcontrib>Menon, Vijay</creatorcontrib><creatorcontrib>Adl-Tabatabai, Ali-Reza</creatorcontrib><creatorcontrib>Balensiefer, Steven</creatorcontrib><creatorcontrib>Grossman, Dan</creatorcontrib><creatorcontrib>Hudson, Richard L.</creatorcontrib><creatorcontrib>Moore, Katherine F.</creatorcontrib><creatorcontrib>Saha, Bratin</creatorcontrib><title>Enforcing isolation and ordering in STM</title><title>ACM SIGPLAN Notices</title><description>Transactional memory provides a new concurrency control mechanism that avoids many of the pitfalls of lock-based synchronization. High-performance software transactional memory (STM) implementations thus far provide weak atomicity : Accessing shared data both inside and outside a transaction can result in unexpected, implementation-dependent behavior. To guarantee isolation and consistent ordering in such a system, programmers are expected to enclose all shared-memory accesses inside transactions. A system that provides strong atomicity guarantees isolation even in the presence of threads that access shared data outside transactions. A strongly-atomic system also orders transactions with conflicting non-transactional memory operations in a consistent manner. In this paper, we discuss some surprising pitfalls of weak atomicity, and we present an STM system that avoids these problems via strong atomicity. We demonstrate how to implement non-transactional data accesses via efficient read and write barriers, and we present compiler optimizations that further reduce the overheads of these barriers. We introduce a dynamic escape analysis that differentiates private and public data at runtime to make barriers cheaper and a static not-accessed-in-transaction analysis that removes many barriers completely. Our results on a set of Java programs show that strong atomicity can be implemented efficiently in a high-performance STM system.</description><issn>0362-1340</issn><issn>1558-1160</issn><isbn>1595933093</isbn><isbn>9781595933096</isbn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2007</creationdate><recordtype>article</recordtype><recordid>eNotkLtPwzAYxC0eEmlhZs0EU9rv8yOxR1SVh1TEQJkt1w8UlMbFTgf-ewLNdNLpdKf7EXKLsEDkYom0YZzTBVIBDednpEAhZIVYwzmZoVBCMQaKXZACWE0rZByuyCznLwBgQGVB7td9iMm2_WfZ5tiZoY19aXpXxuR8-rf78n37ek0ug-myv5l0Tj4e19vVc7V5e3pZPWwqO_YN40IjnDOhcdLvGmkheG5BWayDsDxYzoApSZWqvUBqoGHOSORBBl-b2u3YnNydeg8pfh99HvS-zdZ3nel9PGY93hFScByDy1PQpphz8kEfUrs36Ucj6D86eqKjJzrsFyIJU14</recordid><startdate>20070601</startdate><enddate>20070601</enddate><creator>Shpeisman, Tatiana</creator><creator>Menon, Vijay</creator><creator>Adl-Tabatabai, Ali-Reza</creator><creator>Balensiefer, Steven</creator><creator>Grossman, Dan</creator><creator>Hudson, Richard L.</creator><creator>Moore, Katherine F.</creator><creator>Saha, Bratin</creator><scope>AAYXX</scope><scope>CITATION</scope><scope>7SC</scope><scope>8FD</scope><scope>JQ2</scope><scope>L7M</scope><scope>L~C</scope><scope>L~D</scope></search><sort><creationdate>20070601</creationdate><title>Enforcing isolation and ordering in STM</title><author>Shpeisman, Tatiana ; Menon, Vijay ; Adl-Tabatabai, Ali-Reza ; Balensiefer, Steven ; Grossman, Dan ; Hudson, Richard L. ; Moore, Katherine F. ; Saha, Bratin</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c302t-1375ddaf7d8eb78c0fe4c09c16f5c4fc4303982996e512a073da814f8fe6a6db3</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2007</creationdate><toplevel>online_resources</toplevel><creatorcontrib>Shpeisman, Tatiana</creatorcontrib><creatorcontrib>Menon, Vijay</creatorcontrib><creatorcontrib>Adl-Tabatabai, Ali-Reza</creatorcontrib><creatorcontrib>Balensiefer, Steven</creatorcontrib><creatorcontrib>Grossman, Dan</creatorcontrib><creatorcontrib>Hudson, Richard L.</creatorcontrib><creatorcontrib>Moore, Katherine F.</creatorcontrib><creatorcontrib>Saha, Bratin</creatorcontrib><collection>CrossRef</collection><collection>Computer and Information Systems Abstracts</collection><collection>Technology Research Database</collection><collection>ProQuest Computer Science Collection</collection><collection>Advanced Technologies Database with Aerospace</collection><collection>Computer and Information Systems Abstracts – Academic</collection><collection>Computer and Information Systems Abstracts Professional</collection><jtitle>ACM SIGPLAN Notices</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Shpeisman, Tatiana</au><au>Menon, Vijay</au><au>Adl-Tabatabai, Ali-Reza</au><au>Balensiefer, Steven</au><au>Grossman, Dan</au><au>Hudson, Richard L.</au><au>Moore, Katherine F.</au><au>Saha, Bratin</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Enforcing isolation and ordering in STM</atitle><jtitle>ACM SIGPLAN Notices</jtitle><date>2007-06-01</date><risdate>2007</risdate><volume>42</volume><issue>6</issue><spage>78</spage><epage>88</epage><pages>78-88</pages><issn>0362-1340</issn><eissn>1558-1160</eissn><isbn>1595933093</isbn><isbn>9781595933096</isbn><abstract>Transactional memory provides a new concurrency control mechanism that avoids many of the pitfalls of lock-based synchronization. High-performance software transactional memory (STM) implementations thus far provide weak atomicity : Accessing shared data both inside and outside a transaction can result in unexpected, implementation-dependent behavior. To guarantee isolation and consistent ordering in such a system, programmers are expected to enclose all shared-memory accesses inside transactions. A system that provides strong atomicity guarantees isolation even in the presence of threads that access shared data outside transactions. A strongly-atomic system also orders transactions with conflicting non-transactional memory operations in a consistent manner. In this paper, we discuss some surprising pitfalls of weak atomicity, and we present an STM system that avoids these problems via strong atomicity. We demonstrate how to implement non-transactional data accesses via efficient read and write barriers, and we present compiler optimizations that further reduce the overheads of these barriers. We introduce a dynamic escape analysis that differentiates private and public data at runtime to make barriers cheaper and a static not-accessed-in-transaction analysis that removes many barriers completely. Our results on a set of Java programs show that strong atomicity can be implemented efficiently in a high-performance STM system.</abstract><doi>10.1145/1273442.1250744</doi><tpages>11</tpages></addata></record>
fulltext fulltext
identifier ISSN: 0362-1340
ispartof ACM SIGPLAN Notices, 2007-06, Vol.42 (6), p.78-88
issn 0362-1340
1558-1160
language eng
recordid cdi_proquest_miscellaneous_30958541
source ACM Digital Library Complete
title Enforcing isolation and ordering in STM
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-24T09%3A31%3A40IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_cross&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=Enforcing%20isolation%20and%20ordering%20in%20STM&rft.jtitle=ACM%20SIGPLAN%20Notices&rft.au=Shpeisman,%20Tatiana&rft.date=2007-06-01&rft.volume=42&rft.issue=6&rft.spage=78&rft.epage=88&rft.pages=78-88&rft.issn=0362-1340&rft.eissn=1558-1160&rft.isbn=1595933093&rft.isbn_list=9781595933096&rft_id=info:doi/10.1145/1273442.1250744&rft_dat=%3Cproquest_cross%3E30958541%3C/proquest_cross%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_pqid=30958541&rft_id=info:pmid/&rfr_iscdi=true