Thread escape analysis for Java programs based on Soot
To reduce the synchronization overhead for parallel Java programs, we introduce a thread escape analysis based on points-to graphs. It combines the rules for determining whether an object escapes the thread that creates it with a flexible points-to analysis framework. It intra-procedurally and inter...
Gespeichert in:
| Hauptverfasser: | , , , |
|---|---|
| Format: | Tagungsbericht |
| Sprache: | eng |
| Schlagworte: | |
| Online-Zugang: | Volltext bestellen |
| Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
| container_end_page | 109 |
|---|---|
| container_issue | |
| container_start_page | 106 |
| container_title | |
| container_volume | 1 |
| creator | Yongxian Jin Wei Hu Fengzhen Chen Gaofeng Che |
| description | To reduce the synchronization overhead for parallel Java programs, we introduce a thread escape analysis based on points-to graphs. It combines the rules for determining whether an object escapes the thread that creates it with a flexible points-to analysis framework. It intra-procedurally and inter-procedurally propagates the escape status of static fields and thread fields in the whole Java program and Java libraries. Thus it can identify those objects accessed by only one thread and then remove synchronization operations on them. We have developed an implementation on the Java framework Soot. Our escape analysis framework is written in Java and thus portable. For our benchmarks, 15.7% to 99.2% (with a median of 55.9%) of synchronization operations are eliminated. |
| doi_str_mv | 10.1109/ICTM.2009.5412985 |
| format | Conference Proceeding |
| fullrecord | <record><control><sourceid>ieee_6IE</sourceid><recordid>TN_cdi_ieee_primary_5412985</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><ieee_id>5412985</ieee_id><sourcerecordid>5412985</sourcerecordid><originalsourceid>FETCH-LOGICAL-i90t-48d61b6f9cd9220229849e8b9df7ad3d446096dd86f218d2fc23acd18b74aeda3</originalsourceid><addsrcrecordid>eNotj81OwzAQhC1BJUrJAyAufoEE21kn3iOK-Ckq4kDu1SZrQ1DbRHaF1LcniM5lLqNP3whxq1WhtcL7ddO-FUYpLCxog85eiAxrp8EAQIVoL8XSaFvn1qJZiOu_KSqoEa5EltK3mgPWgNJLUbVf0RNLn3qavKQD7U5pSDKMUb7SD8kpjp-R9kl2lDzL8SA_xvF4IxaBdsln516J9umxbV7yzfvzunnY5AOqYw6OK91VAXtGY5SZXQG965BDTVzybKuwYnZVMNqxCb0pqWftuhrIM5UrcfePHbz32ykOe4qn7fl1-Qv20EhT</addsrcrecordid><sourcetype>Publisher</sourcetype><iscdi>true</iscdi><recordtype>conference_proceeding</recordtype></control><display><type>conference_proceeding</type><title>Thread escape analysis for Java programs based on Soot</title><source>IEEE Electronic Library (IEL) Conference Proceedings</source><creator>Yongxian Jin ; Wei Hu ; Fengzhen Chen ; Gaofeng Che</creator><creatorcontrib>Yongxian Jin ; Wei Hu ; Fengzhen Chen ; Gaofeng Che</creatorcontrib><description>To reduce the synchronization overhead for parallel Java programs, we introduce a thread escape analysis based on points-to graphs. It combines the rules for determining whether an object escapes the thread that creates it with a flexible points-to analysis framework. It intra-procedurally and inter-procedurally propagates the escape status of static fields and thread fields in the whole Java program and Java libraries. Thus it can identify those objects accessed by only one thread and then remove synchronization operations on them. We have developed an implementation on the Java framework Soot. Our escape analysis framework is written in Java and thus portable. For our benchmarks, 15.7% to 99.2% (with a median of 55.9%) of synchronization operations are eliminated.</description><identifier>ISSN: 2157-5592</identifier><identifier>ISBN: 9781424446995</identifier><identifier>ISBN: 1424446996</identifier><identifier>DOI: 10.1109/ICTM.2009.5412985</identifier><identifier>LCCN: 2009904794</identifier><language>eng</language><publisher>IEEE</publisher><subject>Algorithm design and analysis ; Educational institutions ; escape analysis ; Ground support ; Information analysis ; Java ; Libraries ; Mathematics ; Performance analysis ; points-to graph ; Soot ; synchronization removal ; Testing ; thread-escape ; Yarn</subject><ispartof>2009 International Conference on Test and Measurement, 2009, Vol.1, p.106-109</ispartof><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktohtml>$$Uhttps://ieeexplore.ieee.org/document/5412985$$EHTML$$P50$$Gieee$$H</linktohtml><link.rule.ids>309,310,780,784,789,790,2056,27923,54918</link.rule.ids><linktorsrc>$$Uhttps://ieeexplore.ieee.org/document/5412985$$EView_record_in_IEEE$$FView_record_in_$$GIEEE</linktorsrc></links><search><creatorcontrib>Yongxian Jin</creatorcontrib><creatorcontrib>Wei Hu</creatorcontrib><creatorcontrib>Fengzhen Chen</creatorcontrib><creatorcontrib>Gaofeng Che</creatorcontrib><title>Thread escape analysis for Java programs based on Soot</title><title>2009 International Conference on Test and Measurement</title><addtitle>ICTM</addtitle><description>To reduce the synchronization overhead for parallel Java programs, we introduce a thread escape analysis based on points-to graphs. It combines the rules for determining whether an object escapes the thread that creates it with a flexible points-to analysis framework. It intra-procedurally and inter-procedurally propagates the escape status of static fields and thread fields in the whole Java program and Java libraries. Thus it can identify those objects accessed by only one thread and then remove synchronization operations on them. We have developed an implementation on the Java framework Soot. Our escape analysis framework is written in Java and thus portable. For our benchmarks, 15.7% to 99.2% (with a median of 55.9%) of synchronization operations are eliminated.</description><subject>Algorithm design and analysis</subject><subject>Educational institutions</subject><subject>escape analysis</subject><subject>Ground support</subject><subject>Information analysis</subject><subject>Java</subject><subject>Libraries</subject><subject>Mathematics</subject><subject>Performance analysis</subject><subject>points-to graph</subject><subject>Soot</subject><subject>synchronization removal</subject><subject>Testing</subject><subject>thread-escape</subject><subject>Yarn</subject><issn>2157-5592</issn><isbn>9781424446995</isbn><isbn>1424446996</isbn><fulltext>true</fulltext><rsrctype>conference_proceeding</rsrctype><creationdate>2009</creationdate><recordtype>conference_proceeding</recordtype><sourceid>6IE</sourceid><sourceid>RIE</sourceid><recordid>eNotj81OwzAQhC1BJUrJAyAufoEE21kn3iOK-Ckq4kDu1SZrQ1DbRHaF1LcniM5lLqNP3whxq1WhtcL7ddO-FUYpLCxog85eiAxrp8EAQIVoL8XSaFvn1qJZiOu_KSqoEa5EltK3mgPWgNJLUbVf0RNLn3qavKQD7U5pSDKMUb7SD8kpjp-R9kl2lDzL8SA_xvF4IxaBdsln516J9umxbV7yzfvzunnY5AOqYw6OK91VAXtGY5SZXQG965BDTVzybKuwYnZVMNqxCb0pqWftuhrIM5UrcfePHbz32ykOe4qn7fl1-Qv20EhT</recordid><startdate>200912</startdate><enddate>200912</enddate><creator>Yongxian Jin</creator><creator>Wei Hu</creator><creator>Fengzhen Chen</creator><creator>Gaofeng Che</creator><general>IEEE</general><scope>6IE</scope><scope>6IL</scope><scope>CBEJK</scope><scope>RIE</scope><scope>RIL</scope></search><sort><creationdate>200912</creationdate><title>Thread escape analysis for Java programs based on Soot</title><author>Yongxian Jin ; Wei Hu ; Fengzhen Chen ; Gaofeng Che</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-i90t-48d61b6f9cd9220229849e8b9df7ad3d446096dd86f218d2fc23acd18b74aeda3</frbrgroupid><rsrctype>conference_proceedings</rsrctype><prefilter>conference_proceedings</prefilter><language>eng</language><creationdate>2009</creationdate><topic>Algorithm design and analysis</topic><topic>Educational institutions</topic><topic>escape analysis</topic><topic>Ground support</topic><topic>Information analysis</topic><topic>Java</topic><topic>Libraries</topic><topic>Mathematics</topic><topic>Performance analysis</topic><topic>points-to graph</topic><topic>Soot</topic><topic>synchronization removal</topic><topic>Testing</topic><topic>thread-escape</topic><topic>Yarn</topic><toplevel>online_resources</toplevel><creatorcontrib>Yongxian Jin</creatorcontrib><creatorcontrib>Wei Hu</creatorcontrib><creatorcontrib>Fengzhen Chen</creatorcontrib><creatorcontrib>Gaofeng Che</creatorcontrib><collection>IEEE Electronic Library (IEL) Conference Proceedings</collection><collection>IEEE Proceedings Order Plan All Online (POP All Online) 1998-present by volume</collection><collection>IEEE Xplore All Conference Proceedings</collection><collection>IEEE Electronic Library (IEL)</collection><collection>IEEE Proceedings Order Plans (POP All) 1998-Present</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext_linktorsrc</fulltext></delivery><addata><au>Yongxian Jin</au><au>Wei Hu</au><au>Fengzhen Chen</au><au>Gaofeng Che</au><format>book</format><genre>proceeding</genre><ristype>CONF</ristype><atitle>Thread escape analysis for Java programs based on Soot</atitle><btitle>2009 International Conference on Test and Measurement</btitle><stitle>ICTM</stitle><date>2009-12</date><risdate>2009</risdate><volume>1</volume><spage>106</spage><epage>109</epage><pages>106-109</pages><issn>2157-5592</issn><isbn>9781424446995</isbn><isbn>1424446996</isbn><abstract>To reduce the synchronization overhead for parallel Java programs, we introduce a thread escape analysis based on points-to graphs. It combines the rules for determining whether an object escapes the thread that creates it with a flexible points-to analysis framework. It intra-procedurally and inter-procedurally propagates the escape status of static fields and thread fields in the whole Java program and Java libraries. Thus it can identify those objects accessed by only one thread and then remove synchronization operations on them. We have developed an implementation on the Java framework Soot. Our escape analysis framework is written in Java and thus portable. For our benchmarks, 15.7% to 99.2% (with a median of 55.9%) of synchronization operations are eliminated.</abstract><pub>IEEE</pub><doi>10.1109/ICTM.2009.5412985</doi><tpages>4</tpages></addata></record> |
| fulltext | fulltext_linktorsrc |
| identifier | ISSN: 2157-5592 |
| ispartof | 2009 International Conference on Test and Measurement, 2009, Vol.1, p.106-109 |
| issn | 2157-5592 |
| language | eng |
| recordid | cdi_ieee_primary_5412985 |
| source | IEEE Electronic Library (IEL) Conference Proceedings |
| subjects | Algorithm design and analysis Educational institutions escape analysis Ground support Information analysis Java Libraries Mathematics Performance analysis points-to graph Soot synchronization removal Testing thread-escape Yarn |
| title | Thread escape analysis for Java programs based on Soot |
| url | https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-09T12%3A36%3A30IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-ieee_6IE&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=proceeding&rft.atitle=Thread%20escape%20analysis%20for%20Java%20programs%20based%20on%20Soot&rft.btitle=2009%20International%20Conference%20on%20Test%20and%20Measurement&rft.au=Yongxian%20Jin&rft.date=2009-12&rft.volume=1&rft.spage=106&rft.epage=109&rft.pages=106-109&rft.issn=2157-5592&rft.isbn=9781424446995&rft.isbn_list=1424446996&rft_id=info:doi/10.1109/ICTM.2009.5412985&rft_dat=%3Cieee_6IE%3E5412985%3C/ieee_6IE%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_id=info:pmid/&rft_ieee_id=5412985&rfr_iscdi=true |