Handling localisation in rely/guarantee concurrency: An algebraic approach

The rely/guarantee approach of Jones extends Hoare logic with rely and guarantee conditions in order to allow compositional reasoning about shared-variable concurrent programs. This paper focuses on localisation in the context of rely/guarantee concurrency in order to support local variables. Becaus...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Hauptverfasser: Meinicke, Larissa A, Hayes, Ian J
Format: Artikel
Sprache:eng
Schlagworte:
Online-Zugang:Volltext bestellen
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page
container_issue
container_start_page
container_title
container_volume
creator Meinicke, Larissa A
Hayes, Ian J
description The rely/guarantee approach of Jones extends Hoare logic with rely and guarantee conditions in order to allow compositional reasoning about shared-variable concurrent programs. This paper focuses on localisation in the context of rely/guarantee concurrency in order to support local variables. Because we allow the body of a local variable block to contain component processes that run in parallel, the approach needs to allow variables local to a block to become shared variables of its component parallel processes. To support the mechanisation of the rely/guarantee approach, we have developed a synchronous concurrent refinement algebra. Its foundation consists of a small set of primitive commands plus a small set of primitive operators from which all remaining constructs are defined. To support local variables we add a primitive localisation operator to our algebra that is used to define local variable blocks. From this we can prove properties of localisation, including its interaction with rely and guarantee conditions.
doi_str_mv 10.48550/arxiv.1907.04005
format Article
fullrecord <record><control><sourceid>arxiv_GOX</sourceid><recordid>TN_cdi_arxiv_primary_1907_04005</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>1907_04005</sourcerecordid><originalsourceid>FETCH-LOGICAL-a675-d751b2422703ca7a66dec11b7f9dec52eef6173b5da11fd83ba6374fe0d828543</originalsourceid><addsrcrecordid>eNotz71OwzAYhWEvDKhwAUz4BpL63ylbVQEFVWLpHn22P6eWXCdyW0TuHihM552O9BDywFmrOq3ZEupX-mz5itmWKcb0LXnfQgk5lYHm0UNOJzinsdBUaMU8L4cLVChnROrH4i-1YvHzE10XCnlAVyF5CtNUR_CHO3ITIZ_w_n8XZP_yvN9sm93H69tmvWvAWN0Eq7kTSgjLpAcLxgT0nDsbVz-hBWI03EqnA3AeQycdGGlVRBY60WklF-Tx7_aK6aeajlDn_hfVX1HyG66fSCI</addsrcrecordid><sourcetype>Open Access Repository</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype></control><display><type>article</type><title>Handling localisation in rely/guarantee concurrency: An algebraic approach</title><source>arXiv.org</source><creator>Meinicke, Larissa A ; Hayes, Ian J</creator><creatorcontrib>Meinicke, Larissa A ; Hayes, Ian J</creatorcontrib><description>The rely/guarantee approach of Jones extends Hoare logic with rely and guarantee conditions in order to allow compositional reasoning about shared-variable concurrent programs. This paper focuses on localisation in the context of rely/guarantee concurrency in order to support local variables. Because we allow the body of a local variable block to contain component processes that run in parallel, the approach needs to allow variables local to a block to become shared variables of its component parallel processes. To support the mechanisation of the rely/guarantee approach, we have developed a synchronous concurrent refinement algebra. Its foundation consists of a small set of primitive commands plus a small set of primitive operators from which all remaining constructs are defined. To support local variables we add a primitive localisation operator to our algebra that is used to define local variable blocks. From this we can prove properties of localisation, including its interaction with rely and guarantee conditions.</description><identifier>DOI: 10.48550/arxiv.1907.04005</identifier><language>eng</language><subject>Computer Science - Logic in Computer Science</subject><creationdate>2019-07</creationdate><rights>http://arxiv.org/licenses/nonexclusive-distrib/1.0</rights><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>228,230,778,883</link.rule.ids><linktorsrc>$$Uhttps://arxiv.org/abs/1907.04005$$EView_record_in_Cornell_University$$FView_record_in_$$GCornell_University$$Hfree_for_read</linktorsrc><backlink>$$Uhttps://doi.org/10.48550/arXiv.1907.04005$$DView paper in arXiv$$Hfree_for_read</backlink></links><search><creatorcontrib>Meinicke, Larissa A</creatorcontrib><creatorcontrib>Hayes, Ian J</creatorcontrib><title>Handling localisation in rely/guarantee concurrency: An algebraic approach</title><description>The rely/guarantee approach of Jones extends Hoare logic with rely and guarantee conditions in order to allow compositional reasoning about shared-variable concurrent programs. This paper focuses on localisation in the context of rely/guarantee concurrency in order to support local variables. Because we allow the body of a local variable block to contain component processes that run in parallel, the approach needs to allow variables local to a block to become shared variables of its component parallel processes. To support the mechanisation of the rely/guarantee approach, we have developed a synchronous concurrent refinement algebra. Its foundation consists of a small set of primitive commands plus a small set of primitive operators from which all remaining constructs are defined. To support local variables we add a primitive localisation operator to our algebra that is used to define local variable blocks. From this we can prove properties of localisation, including its interaction with rely and guarantee conditions.</description><subject>Computer Science - Logic in Computer Science</subject><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2019</creationdate><recordtype>article</recordtype><sourceid>GOX</sourceid><recordid>eNotz71OwzAYhWEvDKhwAUz4BpL63ylbVQEFVWLpHn22P6eWXCdyW0TuHihM552O9BDywFmrOq3ZEupX-mz5itmWKcb0LXnfQgk5lYHm0UNOJzinsdBUaMU8L4cLVChnROrH4i-1YvHzE10XCnlAVyF5CtNUR_CHO3ITIZ_w_n8XZP_yvN9sm93H69tmvWvAWN0Eq7kTSgjLpAcLxgT0nDsbVz-hBWI03EqnA3AeQycdGGlVRBY60WklF-Tx7_aK6aeajlDn_hfVX1HyG66fSCI</recordid><startdate>20190709</startdate><enddate>20190709</enddate><creator>Meinicke, Larissa A</creator><creator>Hayes, Ian J</creator><scope>AKY</scope><scope>GOX</scope></search><sort><creationdate>20190709</creationdate><title>Handling localisation in rely/guarantee concurrency: An algebraic approach</title><author>Meinicke, Larissa A ; Hayes, Ian J</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-a675-d751b2422703ca7a66dec11b7f9dec52eef6173b5da11fd83ba6374fe0d828543</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2019</creationdate><topic>Computer Science - Logic in Computer Science</topic><toplevel>online_resources</toplevel><creatorcontrib>Meinicke, Larissa A</creatorcontrib><creatorcontrib>Hayes, Ian J</creatorcontrib><collection>arXiv Computer Science</collection><collection>arXiv.org</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext_linktorsrc</fulltext></delivery><addata><au>Meinicke, Larissa A</au><au>Hayes, Ian J</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Handling localisation in rely/guarantee concurrency: An algebraic approach</atitle><date>2019-07-09</date><risdate>2019</risdate><abstract>The rely/guarantee approach of Jones extends Hoare logic with rely and guarantee conditions in order to allow compositional reasoning about shared-variable concurrent programs. This paper focuses on localisation in the context of rely/guarantee concurrency in order to support local variables. Because we allow the body of a local variable block to contain component processes that run in parallel, the approach needs to allow variables local to a block to become shared variables of its component parallel processes. To support the mechanisation of the rely/guarantee approach, we have developed a synchronous concurrent refinement algebra. Its foundation consists of a small set of primitive commands plus a small set of primitive operators from which all remaining constructs are defined. To support local variables we add a primitive localisation operator to our algebra that is used to define local variable blocks. From this we can prove properties of localisation, including its interaction with rely and guarantee conditions.</abstract><doi>10.48550/arxiv.1907.04005</doi><oa>free_for_read</oa></addata></record>
fulltext fulltext_linktorsrc
identifier DOI: 10.48550/arxiv.1907.04005
ispartof
issn
language eng
recordid cdi_arxiv_primary_1907_04005
source arXiv.org
subjects Computer Science - Logic in Computer Science
title Handling localisation in rely/guarantee concurrency: An algebraic approach
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-16T06%3A29%3A49IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-arxiv_GOX&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=Handling%20localisation%20in%20rely/guarantee%20concurrency:%20An%20algebraic%20approach&rft.au=Meinicke,%20Larissa%20A&rft.date=2019-07-09&rft_id=info:doi/10.48550/arxiv.1907.04005&rft_dat=%3Carxiv_GOX%3E1907_04005%3C/arxiv_GOX%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