Lightweight monitors for the Java virtual machine

Java supports the monitor construct for language‐level synchronization in the context of multi‐threading. This paper introduces the lightweight monitor, an efficient user‐level monitor implementation. The lightweight monitor is useful for single‐threaded Java programs as well as for multi‐threaded J...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Veröffentlicht in:Software, practice & experience practice & experience, 2005-03, Vol.35 (3), p.281-299
Hauptverfasser: Yang, Byung-Sun, Moon, Soo-Mook, Ebcioğlu, Kemal
Format: Artikel
Sprache:eng
Schlagworte:
Online-Zugang:Volltext
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page 299
container_issue 3
container_start_page 281
container_title Software, practice & experience
container_volume 35
creator Yang, Byung-Sun
Moon, Soo-Mook
Ebcioğlu, Kemal
description Java supports the monitor construct for language‐level synchronization in the context of multi‐threading. This paper introduces the lightweight monitor, an efficient user‐level monitor implementation. The lightweight monitor is useful for single‐threaded Java programs as well as for multi‐threaded Java programs with little lock contention. A 32‐bit lock is embedded in each object for efficient lock access while other monitor data structures are managed using a hash table. We highly optimized the lock manipulation code, which is translated and inlined by a just‐in‐time (JIT) compiler. In the most probable cases, only nine SPARC instructions are spent for lock acquisition and five instructions are spent for lock release. Our experimental results indicate that the lightweight monitor is faster than the monitor implementation in the SUN JDK 1.2 RC1 by up to 21 times in the absence of lock contention and by up to seven times in the presence of lock contention. Copyright © 2004 John Wiley & Sons, Ltd.
doi_str_mv 10.1002/spe.635
format Article
fullrecord <record><control><sourceid>proquest_cross</sourceid><recordid>TN_cdi_proquest_miscellaneous_28559586</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>28559586</sourcerecordid><originalsourceid>FETCH-LOGICAL-c3305-63979735f6a3bef466d6cc97e44ad598780c28d1da18699a228ce5e394de18cb3</originalsourceid><addsrcrecordid>eNp10E9LwzAYx_EgCs4pvoWe9CCd-dOkyVGKVsdQQcXhJWTpUxdt15l0m3v3dlS8eXmey4ff4YvQKcEjgjG9DEsYCcb30IBglcaYJtN9NMCYyRiLJDlERyF8YEwIp2KAyMS9z9sN7G5UNwvXNj5EZeOjdg7R2KxNtHa-XZkqqo2duwUco4PSVAFOfv8QvdxcP2e38eQhv8uuJrFlDPNYMJWqlPFSGDaDMhGiENaqFJLEFFzJVGJLZUEKQ6RQylAqLXBgKimASDtjQ3TW7y5987WC0OraBQtVZRbQrIKmknPFpejgeQ-tb0LwUOqld7XxW02w3iXRXRLdJenkRS83roLtf0w_PV73Ou61Cy18_2njP7VIWcr1632ux3n2JqY51Rn7AdshcDM</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype><pqid>28559586</pqid></control><display><type>article</type><title>Lightweight monitors for the Java virtual machine</title><source>Access via Wiley Online Library</source><creator>Yang, Byung-Sun ; Moon, Soo-Mook ; Ebcioğlu, Kemal</creator><creatorcontrib>Yang, Byung-Sun ; Moon, Soo-Mook ; Ebcioğlu, Kemal</creatorcontrib><description>Java supports the monitor construct for language‐level synchronization in the context of multi‐threading. This paper introduces the lightweight monitor, an efficient user‐level monitor implementation. The lightweight monitor is useful for single‐threaded Java programs as well as for multi‐threaded Java programs with little lock contention. A 32‐bit lock is embedded in each object for efficient lock access while other monitor data structures are managed using a hash table. We highly optimized the lock manipulation code, which is translated and inlined by a just‐in‐time (JIT) compiler. In the most probable cases, only nine SPARC instructions are spent for lock acquisition and five instructions are spent for lock release. Our experimental results indicate that the lightweight monitor is faster than the monitor implementation in the SUN JDK 1.2 RC1 by up to 21 times in the absence of lock contention and by up to seven times in the presence of lock contention. Copyright © 2004 John Wiley &amp; Sons, Ltd.</description><identifier>ISSN: 0038-0644</identifier><identifier>EISSN: 1097-024X</identifier><identifier>DOI: 10.1002/spe.635</identifier><language>eng</language><publisher>Chichester, UK: John Wiley &amp; Sons, Ltd</publisher><subject>Java virtual machine ; just-in-time compilation ; lock ; monitor</subject><ispartof>Software, practice &amp; experience, 2005-03, Vol.35 (3), p.281-299</ispartof><rights>Copyright © 2004 John Wiley &amp; Sons, Ltd.</rights><lds50>peer_reviewed</lds50><woscitedreferencessubscribed>false</woscitedreferencessubscribed><citedby>FETCH-LOGICAL-c3305-63979735f6a3bef466d6cc97e44ad598780c28d1da18699a228ce5e394de18cb3</citedby><cites>FETCH-LOGICAL-c3305-63979735f6a3bef466d6cc97e44ad598780c28d1da18699a228ce5e394de18cb3</cites></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktopdf>$$Uhttps://onlinelibrary.wiley.com/doi/pdf/10.1002%2Fspe.635$$EPDF$$P50$$Gwiley$$H</linktopdf><linktohtml>$$Uhttps://onlinelibrary.wiley.com/doi/full/10.1002%2Fspe.635$$EHTML$$P50$$Gwiley$$H</linktohtml><link.rule.ids>314,780,784,1417,27924,27925,45574,45575</link.rule.ids></links><search><creatorcontrib>Yang, Byung-Sun</creatorcontrib><creatorcontrib>Moon, Soo-Mook</creatorcontrib><creatorcontrib>Ebcioğlu, Kemal</creatorcontrib><title>Lightweight monitors for the Java virtual machine</title><title>Software, practice &amp; experience</title><addtitle>Softw: Pract. Exper</addtitle><description>Java supports the monitor construct for language‐level synchronization in the context of multi‐threading. This paper introduces the lightweight monitor, an efficient user‐level monitor implementation. The lightweight monitor is useful for single‐threaded Java programs as well as for multi‐threaded Java programs with little lock contention. A 32‐bit lock is embedded in each object for efficient lock access while other monitor data structures are managed using a hash table. We highly optimized the lock manipulation code, which is translated and inlined by a just‐in‐time (JIT) compiler. In the most probable cases, only nine SPARC instructions are spent for lock acquisition and five instructions are spent for lock release. Our experimental results indicate that the lightweight monitor is faster than the monitor implementation in the SUN JDK 1.2 RC1 by up to 21 times in the absence of lock contention and by up to seven times in the presence of lock contention. Copyright © 2004 John Wiley &amp; Sons, Ltd.</description><subject>Java virtual machine</subject><subject>just-in-time compilation</subject><subject>lock</subject><subject>monitor</subject><issn>0038-0644</issn><issn>1097-024X</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2005</creationdate><recordtype>article</recordtype><recordid>eNp10E9LwzAYx_EgCs4pvoWe9CCd-dOkyVGKVsdQQcXhJWTpUxdt15l0m3v3dlS8eXmey4ff4YvQKcEjgjG9DEsYCcb30IBglcaYJtN9NMCYyRiLJDlERyF8YEwIp2KAyMS9z9sN7G5UNwvXNj5EZeOjdg7R2KxNtHa-XZkqqo2duwUco4PSVAFOfv8QvdxcP2e38eQhv8uuJrFlDPNYMJWqlPFSGDaDMhGiENaqFJLEFFzJVGJLZUEKQ6RQylAqLXBgKimASDtjQ3TW7y5987WC0OraBQtVZRbQrIKmknPFpejgeQ-tb0LwUOqld7XxW02w3iXRXRLdJenkRS83roLtf0w_PV73Ou61Cy18_2njP7VIWcr1632ux3n2JqY51Rn7AdshcDM</recordid><startdate>200503</startdate><enddate>200503</enddate><creator>Yang, Byung-Sun</creator><creator>Moon, Soo-Mook</creator><creator>Ebcioğlu, Kemal</creator><general>John Wiley &amp; Sons, Ltd</general><scope>BSCLL</scope><scope>AAYXX</scope><scope>CITATION</scope><scope>8FD</scope><scope>F28</scope><scope>FR3</scope></search><sort><creationdate>200503</creationdate><title>Lightweight monitors for the Java virtual machine</title><author>Yang, Byung-Sun ; Moon, Soo-Mook ; Ebcioğlu, Kemal</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c3305-63979735f6a3bef466d6cc97e44ad598780c28d1da18699a228ce5e394de18cb3</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2005</creationdate><topic>Java virtual machine</topic><topic>just-in-time compilation</topic><topic>lock</topic><topic>monitor</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>Yang, Byung-Sun</creatorcontrib><creatorcontrib>Moon, Soo-Mook</creatorcontrib><creatorcontrib>Ebcioğlu, Kemal</creatorcontrib><collection>Istex</collection><collection>CrossRef</collection><collection>Technology Research Database</collection><collection>ANTE: Abstracts in New Technology &amp; Engineering</collection><collection>Engineering Research Database</collection><jtitle>Software, practice &amp; experience</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Yang, Byung-Sun</au><au>Moon, Soo-Mook</au><au>Ebcioğlu, Kemal</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Lightweight monitors for the Java virtual machine</atitle><jtitle>Software, practice &amp; experience</jtitle><addtitle>Softw: Pract. Exper</addtitle><date>2005-03</date><risdate>2005</risdate><volume>35</volume><issue>3</issue><spage>281</spage><epage>299</epage><pages>281-299</pages><issn>0038-0644</issn><eissn>1097-024X</eissn><abstract>Java supports the monitor construct for language‐level synchronization in the context of multi‐threading. This paper introduces the lightweight monitor, an efficient user‐level monitor implementation. The lightweight monitor is useful for single‐threaded Java programs as well as for multi‐threaded Java programs with little lock contention. A 32‐bit lock is embedded in each object for efficient lock access while other monitor data structures are managed using a hash table. We highly optimized the lock manipulation code, which is translated and inlined by a just‐in‐time (JIT) compiler. In the most probable cases, only nine SPARC instructions are spent for lock acquisition and five instructions are spent for lock release. Our experimental results indicate that the lightweight monitor is faster than the monitor implementation in the SUN JDK 1.2 RC1 by up to 21 times in the absence of lock contention and by up to seven times in the presence of lock contention. Copyright © 2004 John Wiley &amp; Sons, Ltd.</abstract><cop>Chichester, UK</cop><pub>John Wiley &amp; Sons, Ltd</pub><doi>10.1002/spe.635</doi><tpages>19</tpages></addata></record>
fulltext fulltext
identifier ISSN: 0038-0644
ispartof Software, practice & experience, 2005-03, Vol.35 (3), p.281-299
issn 0038-0644
1097-024X
language eng
recordid cdi_proquest_miscellaneous_28559586
source Access via Wiley Online Library
subjects Java virtual machine
just-in-time compilation
lock
monitor
title Lightweight monitors for the Java virtual machine
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2024-12-20T09%3A50%3A22IST&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=Lightweight%20monitors%20for%20the%20Java%20virtual%20machine&rft.jtitle=Software,%20practice%20&%20experience&rft.au=Yang,%20Byung-Sun&rft.date=2005-03&rft.volume=35&rft.issue=3&rft.spage=281&rft.epage=299&rft.pages=281-299&rft.issn=0038-0644&rft.eissn=1097-024X&rft_id=info:doi/10.1002/spe.635&rft_dat=%3Cproquest_cross%3E28559586%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=28559586&rft_id=info:pmid/&rfr_iscdi=true