Atomizer: a dynamic atomicity checker for multithreaded programs
Ensuring the correctness of multithreaded programs is difficult, due to the potential for unexpected interactions between concurrent threads. Much previous work has focused on detecting race conditions, but the absence of race conditions does not by itself prevent undesired thread interactions. We f...
Gespeichert in:
Veröffentlicht in: | SIGPLAN notices 2004-01, Vol.39 (1), p.256-267 |
---|---|
Hauptverfasser: | , |
Format: | Artikel |
Sprache: | eng |
Online-Zugang: | Volltext |
Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
container_end_page | 267 |
---|---|
container_issue | 1 |
container_start_page | 256 |
container_title | SIGPLAN notices |
container_volume | 39 |
creator | Flanagan, Cormac Freund, Stephen N |
description | Ensuring the correctness of multithreaded programs is difficult, due to the potential for unexpected interactions between concurrent threads. Much previous work has focused on detecting race conditions, but the absence of race conditions does not by itself prevent undesired thread interactions. We focus on the more fundamental non-interference property of
atomicity
; a method is atomic if its execution is not affected by and does not interfere with concurrently-executing threads. Atomic methods can be understood according to their sequential semantics, which significantly simplifies (formal and informal) correctness arguments.This paper presents a dynamic analysis for detecting atomicity violations. This analysis combines ideas from both Lipton's theory of reduction and earlier dynamic race detectors. Experience with a prototype checker for multithreaded Java code demonstrates that this approach is effective for detecting errors due to unintended interactions between threads. In particular, our atomicity checker detects errors that would be missed by standard race detectors, and it produces fewer false alarms on benign races that do not cause atomicity violations. Our experimental results also indicate that the majority of methods in our benchmarks are atomic, supporting our hypothesis that atomicity is a standard methodology in multithreaded programming. |
doi_str_mv | 10.1145/982962.964023 |
format | Article |
fullrecord | <record><control><sourceid>crossref</sourceid><recordid>TN_cdi_crossref_primary_10_1145_982962_964023</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>10_1145_982962_964023</sourcerecordid><originalsourceid>FETCH-LOGICAL-c191t-7d485bb72fd6ac1af50f065d7216d1349ea2741a06739556a69a1916ffe19a783</originalsourceid><addsrcrecordid>eNotz01rQjEQheGhWPBqu-zPiM7kY5IsReoHCN206zDem4ClYknctL--luvqrM4LD8AL4YLIumUMOrJeRLaozQN05FxQRIwT6NCwVmQsTmHW2iciGtShg-nqejmffnN9gsciXy0_33cOH5vX9_VOHd62-_XqoHqKdFV-sMEdj16XgaUnKQ4Lshu8Jh5u_ZhFe0uC7E10joWj3I5cSqYoPpg5qLHb10trNZf0XU9nqT-JMP0z0shII8P8ARqaNx0</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype></control><display><type>article</type><title>Atomizer: a dynamic atomicity checker for multithreaded programs</title><source>ACM Digital Library</source><creator>Flanagan, Cormac ; Freund, Stephen N</creator><creatorcontrib>Flanagan, Cormac ; Freund, Stephen N</creatorcontrib><description>Ensuring the correctness of multithreaded programs is difficult, due to the potential for unexpected interactions between concurrent threads. Much previous work has focused on detecting race conditions, but the absence of race conditions does not by itself prevent undesired thread interactions. We focus on the more fundamental non-interference property of
atomicity
; a method is atomic if its execution is not affected by and does not interfere with concurrently-executing threads. Atomic methods can be understood according to their sequential semantics, which significantly simplifies (formal and informal) correctness arguments.This paper presents a dynamic analysis for detecting atomicity violations. This analysis combines ideas from both Lipton's theory of reduction and earlier dynamic race detectors. Experience with a prototype checker for multithreaded Java code demonstrates that this approach is effective for detecting errors due to unintended interactions between threads. In particular, our atomicity checker detects errors that would be missed by standard race detectors, and it produces fewer false alarms on benign races that do not cause atomicity violations. Our experimental results also indicate that the majority of methods in our benchmarks are atomic, supporting our hypothesis that atomicity is a standard methodology in multithreaded programming.</description><identifier>ISSN: 0362-1340</identifier><identifier>EISSN: 1558-1160</identifier><identifier>DOI: 10.1145/982962.964023</identifier><language>eng</language><ispartof>SIGPLAN notices, 2004-01, Vol.39 (1), p.256-267</ispartof><woscitedreferencessubscribed>false</woscitedreferencessubscribed><cites>FETCH-LOGICAL-c191t-7d485bb72fd6ac1af50f065d7216d1349ea2741a06739556a69a1916ffe19a783</cites></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>314,780,784,27924,27925</link.rule.ids></links><search><creatorcontrib>Flanagan, Cormac</creatorcontrib><creatorcontrib>Freund, Stephen N</creatorcontrib><title>Atomizer: a dynamic atomicity checker for multithreaded programs</title><title>SIGPLAN notices</title><description>Ensuring the correctness of multithreaded programs is difficult, due to the potential for unexpected interactions between concurrent threads. Much previous work has focused on detecting race conditions, but the absence of race conditions does not by itself prevent undesired thread interactions. We focus on the more fundamental non-interference property of
atomicity
; a method is atomic if its execution is not affected by and does not interfere with concurrently-executing threads. Atomic methods can be understood according to their sequential semantics, which significantly simplifies (formal and informal) correctness arguments.This paper presents a dynamic analysis for detecting atomicity violations. This analysis combines ideas from both Lipton's theory of reduction and earlier dynamic race detectors. Experience with a prototype checker for multithreaded Java code demonstrates that this approach is effective for detecting errors due to unintended interactions between threads. In particular, our atomicity checker detects errors that would be missed by standard race detectors, and it produces fewer false alarms on benign races that do not cause atomicity violations. Our experimental results also indicate that the majority of methods in our benchmarks are atomic, supporting our hypothesis that atomicity is a standard methodology in multithreaded programming.</description><issn>0362-1340</issn><issn>1558-1160</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2004</creationdate><recordtype>article</recordtype><recordid>eNotz01rQjEQheGhWPBqu-zPiM7kY5IsReoHCN206zDem4ClYknctL--luvqrM4LD8AL4YLIumUMOrJeRLaozQN05FxQRIwT6NCwVmQsTmHW2iciGtShg-nqejmffnN9gsciXy0_33cOH5vX9_VOHd62-_XqoHqKdFV-sMEdj16XgaUnKQ4Lshu8Jh5u_ZhFe0uC7E10joWj3I5cSqYoPpg5qLHb10trNZf0XU9nqT-JMP0z0shII8P8ARqaNx0</recordid><startdate>200401</startdate><enddate>200401</enddate><creator>Flanagan, Cormac</creator><creator>Freund, Stephen N</creator><scope>AAYXX</scope><scope>CITATION</scope></search><sort><creationdate>200401</creationdate><title>Atomizer</title><author>Flanagan, Cormac ; Freund, Stephen N</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c191t-7d485bb72fd6ac1af50f065d7216d1349ea2741a06739556a69a1916ffe19a783</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2004</creationdate><toplevel>online_resources</toplevel><creatorcontrib>Flanagan, Cormac</creatorcontrib><creatorcontrib>Freund, Stephen N</creatorcontrib><collection>CrossRef</collection><jtitle>SIGPLAN notices</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Flanagan, Cormac</au><au>Freund, Stephen N</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Atomizer: a dynamic atomicity checker for multithreaded programs</atitle><jtitle>SIGPLAN notices</jtitle><date>2004-01</date><risdate>2004</risdate><volume>39</volume><issue>1</issue><spage>256</spage><epage>267</epage><pages>256-267</pages><issn>0362-1340</issn><eissn>1558-1160</eissn><abstract>Ensuring the correctness of multithreaded programs is difficult, due to the potential for unexpected interactions between concurrent threads. Much previous work has focused on detecting race conditions, but the absence of race conditions does not by itself prevent undesired thread interactions. We focus on the more fundamental non-interference property of
atomicity
; a method is atomic if its execution is not affected by and does not interfere with concurrently-executing threads. Atomic methods can be understood according to their sequential semantics, which significantly simplifies (formal and informal) correctness arguments.This paper presents a dynamic analysis for detecting atomicity violations. This analysis combines ideas from both Lipton's theory of reduction and earlier dynamic race detectors. Experience with a prototype checker for multithreaded Java code demonstrates that this approach is effective for detecting errors due to unintended interactions between threads. In particular, our atomicity checker detects errors that would be missed by standard race detectors, and it produces fewer false alarms on benign races that do not cause atomicity violations. Our experimental results also indicate that the majority of methods in our benchmarks are atomic, supporting our hypothesis that atomicity is a standard methodology in multithreaded programming.</abstract><doi>10.1145/982962.964023</doi><tpages>12</tpages></addata></record> |
fulltext | fulltext |
identifier | ISSN: 0362-1340 |
ispartof | SIGPLAN notices, 2004-01, Vol.39 (1), p.256-267 |
issn | 0362-1340 1558-1160 |
language | eng |
recordid | cdi_crossref_primary_10_1145_982962_964023 |
source | ACM Digital Library |
title | Atomizer: a dynamic atomicity checker for multithreaded programs |
url | https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2024-12-25T05%3A25%3A29IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-crossref&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=Atomizer:%20a%20dynamic%20atomicity%20checker%20for%20multithreaded%20programs&rft.jtitle=SIGPLAN%20notices&rft.au=Flanagan,%20Cormac&rft.date=2004-01&rft.volume=39&rft.issue=1&rft.spage=256&rft.epage=267&rft.pages=256-267&rft.issn=0362-1340&rft.eissn=1558-1160&rft_id=info:doi/10.1145/982962.964023&rft_dat=%3Ccrossref%3E10_1145_982962_964023%3C/crossref%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_id=info:pmid/&rfr_iscdi=true |