Competitive parallelism: getting your priorities right

Multi-threaded programs have traditionally fallen into one of two domains: cooperative and competitive. These two domains have traditionally remained mostly disjoint, with cooperative threading used for increasing throughput in compute-intensive applications such as scientific workloads and cooperat...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Veröffentlicht in:Proceedings of ACM on programming languages 2018-09, Vol.2 (ICFP), p.1-30, Article 95
Hauptverfasser: Muller, Stefan K., Acar, Umut A., Harper, Robert
Format: Artikel
Sprache:eng
Online-Zugang:Volltext
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page 30
container_issue ICFP
container_start_page 1
container_title Proceedings of ACM on programming languages
container_volume 2
creator Muller, Stefan K.
Acar, Umut A.
Harper, Robert
description Multi-threaded programs have traditionally fallen into one of two domains: cooperative and competitive. These two domains have traditionally remained mostly disjoint, with cooperative threading used for increasing throughput in compute-intensive applications such as scientific workloads and cooperative threading used for increasing responsiveness in interactive applications such as GUIs and games. As multicore hardware becomes increasingly mainstream, there is a need for bridging these two disjoint worlds, because many applications mix interaction and computation and would benefit from both cooperative and competitive threading. In this paper, we present techniques for programming and reasoning about parallel interactive applications that can use both cooperative and competitive threading. Our techniques enable the programmer to write rich parallel interactive programs by creating and synchronizing with threads as needed, and by assigning threads user-defined and partially ordered priorities. To ensure important responsiveness properties, we present a modal type system analogous to S4 modal logic that precludes low-priority threads from delaying high-priority threads, thereby statically preventing a crucial set of priority-inversion bugs. We then present a cost model that allows reasoning about responsiveness and completion time of well-typed programs. The cost model extends the traditional work-span model for cooperative threading to account for competitive scheduling decisions needed to ensure responsiveness. Finally, we show that our proposed techniques are realistic by implementing them as an extension to the Standard ML language.
doi_str_mv 10.1145/3236790
format Article
fullrecord <record><control><sourceid>crossref</sourceid><recordid>TN_cdi_crossref_primary_10_1145_3236790</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>10_1145_3236790</sourcerecordid><originalsourceid>FETCH-LOGICAL-c258t-82d2d570aa027a3640105f55f3e5655d0d9461c8767d0fbcb44cd63ba745a8623</originalsourceid><addsrcrecordid>eNplj8tKxEAURBtRcBgHfyE7V9Hb78SdBHWEATe6Djf9iC3JJHS3wvy9EWchuqpaHIo6hFxSuKZUyBvOuNI1nJAVE1qWVDB6-qufk01K7wBAay4qXq-IaqZxdjnk8OmKGSMOgxtCGm-L3uUc9n1xmD5iMccwxQVyqYihf8sX5MzjkNzmmGvy-nD_0mzL3fPjU3O3Kw2TVS4rZpmVGhCBaeRKAAXppfTcSSWlBVsLRU2llbbgO9MJYaziHWohsVKMr8nVz66JU0rR-XZ5MmI8tBTab-P2aLyQ5R_ShIw5TPscMQz_-C9e4VYD</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype></control><display><type>article</type><title>Competitive parallelism: getting your priorities right</title><source>ACM Digital Library Complete</source><source>Elektronische Zeitschriftenbibliothek - Frei zugängliche E-Journals</source><creator>Muller, Stefan K. ; Acar, Umut A. ; Harper, Robert</creator><creatorcontrib>Muller, Stefan K. ; Acar, Umut A. ; Harper, Robert</creatorcontrib><description>Multi-threaded programs have traditionally fallen into one of two domains: cooperative and competitive. These two domains have traditionally remained mostly disjoint, with cooperative threading used for increasing throughput in compute-intensive applications such as scientific workloads and cooperative threading used for increasing responsiveness in interactive applications such as GUIs and games. As multicore hardware becomes increasingly mainstream, there is a need for bridging these two disjoint worlds, because many applications mix interaction and computation and would benefit from both cooperative and competitive threading. In this paper, we present techniques for programming and reasoning about parallel interactive applications that can use both cooperative and competitive threading. Our techniques enable the programmer to write rich parallel interactive programs by creating and synchronizing with threads as needed, and by assigning threads user-defined and partially ordered priorities. To ensure important responsiveness properties, we present a modal type system analogous to S4 modal logic that precludes low-priority threads from delaying high-priority threads, thereby statically preventing a crucial set of priority-inversion bugs. We then present a cost model that allows reasoning about responsiveness and completion time of well-typed programs. The cost model extends the traditional work-span model for cooperative threading to account for competitive scheduling decisions needed to ensure responsiveness. Finally, we show that our proposed techniques are realistic by implementing them as an extension to the Standard ML language.</description><identifier>ISSN: 2475-1421</identifier><identifier>EISSN: 2475-1421</identifier><identifier>DOI: 10.1145/3236790</identifier><language>eng</language><ispartof>Proceedings of ACM on programming languages, 2018-09, Vol.2 (ICFP), p.1-30, Article 95</ispartof><lds50>peer_reviewed</lds50><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed><citedby>FETCH-LOGICAL-c258t-82d2d570aa027a3640105f55f3e5655d0d9461c8767d0fbcb44cd63ba745a8623</citedby><cites>FETCH-LOGICAL-c258t-82d2d570aa027a3640105f55f3e5655d0d9461c8767d0fbcb44cd63ba745a8623</cites></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>314,776,780,27901,27902</link.rule.ids></links><search><creatorcontrib>Muller, Stefan K.</creatorcontrib><creatorcontrib>Acar, Umut A.</creatorcontrib><creatorcontrib>Harper, Robert</creatorcontrib><title>Competitive parallelism: getting your priorities right</title><title>Proceedings of ACM on programming languages</title><description>Multi-threaded programs have traditionally fallen into one of two domains: cooperative and competitive. These two domains have traditionally remained mostly disjoint, with cooperative threading used for increasing throughput in compute-intensive applications such as scientific workloads and cooperative threading used for increasing responsiveness in interactive applications such as GUIs and games. As multicore hardware becomes increasingly mainstream, there is a need for bridging these two disjoint worlds, because many applications mix interaction and computation and would benefit from both cooperative and competitive threading. In this paper, we present techniques for programming and reasoning about parallel interactive applications that can use both cooperative and competitive threading. Our techniques enable the programmer to write rich parallel interactive programs by creating and synchronizing with threads as needed, and by assigning threads user-defined and partially ordered priorities. To ensure important responsiveness properties, we present a modal type system analogous to S4 modal logic that precludes low-priority threads from delaying high-priority threads, thereby statically preventing a crucial set of priority-inversion bugs. We then present a cost model that allows reasoning about responsiveness and completion time of well-typed programs. The cost model extends the traditional work-span model for cooperative threading to account for competitive scheduling decisions needed to ensure responsiveness. Finally, we show that our proposed techniques are realistic by implementing them as an extension to the Standard ML language.</description><issn>2475-1421</issn><issn>2475-1421</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2018</creationdate><recordtype>article</recordtype><recordid>eNplj8tKxEAURBtRcBgHfyE7V9Hb78SdBHWEATe6Djf9iC3JJHS3wvy9EWchuqpaHIo6hFxSuKZUyBvOuNI1nJAVE1qWVDB6-qufk01K7wBAay4qXq-IaqZxdjnk8OmKGSMOgxtCGm-L3uUc9n1xmD5iMccwxQVyqYihf8sX5MzjkNzmmGvy-nD_0mzL3fPjU3O3Kw2TVS4rZpmVGhCBaeRKAAXppfTcSSWlBVsLRU2llbbgO9MJYaziHWohsVKMr8nVz66JU0rR-XZ5MmI8tBTab-P2aLyQ5R_ShIw5TPscMQz_-C9e4VYD</recordid><startdate>20180901</startdate><enddate>20180901</enddate><creator>Muller, Stefan K.</creator><creator>Acar, Umut A.</creator><creator>Harper, Robert</creator><scope>AAYXX</scope><scope>CITATION</scope></search><sort><creationdate>20180901</creationdate><title>Competitive parallelism: getting your priorities right</title><author>Muller, Stefan K. ; Acar, Umut A. ; Harper, Robert</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c258t-82d2d570aa027a3640105f55f3e5655d0d9461c8767d0fbcb44cd63ba745a8623</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2018</creationdate><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>Muller, Stefan K.</creatorcontrib><creatorcontrib>Acar, Umut A.</creatorcontrib><creatorcontrib>Harper, Robert</creatorcontrib><collection>CrossRef</collection><jtitle>Proceedings of ACM on programming languages</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Muller, Stefan K.</au><au>Acar, Umut A.</au><au>Harper, Robert</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Competitive parallelism: getting your priorities right</atitle><jtitle>Proceedings of ACM on programming languages</jtitle><date>2018-09-01</date><risdate>2018</risdate><volume>2</volume><issue>ICFP</issue><spage>1</spage><epage>30</epage><pages>1-30</pages><artnum>95</artnum><issn>2475-1421</issn><eissn>2475-1421</eissn><abstract>Multi-threaded programs have traditionally fallen into one of two domains: cooperative and competitive. These two domains have traditionally remained mostly disjoint, with cooperative threading used for increasing throughput in compute-intensive applications such as scientific workloads and cooperative threading used for increasing responsiveness in interactive applications such as GUIs and games. As multicore hardware becomes increasingly mainstream, there is a need for bridging these two disjoint worlds, because many applications mix interaction and computation and would benefit from both cooperative and competitive threading. In this paper, we present techniques for programming and reasoning about parallel interactive applications that can use both cooperative and competitive threading. Our techniques enable the programmer to write rich parallel interactive programs by creating and synchronizing with threads as needed, and by assigning threads user-defined and partially ordered priorities. To ensure important responsiveness properties, we present a modal type system analogous to S4 modal logic that precludes low-priority threads from delaying high-priority threads, thereby statically preventing a crucial set of priority-inversion bugs. We then present a cost model that allows reasoning about responsiveness and completion time of well-typed programs. The cost model extends the traditional work-span model for cooperative threading to account for competitive scheduling decisions needed to ensure responsiveness. Finally, we show that our proposed techniques are realistic by implementing them as an extension to the Standard ML language.</abstract><doi>10.1145/3236790</doi><tpages>30</tpages><oa>free_for_read</oa></addata></record>
fulltext fulltext
identifier ISSN: 2475-1421
ispartof Proceedings of ACM on programming languages, 2018-09, Vol.2 (ICFP), p.1-30, Article 95
issn 2475-1421
2475-1421
language eng
recordid cdi_crossref_primary_10_1145_3236790
source ACM Digital Library Complete; Elektronische Zeitschriftenbibliothek - Frei zugängliche E-Journals
title Competitive parallelism: getting your priorities right
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-02-02T04%3A40%3A56IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-crossref&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=Competitive%20parallelism:%20getting%20your%20priorities%20right&rft.jtitle=Proceedings%20of%20ACM%20on%20programming%20languages&rft.au=Muller,%20Stefan%20K.&rft.date=2018-09-01&rft.volume=2&rft.issue=ICFP&rft.spage=1&rft.epage=30&rft.pages=1-30&rft.artnum=95&rft.issn=2475-1421&rft.eissn=2475-1421&rft_id=info:doi/10.1145/3236790&rft_dat=%3Ccrossref%3E10_1145_3236790%3C/crossref%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