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...
Gespeichert in:
Hauptverfasser: | , |
---|---|
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 |