Loading…

Datalog-based scalable semantic diffing of concurrent programs

When an evolving program is modified to address issues related to thread synchronization, there is a need to confirm the change is correct, i.e., it does not introduce unexpected behavior. However, manually comparing two programs to identify the semantic difference is labor intensive and error prone...

Full description

Saved in:
Bibliographic Details
Main Authors: Sung, Chungha, Lahiri, Shuvendu K., Enea, Constantin, Wang, Chao
Format: Conference Proceeding
Language:English
Subjects:
Online Access:Request full text
Tags: Add Tag
No Tags, Be the first to tag this record!
cited_by
cites
container_end_page 666
container_issue
container_start_page 656
container_title
container_volume
creator Sung, Chungha
Lahiri, Shuvendu K.
Enea, Constantin
Wang, Chao
description When an evolving program is modified to address issues related to thread synchronization, there is a need to confirm the change is correct, i.e., it does not introduce unexpected behavior. However, manually comparing two programs to identify the semantic difference is labor intensive and error prone, whereas techniques based on model checking are computationally expensive. To fill the gap, we develop a fast and approximate static analysis for computing synchronization differences of two programs. The method is fast because, instead of relying on heavy-weight model checking techniques, it leverages a polynomial-time Datalog-based program analysis framework to compute differentiating data-flow edges, i.e., edges allowed by one program but not the other. Although approximation is used our method is sufficiently accurate due to careful design of the Datalog inference rules and iterative increase of the required data-flow edges for representing a difference. We have implemented our method and evaluated it on a large number of multithreaded C programs to confirm its ability to produce, often within seconds, the same differences obtained by human; in contrast, prior techniques based on model checking take minutes or even hours and thus can be 10x to 1000x slower.
doi_str_mv 10.1145/3238147.3238211
format conference_proceeding
fullrecord <record><control><sourceid>acm_CHZPO</sourceid><recordid>TN_cdi_ieee_primary_9000032</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><ieee_id>9000032</ieee_id><sourcerecordid>acm_books_10_1145_3238147_3238211</sourcerecordid><originalsourceid>FETCH-LOGICAL-a275t-1de6fbc4e50c96c64b2b0c6c8c7e0fc197628ca13ff05af9d4f8f0059e739bc03</originalsourceid><addsrcrecordid>eNqNkL1PwzAUxA0IiVI6M7BkZEl5tuM4XpBQ-ZQqsYDEZtkvz1UgH5UdBv57UrUDI9NJd7qT7sfYJYcl54W6kUJWvNDLnQrOj9j55IJURuqPYzYTZSFzrrQ4-RucsUVKnwAgKg1KqBm7vXeja4dN7l2iOkvoWudbyhJ1rh8bzOomhKbfZEPIcOjxO0bqx2wbh010Xbpgp8G1iRYHnbP3x4e31XO-fn16Wd2tcye0GnNeUxk8FqQATYll4YUHLLFCTRCQG12KCh2XIYBywdRFqAKAMqSl8Qhyzq72uw0R2W1sOhd_rJmewARgzpb71GFn_TB8JcvB7jDZAyZ7wGR9bChMhet_FuQv0Ehj7g</addsrcrecordid><sourcetype>Publisher</sourcetype><iscdi>true</iscdi><recordtype>conference_proceeding</recordtype></control><display><type>conference_proceeding</type><title>Datalog-based scalable semantic diffing of concurrent programs</title><source>IEEE Xplore All Conference Series</source><creator>Sung, Chungha ; Lahiri, Shuvendu K. ; Enea, Constantin ; Wang, Chao</creator><creatorcontrib>Sung, Chungha ; Lahiri, Shuvendu K. ; Enea, Constantin ; Wang, Chao</creatorcontrib><description>When an evolving program is modified to address issues related to thread synchronization, there is a need to confirm the change is correct, i.e., it does not introduce unexpected behavior. However, manually comparing two programs to identify the semantic difference is labor intensive and error prone, whereas techniques based on model checking are computationally expensive. To fill the gap, we develop a fast and approximate static analysis for computing synchronization differences of two programs. The method is fast because, instead of relying on heavy-weight model checking techniques, it leverages a polynomial-time Datalog-based program analysis framework to compute differentiating data-flow edges, i.e., edges allowed by one program but not the other. Although approximation is used our method is sufficiently accurate due to careful design of the Datalog inference rules and iterative increase of the required data-flow edges for representing a difference. We have implemented our method and evaluated it on a large number of multithreaded C programs to confirm its ability to produce, often within seconds, the same differences obtained by human; in contrast, prior techniques based on model checking take minutes or even hours and thus can be 10x to 1000x slower.</description><identifier>ISBN: 145035937X</identifier><identifier>ISBN: 9781450359375</identifier><identifier>EISSN: 2643-1572</identifier><identifier>EISBN: 145035937X</identifier><identifier>EISBN: 9781450359375</identifier><identifier>DOI: 10.1145/3238147.3238211</identifier><language>eng</language><publisher>New York, NY, USA: ACM</publisher><subject>atomicity ; change impact ; Concurrency ; Datalog ; race condition ; semantic diffing ; Software and its engineering -- Software creation and management -- Software verification and validation ; static analysis</subject><ispartof>2018 33rd IEEE/ACM International Conference on Automated Software Engineering (ASE), 2018, p.656-666</ispartof><rights>2018 ACM</rights><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktohtml>$$Uhttps://ieeexplore.ieee.org/document/9000032$$EHTML$$P50$$Gieee$$H</linktohtml><link.rule.ids>309,310,780,784,789,790,23930,23931,25140,27925,54555,54932</link.rule.ids><linktorsrc>$$Uhttps://ieeexplore.ieee.org/document/9000032$$EView_record_in_IEEE$$FView_record_in_$$GIEEE</linktorsrc></links><search><creatorcontrib>Sung, Chungha</creatorcontrib><creatorcontrib>Lahiri, Shuvendu K.</creatorcontrib><creatorcontrib>Enea, Constantin</creatorcontrib><creatorcontrib>Wang, Chao</creatorcontrib><title>Datalog-based scalable semantic diffing of concurrent programs</title><title>2018 33rd IEEE/ACM International Conference on Automated Software Engineering (ASE)</title><addtitle>ASE</addtitle><description>When an evolving program is modified to address issues related to thread synchronization, there is a need to confirm the change is correct, i.e., it does not introduce unexpected behavior. However, manually comparing two programs to identify the semantic difference is labor intensive and error prone, whereas techniques based on model checking are computationally expensive. To fill the gap, we develop a fast and approximate static analysis for computing synchronization differences of two programs. The method is fast because, instead of relying on heavy-weight model checking techniques, it leverages a polynomial-time Datalog-based program analysis framework to compute differentiating data-flow edges, i.e., edges allowed by one program but not the other. Although approximation is used our method is sufficiently accurate due to careful design of the Datalog inference rules and iterative increase of the required data-flow edges for representing a difference. We have implemented our method and evaluated it on a large number of multithreaded C programs to confirm its ability to produce, often within seconds, the same differences obtained by human; in contrast, prior techniques based on model checking take minutes or even hours and thus can be 10x to 1000x slower.</description><subject>atomicity</subject><subject>change impact</subject><subject>Concurrency</subject><subject>Datalog</subject><subject>race condition</subject><subject>semantic diffing</subject><subject>Software and its engineering -- Software creation and management -- Software verification and validation</subject><subject>static analysis</subject><issn>2643-1572</issn><isbn>145035937X</isbn><isbn>9781450359375</isbn><isbn>145035937X</isbn><isbn>9781450359375</isbn><fulltext>true</fulltext><rsrctype>conference_proceeding</rsrctype><creationdate>2018</creationdate><recordtype>conference_proceeding</recordtype><sourceid>6IE</sourceid><recordid>eNqNkL1PwzAUxA0IiVI6M7BkZEl5tuM4XpBQ-ZQqsYDEZtkvz1UgH5UdBv57UrUDI9NJd7qT7sfYJYcl54W6kUJWvNDLnQrOj9j55IJURuqPYzYTZSFzrrQ4-RucsUVKnwAgKg1KqBm7vXeja4dN7l2iOkvoWudbyhJ1rh8bzOomhKbfZEPIcOjxO0bqx2wbh010Xbpgp8G1iRYHnbP3x4e31XO-fn16Wd2tcye0GnNeUxk8FqQATYll4YUHLLFCTRCQG12KCh2XIYBywdRFqAKAMqSl8Qhyzq72uw0R2W1sOhd_rJmewARgzpb71GFn_TB8JcvB7jDZAyZ7wGR9bChMhet_FuQv0Ehj7g</recordid><startdate>20180903</startdate><enddate>20180903</enddate><creator>Sung, Chungha</creator><creator>Lahiri, Shuvendu K.</creator><creator>Enea, Constantin</creator><creator>Wang, Chao</creator><general>ACM</general><scope>6IE</scope><scope>6IL</scope><scope>CBEJK</scope><scope>RIE</scope><scope>RIL</scope></search><sort><creationdate>20180903</creationdate><title>Datalog-based scalable semantic diffing of concurrent programs</title><author>Sung, Chungha ; Lahiri, Shuvendu K. ; Enea, Constantin ; Wang, Chao</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-a275t-1de6fbc4e50c96c64b2b0c6c8c7e0fc197628ca13ff05af9d4f8f0059e739bc03</frbrgroupid><rsrctype>conference_proceedings</rsrctype><prefilter>conference_proceedings</prefilter><language>eng</language><creationdate>2018</creationdate><topic>atomicity</topic><topic>change impact</topic><topic>Concurrency</topic><topic>Datalog</topic><topic>race condition</topic><topic>semantic diffing</topic><topic>Software and its engineering -- Software creation and management -- Software verification and validation</topic><topic>static analysis</topic><toplevel>online_resources</toplevel><creatorcontrib>Sung, Chungha</creatorcontrib><creatorcontrib>Lahiri, Shuvendu K.</creatorcontrib><creatorcontrib>Enea, Constantin</creatorcontrib><creatorcontrib>Wang, Chao</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>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>Sung, Chungha</au><au>Lahiri, Shuvendu K.</au><au>Enea, Constantin</au><au>Wang, Chao</au><format>book</format><genre>proceeding</genre><ristype>CONF</ristype><atitle>Datalog-based scalable semantic diffing of concurrent programs</atitle><btitle>2018 33rd IEEE/ACM International Conference on Automated Software Engineering (ASE)</btitle><stitle>ASE</stitle><date>2018-09-03</date><risdate>2018</risdate><spage>656</spage><epage>666</epage><pages>656-666</pages><eissn>2643-1572</eissn><isbn>145035937X</isbn><isbn>9781450359375</isbn><eisbn>145035937X</eisbn><eisbn>9781450359375</eisbn><abstract>When an evolving program is modified to address issues related to thread synchronization, there is a need to confirm the change is correct, i.e., it does not introduce unexpected behavior. However, manually comparing two programs to identify the semantic difference is labor intensive and error prone, whereas techniques based on model checking are computationally expensive. To fill the gap, we develop a fast and approximate static analysis for computing synchronization differences of two programs. The method is fast because, instead of relying on heavy-weight model checking techniques, it leverages a polynomial-time Datalog-based program analysis framework to compute differentiating data-flow edges, i.e., edges allowed by one program but not the other. Although approximation is used our method is sufficiently accurate due to careful design of the Datalog inference rules and iterative increase of the required data-flow edges for representing a difference. We have implemented our method and evaluated it on a large number of multithreaded C programs to confirm its ability to produce, often within seconds, the same differences obtained by human; in contrast, prior techniques based on model checking take minutes or even hours and thus can be 10x to 1000x slower.</abstract><cop>New York, NY, USA</cop><pub>ACM</pub><doi>10.1145/3238147.3238211</doi><tpages>11</tpages></addata></record>
fulltext fulltext_linktorsrc
identifier ISBN: 145035937X
ispartof 2018 33rd IEEE/ACM International Conference on Automated Software Engineering (ASE), 2018, p.656-666
issn 2643-1572
language eng
recordid cdi_ieee_primary_9000032
source IEEE Xplore All Conference Series
subjects atomicity
change impact
Concurrency
Datalog
race condition
semantic diffing
Software and its engineering -- Software creation and management -- Software verification and validation
static analysis
title Datalog-based scalable semantic diffing of concurrent programs
url http://sfxeu10.hosted.exlibrisgroup.com/loughborough?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-07T13%3A37%3A58IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-acm_CHZPO&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=proceeding&rft.atitle=Datalog-based%20scalable%20semantic%20diffing%20of%20concurrent%20programs&rft.btitle=2018%2033rd%20IEEE/ACM%20International%20Conference%20on%20Automated%20Software%20Engineering%20(ASE)&rft.au=Sung,%20Chungha&rft.date=2018-09-03&rft.spage=656&rft.epage=666&rft.pages=656-666&rft.eissn=2643-1572&rft.isbn=145035937X&rft.isbn_list=9781450359375&rft_id=info:doi/10.1145/3238147.3238211&rft.eisbn=145035937X&rft.eisbn_list=9781450359375&rft_dat=%3Cacm_CHZPO%3Eacm_books_10_1145_3238147_3238211%3C/acm_CHZPO%3E%3Cgrp_id%3Ecdi_FETCH-LOGICAL-a275t-1de6fbc4e50c96c64b2b0c6c8c7e0fc197628ca13ff05af9d4f8f0059e739bc03%3C/grp_id%3E%3Coa%3E%3C/oa%3E%3Curl%3E%3C/url%3E&rft_id=info:oai/&rft_id=info:pmid/&rft_ieee_id=9000032&rfr_iscdi=true