A Lazy Concurrent List-Based Set Algorithm
List-based implementations of sets are a fundamental building block of many concurrent algorithms. A skiplist based on the lock-free list-based set algorithm of Michael will be included in the JavaTM Concurrency Package of JDK 1.6.0. However, Michael’s lock-free algorithm has several drawbacks, most...
Gespeichert in:
Hauptverfasser: | , , , , , |
---|---|
Format: | Tagungsbericht |
Sprache: | eng |
Schlagworte: | |
Online-Zugang: | Volltext |
Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
container_end_page | 16 |
---|---|
container_issue | |
container_start_page | 3 |
container_title | |
container_volume | |
creator | Heller, Steve Herlihy, Maurice Luchangco, Victor Moir, Mark Scherer, William N. Shavit, Nir |
description | List-based implementations of sets are a fundamental building block of many concurrent algorithms. A skiplist based on the lock-free list-based set algorithm of Michael will be included in the JavaTM Concurrency Package of JDK 1.6.0. However, Michael’s lock-free algorithm has several drawbacks, most notably that it requires all list traversal operations, including membership tests, to perform cleanup operations of logically removed nodes, and that it uses the equivalent of an atomically markable reference, a pointer that can be atomically “marked,” which is expensive in some languages and unavailable in others.
We present a novel “lazy” list-based implementation of a concurrent set object. It is based on an optimistic locking scheme for inserts and removes, eliminating the need to use the equivalent of an atomically markable reference. It also has a novel wait-free membership test operation (as opposed to Michael’s lock-free one) that does not need to perform cleanup operations and is more efficient than that of all previous algorithms.
Empirical testing shows that the new lazy-list algorithm consistently outperforms all known algorithms, including Michael’s lock-free algorithm, throughout the concurrency range. At high load, with 90% membership tests, the lazy algorithm is more than twice as fast as Michael’s. This is encouraging given that typical search structure usage patterns include around 90% membership tests. By replacing the lock-free membership test of Michael’s algorithm with our new wait-free one, we achieve an algorithm that slightly outperforms our new lazy-list (though it may not be as efficient in other contexts as it uses Java’s RTTI mechanism to create pointers that can be atomically marked). |
doi_str_mv | 10.1007/11795490_3 |
format | Conference Proceeding |
fullrecord | <record><control><sourceid>pascalfrancis_sprin</sourceid><recordid>TN_cdi_pascalfrancis_primary_19183686</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>19183686</sourcerecordid><originalsourceid>FETCH-LOGICAL-c259t-921ce66ce8f53d05e5f79d6dfb1d7d06af73081cfc30d7fe4a4d53a4bb3945703</originalsourceid><addsrcrecordid>eNpFkLlOw0AURYdNIoQ0fIEbJIRkeM9vFk8ZIjbJEgVQj8azBENiRx5ThK_HKCBuc4tzdYrL2BnCFQKoa0SlBddgaI_NtCpJcCBJRcH32QQlYk7E9QE7-QOIh2wCBEWuFadjNkvpHcYQjh6YsMt5VtmvbbboWvfZ96EdsqpJQ35jU_DZcxiy-WrZ9c3wtj5lR9GuUpj99pS93t2-LB7y6un-cTGvclcIPeS6QBekdKGMgjyIIKLSXvpYo1cepI2KoEQXHYFXMXDLvSDL65o0Fwpoys533o1Nzq5ib1vXJLPpm7XttwY1liRLOe4udrs0onYZelN33UcyCObnK_P_FX0DWd5UUA</addsrcrecordid><sourcetype>Index Database</sourcetype><iscdi>true</iscdi><recordtype>conference_proceeding</recordtype></control><display><type>conference_proceeding</type><title>A Lazy Concurrent List-Based Set Algorithm</title><source>Springer Books</source><creator>Heller, Steve ; Herlihy, Maurice ; Luchangco, Victor ; Moir, Mark ; Scherer, William N. ; Shavit, Nir</creator><contributor>Anderson, James H. ; Prencipe, Giuseppe ; Wattenhofer, Roger</contributor><creatorcontrib>Heller, Steve ; Herlihy, Maurice ; Luchangco, Victor ; Moir, Mark ; Scherer, William N. ; Shavit, Nir ; Anderson, James H. ; Prencipe, Giuseppe ; Wattenhofer, Roger</creatorcontrib><description>List-based implementations of sets are a fundamental building block of many concurrent algorithms. A skiplist based on the lock-free list-based set algorithm of Michael will be included in the JavaTM Concurrency Package of JDK 1.6.0. However, Michael’s lock-free algorithm has several drawbacks, most notably that it requires all list traversal operations, including membership tests, to perform cleanup operations of logically removed nodes, and that it uses the equivalent of an atomically markable reference, a pointer that can be atomically “marked,” which is expensive in some languages and unavailable in others.
We present a novel “lazy” list-based implementation of a concurrent set object. It is based on an optimistic locking scheme for inserts and removes, eliminating the need to use the equivalent of an atomically markable reference. It also has a novel wait-free membership test operation (as opposed to Michael’s lock-free one) that does not need to perform cleanup operations and is more efficient than that of all previous algorithms.
Empirical testing shows that the new lazy-list algorithm consistently outperforms all known algorithms, including Michael’s lock-free algorithm, throughout the concurrency range. At high load, with 90% membership tests, the lazy algorithm is more than twice as fast as Michael’s. This is encouraging given that typical search structure usage patterns include around 90% membership tests. By replacing the lock-free membership test of Michael’s algorithm with our new wait-free one, we achieve an algorithm that slightly outperforms our new lazy-list (though it may not be as efficient in other contexts as it uses Java’s RTTI mechanism to create pointers that can be atomically marked).</description><identifier>ISSN: 0302-9743</identifier><identifier>ISBN: 3540363211</identifier><identifier>ISBN: 9783540363217</identifier><identifier>EISSN: 1611-3349</identifier><identifier>EISBN: 9783540363224</identifier><identifier>EISBN: 354036322X</identifier><identifier>DOI: 10.1007/11795490_3</identifier><language>eng</language><publisher>Berlin, Heidelberg: Springer Berlin Heidelberg</publisher><subject>Applied sciences ; Computer science; control theory; systems ; Computer systems and distributed systems. User interface ; Exact sciences and technology ; Linearization Point ; Membership Query ; Membership Test ; Method Call ; Physical Removal ; Software</subject><ispartof>Lecture notes in computer science, 2006, p.3-16</ispartof><rights>Springer-Verlag Berlin Heidelberg 2006</rights><rights>2007 INIST-CNRS</rights><lds50>peer_reviewed</lds50><woscitedreferencessubscribed>false</woscitedreferencessubscribed><citedby>FETCH-LOGICAL-c259t-921ce66ce8f53d05e5f79d6dfb1d7d06af73081cfc30d7fe4a4d53a4bb3945703</citedby></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktopdf>$$Uhttps://link.springer.com/content/pdf/10.1007/11795490_3$$EPDF$$P50$$Gspringer$$H</linktopdf><linktohtml>$$Uhttps://link.springer.com/10.1007/11795490_3$$EHTML$$P50$$Gspringer$$H</linktohtml><link.rule.ids>309,310,779,780,784,789,790,793,4050,4051,27925,38255,41442,42511</link.rule.ids><backlink>$$Uhttp://pascal-francis.inist.fr/vibad/index.php?action=getRecordDetail&idt=19183686$$DView record in Pascal Francis$$Hfree_for_read</backlink></links><search><contributor>Anderson, James H.</contributor><contributor>Prencipe, Giuseppe</contributor><contributor>Wattenhofer, Roger</contributor><creatorcontrib>Heller, Steve</creatorcontrib><creatorcontrib>Herlihy, Maurice</creatorcontrib><creatorcontrib>Luchangco, Victor</creatorcontrib><creatorcontrib>Moir, Mark</creatorcontrib><creatorcontrib>Scherer, William N.</creatorcontrib><creatorcontrib>Shavit, Nir</creatorcontrib><title>A Lazy Concurrent List-Based Set Algorithm</title><title>Lecture notes in computer science</title><description>List-based implementations of sets are a fundamental building block of many concurrent algorithms. A skiplist based on the lock-free list-based set algorithm of Michael will be included in the JavaTM Concurrency Package of JDK 1.6.0. However, Michael’s lock-free algorithm has several drawbacks, most notably that it requires all list traversal operations, including membership tests, to perform cleanup operations of logically removed nodes, and that it uses the equivalent of an atomically markable reference, a pointer that can be atomically “marked,” which is expensive in some languages and unavailable in others.
We present a novel “lazy” list-based implementation of a concurrent set object. It is based on an optimistic locking scheme for inserts and removes, eliminating the need to use the equivalent of an atomically markable reference. It also has a novel wait-free membership test operation (as opposed to Michael’s lock-free one) that does not need to perform cleanup operations and is more efficient than that of all previous algorithms.
Empirical testing shows that the new lazy-list algorithm consistently outperforms all known algorithms, including Michael’s lock-free algorithm, throughout the concurrency range. At high load, with 90% membership tests, the lazy algorithm is more than twice as fast as Michael’s. This is encouraging given that typical search structure usage patterns include around 90% membership tests. By replacing the lock-free membership test of Michael’s algorithm with our new wait-free one, we achieve an algorithm that slightly outperforms our new lazy-list (though it may not be as efficient in other contexts as it uses Java’s RTTI mechanism to create pointers that can be atomically marked).</description><subject>Applied sciences</subject><subject>Computer science; control theory; systems</subject><subject>Computer systems and distributed systems. User interface</subject><subject>Exact sciences and technology</subject><subject>Linearization Point</subject><subject>Membership Query</subject><subject>Membership Test</subject><subject>Method Call</subject><subject>Physical Removal</subject><subject>Software</subject><issn>0302-9743</issn><issn>1611-3349</issn><isbn>3540363211</isbn><isbn>9783540363217</isbn><isbn>9783540363224</isbn><isbn>354036322X</isbn><fulltext>true</fulltext><rsrctype>conference_proceeding</rsrctype><creationdate>2006</creationdate><recordtype>conference_proceeding</recordtype><recordid>eNpFkLlOw0AURYdNIoQ0fIEbJIRkeM9vFk8ZIjbJEgVQj8azBENiRx5ThK_HKCBuc4tzdYrL2BnCFQKoa0SlBddgaI_NtCpJcCBJRcH32QQlYk7E9QE7-QOIh2wCBEWuFadjNkvpHcYQjh6YsMt5VtmvbbboWvfZ96EdsqpJQ35jU_DZcxiy-WrZ9c3wtj5lR9GuUpj99pS93t2-LB7y6un-cTGvclcIPeS6QBekdKGMgjyIIKLSXvpYo1cepI2KoEQXHYFXMXDLvSDL65o0Fwpoys533o1Nzq5ib1vXJLPpm7XttwY1liRLOe4udrs0onYZelN33UcyCObnK_P_FX0DWd5UUA</recordid><startdate>2006</startdate><enddate>2006</enddate><creator>Heller, Steve</creator><creator>Herlihy, Maurice</creator><creator>Luchangco, Victor</creator><creator>Moir, Mark</creator><creator>Scherer, William N.</creator><creator>Shavit, Nir</creator><general>Springer Berlin Heidelberg</general><general>Springer</general><scope>IQODW</scope></search><sort><creationdate>2006</creationdate><title>A Lazy Concurrent List-Based Set Algorithm</title><author>Heller, Steve ; Herlihy, Maurice ; Luchangco, Victor ; Moir, Mark ; Scherer, William N. ; Shavit, Nir</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c259t-921ce66ce8f53d05e5f79d6dfb1d7d06af73081cfc30d7fe4a4d53a4bb3945703</frbrgroupid><rsrctype>conference_proceedings</rsrctype><prefilter>conference_proceedings</prefilter><language>eng</language><creationdate>2006</creationdate><topic>Applied sciences</topic><topic>Computer science; control theory; systems</topic><topic>Computer systems and distributed systems. User interface</topic><topic>Exact sciences and technology</topic><topic>Linearization Point</topic><topic>Membership Query</topic><topic>Membership Test</topic><topic>Method Call</topic><topic>Physical Removal</topic><topic>Software</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>Heller, Steve</creatorcontrib><creatorcontrib>Herlihy, Maurice</creatorcontrib><creatorcontrib>Luchangco, Victor</creatorcontrib><creatorcontrib>Moir, Mark</creatorcontrib><creatorcontrib>Scherer, William N.</creatorcontrib><creatorcontrib>Shavit, Nir</creatorcontrib><collection>Pascal-Francis</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Heller, Steve</au><au>Herlihy, Maurice</au><au>Luchangco, Victor</au><au>Moir, Mark</au><au>Scherer, William N.</au><au>Shavit, Nir</au><au>Anderson, James H.</au><au>Prencipe, Giuseppe</au><au>Wattenhofer, Roger</au><format>book</format><genre>proceeding</genre><ristype>CONF</ristype><atitle>A Lazy Concurrent List-Based Set Algorithm</atitle><btitle>Lecture notes in computer science</btitle><date>2006</date><risdate>2006</risdate><spage>3</spage><epage>16</epage><pages>3-16</pages><issn>0302-9743</issn><eissn>1611-3349</eissn><isbn>3540363211</isbn><isbn>9783540363217</isbn><eisbn>9783540363224</eisbn><eisbn>354036322X</eisbn><abstract>List-based implementations of sets are a fundamental building block of many concurrent algorithms. A skiplist based on the lock-free list-based set algorithm of Michael will be included in the JavaTM Concurrency Package of JDK 1.6.0. However, Michael’s lock-free algorithm has several drawbacks, most notably that it requires all list traversal operations, including membership tests, to perform cleanup operations of logically removed nodes, and that it uses the equivalent of an atomically markable reference, a pointer that can be atomically “marked,” which is expensive in some languages and unavailable in others.
We present a novel “lazy” list-based implementation of a concurrent set object. It is based on an optimistic locking scheme for inserts and removes, eliminating the need to use the equivalent of an atomically markable reference. It also has a novel wait-free membership test operation (as opposed to Michael’s lock-free one) that does not need to perform cleanup operations and is more efficient than that of all previous algorithms.
Empirical testing shows that the new lazy-list algorithm consistently outperforms all known algorithms, including Michael’s lock-free algorithm, throughout the concurrency range. At high load, with 90% membership tests, the lazy algorithm is more than twice as fast as Michael’s. This is encouraging given that typical search structure usage patterns include around 90% membership tests. By replacing the lock-free membership test of Michael’s algorithm with our new wait-free one, we achieve an algorithm that slightly outperforms our new lazy-list (though it may not be as efficient in other contexts as it uses Java’s RTTI mechanism to create pointers that can be atomically marked).</abstract><cop>Berlin, Heidelberg</cop><pub>Springer Berlin Heidelberg</pub><doi>10.1007/11795490_3</doi><tpages>14</tpages></addata></record> |
fulltext | fulltext |
identifier | ISSN: 0302-9743 |
ispartof | Lecture notes in computer science, 2006, p.3-16 |
issn | 0302-9743 1611-3349 |
language | eng |
recordid | cdi_pascalfrancis_primary_19183686 |
source | Springer Books |
subjects | Applied sciences Computer science control theory systems Computer systems and distributed systems. User interface Exact sciences and technology Linearization Point Membership Query Membership Test Method Call Physical Removal Software |
title | A Lazy Concurrent List-Based Set Algorithm |
url | https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2024-12-25T19%3A53%3A15IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-pascalfrancis_sprin&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=proceeding&rft.atitle=A%20Lazy%20Concurrent%20List-Based%20Set%20Algorithm&rft.btitle=Lecture%20notes%20in%20computer%20science&rft.au=Heller,%20Steve&rft.date=2006&rft.spage=3&rft.epage=16&rft.pages=3-16&rft.issn=0302-9743&rft.eissn=1611-3349&rft.isbn=3540363211&rft.isbn_list=9783540363217&rft_id=info:doi/10.1007/11795490_3&rft_dat=%3Cpascalfrancis_sprin%3E19183686%3C/pascalfrancis_sprin%3E%3Curl%3E%3C/url%3E&rft.eisbn=9783540363224&rft.eisbn_list=354036322X&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_id=info:pmid/&rfr_iscdi=true |