A type based sharing analysis for update avoidance and optimisation

Sharing of evaluation is crucial for the efficiency of lazy functional languages, but unfortunately the machinery to implement it carries an inherent overhead. In abstract machines this overhead shows up as the cost of performing updates, many of them actually unnecessary, and also in the cost of th...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Veröffentlicht in:ICFP 98: ICFP: International Conference on Functional Programming and Its Extension 1999, Vol.34 (1), p.39-50
1. Verfasser: GUSTAVSSON, J
Format: Artikel
Sprache:eng
Schlagworte:
Online-Zugang:Volltext
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page 50
container_issue 1
container_start_page 39
container_title ICFP 98: ICFP: International Conference on Functional Programming and Its Extension
container_volume 34
creator GUSTAVSSON, J
description Sharing of evaluation is crucial for the efficiency of lazy functional languages, but unfortunately the machinery to implement it carries an inherent overhead. In abstract machines this overhead shows up as the cost of performing updates, many of them actually unnecessary, and also in the cost of the associated bookkeeping, that is keeping track of when and where to update. In spineless abstract machines, such as the STG-machine and the TIM, this bookkeeping consists of pushing, checking for and popping update markers. Checking for update markers is a very frequent operation and indeed the implementation of the STG-machine has been optimised for fast update marker checks at the expense of making the pushing and popping of update markers more costly.In this paper we present a type based sharing analysis that can determine when updates can be safely omitted and marker checks bypassed. The type system is proved sound with respect to the lazy Krivine machine. We have implemented the analysis and the preliminary benchmarks seem very promising. Most notably, virtually all update marker checks can be avoided. This may make the tradeoffs of current implementations obsolete and calls for new abstract machine designs.
doi_str_mv 10.1145/291251.289427
format Article
fullrecord <record><control><sourceid>proquest_cross</sourceid><recordid>TN_cdi_crossref_primary_10_1145_291251_289427</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>29524639</sourcerecordid><originalsourceid>FETCH-LOGICAL-c336t-652922f893f46ef1920956e9bd94f7d9e625d88daab175c94a941a3154216ca63</originalsourceid><addsrcrecordid>eNpFkMtPwzAMhyMeEmPsyD0HxK0jdh5NjmjiJU3iAufKaxIo6tqSdEj77ynaJE625M8_2R9j1yCWAErfoQPUsETrFJYnbAZa2wLAiFO2cKUFbQGkQOXO2ExIgwVIJS7YZc5fQohpYmdsdc_H_RD4hnLwPH9SaroPTh21-9xkHvvEd4OnMXD66RtPXT11nef9MDbbJtPY9N0VO4_U5rA41jl7f3x4Wz0X69enl9X9uqilNGNhNDrEaJ2MyoQIDoXTJriNdyqW3gWD2lvriTZQ6topcgpIglYIpiYj5-z2kDuk_nsX8lhNF9ShbakL_S5X6DQqI90EFgewTn3OKcRqSM2W0r4CUf2pqw7qqoO6ib85BlOuqY1perPJ_0vGIKKQv0dCaac</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype><pqid>29524639</pqid></control><display><type>article</type><title>A type based sharing analysis for update avoidance and optimisation</title><source>ACM Digital Library</source><creator>GUSTAVSSON, J</creator><creatorcontrib>GUSTAVSSON, J</creatorcontrib><description>Sharing of evaluation is crucial for the efficiency of lazy functional languages, but unfortunately the machinery to implement it carries an inherent overhead. In abstract machines this overhead shows up as the cost of performing updates, many of them actually unnecessary, and also in the cost of the associated bookkeeping, that is keeping track of when and where to update. In spineless abstract machines, such as the STG-machine and the TIM, this bookkeeping consists of pushing, checking for and popping update markers. Checking for update markers is a very frequent operation and indeed the implementation of the STG-machine has been optimised for fast update marker checks at the expense of making the pushing and popping of update markers more costly.In this paper we present a type based sharing analysis that can determine when updates can be safely omitted and marker checks bypassed. The type system is proved sound with respect to the lazy Krivine machine. We have implemented the analysis and the preliminary benchmarks seem very promising. Most notably, virtually all update marker checks can be avoided. This may make the tradeoffs of current implementations obsolete and calls for new abstract machine designs.</description><identifier>ISSN: 0362-1340</identifier><identifier>ISBN: 9781581130249</identifier><identifier>ISBN: 1581130244</identifier><identifier>EISSN: 1558-1160</identifier><identifier>DOI: 10.1145/291251.289427</identifier><language>eng</language><publisher>New York, NY: Association for Computing Machinery, Special Interest Group on Programming Languages</publisher><subject>Applied sciences ; Automata. Abstract machines. Turing machines ; Computer science; control theory; systems ; Exact sciences and technology ; Language theory and syntactical analysis ; Software ; Software engineering ; Theoretical computing</subject><ispartof>ICFP 98: ICFP: International Conference on Functional Programming and Its Extension, 1999, Vol.34 (1), p.39-50</ispartof><rights>1999 INIST-CNRS</rights><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed><citedby>FETCH-LOGICAL-c336t-652922f893f46ef1920956e9bd94f7d9e625d88daab175c94a941a3154216ca63</citedby><cites>FETCH-LOGICAL-c336t-652922f893f46ef1920956e9bd94f7d9e625d88daab175c94a941a3154216ca63</cites></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>309,310,314,776,780,785,786,4035,4036,23910,23911,25119,27903,27904</link.rule.ids><backlink>$$Uhttp://pascal-francis.inist.fr/vibad/index.php?action=getRecordDetail&amp;idt=1662220$$DView record in Pascal Francis$$Hfree_for_read</backlink></links><search><creatorcontrib>GUSTAVSSON, J</creatorcontrib><title>A type based sharing analysis for update avoidance and optimisation</title><title>ICFP 98: ICFP: International Conference on Functional Programming and Its Extension</title><description>Sharing of evaluation is crucial for the efficiency of lazy functional languages, but unfortunately the machinery to implement it carries an inherent overhead. In abstract machines this overhead shows up as the cost of performing updates, many of them actually unnecessary, and also in the cost of the associated bookkeeping, that is keeping track of when and where to update. In spineless abstract machines, such as the STG-machine and the TIM, this bookkeeping consists of pushing, checking for and popping update markers. Checking for update markers is a very frequent operation and indeed the implementation of the STG-machine has been optimised for fast update marker checks at the expense of making the pushing and popping of update markers more costly.In this paper we present a type based sharing analysis that can determine when updates can be safely omitted and marker checks bypassed. The type system is proved sound with respect to the lazy Krivine machine. We have implemented the analysis and the preliminary benchmarks seem very promising. Most notably, virtually all update marker checks can be avoided. This may make the tradeoffs of current implementations obsolete and calls for new abstract machine designs.</description><subject>Applied sciences</subject><subject>Automata. Abstract machines. Turing machines</subject><subject>Computer science; control theory; systems</subject><subject>Exact sciences and technology</subject><subject>Language theory and syntactical analysis</subject><subject>Software</subject><subject>Software engineering</subject><subject>Theoretical computing</subject><issn>0362-1340</issn><issn>1558-1160</issn><isbn>9781581130249</isbn><isbn>1581130244</isbn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>1999</creationdate><recordtype>article</recordtype><recordid>eNpFkMtPwzAMhyMeEmPsyD0HxK0jdh5NjmjiJU3iAufKaxIo6tqSdEj77ynaJE625M8_2R9j1yCWAErfoQPUsETrFJYnbAZa2wLAiFO2cKUFbQGkQOXO2ExIgwVIJS7YZc5fQohpYmdsdc_H_RD4hnLwPH9SaroPTh21-9xkHvvEd4OnMXD66RtPXT11nef9MDbbJtPY9N0VO4_U5rA41jl7f3x4Wz0X69enl9X9uqilNGNhNDrEaJ2MyoQIDoXTJriNdyqW3gWD2lvriTZQ6topcgpIglYIpiYj5-z2kDuk_nsX8lhNF9ShbakL_S5X6DQqI90EFgewTn3OKcRqSM2W0r4CUf2pqw7qqoO6ib85BlOuqY1perPJ_0vGIKKQv0dCaac</recordid><startdate>1999</startdate><enddate>1999</enddate><creator>GUSTAVSSON, J</creator><general>Association for Computing Machinery, Special Interest Group on Programming Languages</general><scope>IQODW</scope><scope>AAYXX</scope><scope>CITATION</scope><scope>7SC</scope><scope>8FD</scope><scope>JQ2</scope><scope>L7M</scope><scope>L~C</scope><scope>L~D</scope></search><sort><creationdate>1999</creationdate><title>A type based sharing analysis for update avoidance and optimisation</title><author>GUSTAVSSON, J</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c336t-652922f893f46ef1920956e9bd94f7d9e625d88daab175c94a941a3154216ca63</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>1999</creationdate><topic>Applied sciences</topic><topic>Automata. Abstract machines. Turing machines</topic><topic>Computer science; control theory; systems</topic><topic>Exact sciences and technology</topic><topic>Language theory and syntactical analysis</topic><topic>Software</topic><topic>Software engineering</topic><topic>Theoretical computing</topic><toplevel>online_resources</toplevel><creatorcontrib>GUSTAVSSON, J</creatorcontrib><collection>Pascal-Francis</collection><collection>CrossRef</collection><collection>Computer and Information Systems Abstracts</collection><collection>Technology Research Database</collection><collection>ProQuest Computer Science Collection</collection><collection>Advanced Technologies Database with Aerospace</collection><collection>Computer and Information Systems Abstracts – Academic</collection><collection>Computer and Information Systems Abstracts Professional</collection><jtitle>ICFP 98: ICFP: International Conference on Functional Programming and Its Extension</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>GUSTAVSSON, J</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>A type based sharing analysis for update avoidance and optimisation</atitle><jtitle>ICFP 98: ICFP: International Conference on Functional Programming and Its Extension</jtitle><date>1999</date><risdate>1999</risdate><volume>34</volume><issue>1</issue><spage>39</spage><epage>50</epage><pages>39-50</pages><issn>0362-1340</issn><eissn>1558-1160</eissn><isbn>9781581130249</isbn><isbn>1581130244</isbn><abstract>Sharing of evaluation is crucial for the efficiency of lazy functional languages, but unfortunately the machinery to implement it carries an inherent overhead. In abstract machines this overhead shows up as the cost of performing updates, many of them actually unnecessary, and also in the cost of the associated bookkeeping, that is keeping track of when and where to update. In spineless abstract machines, such as the STG-machine and the TIM, this bookkeeping consists of pushing, checking for and popping update markers. Checking for update markers is a very frequent operation and indeed the implementation of the STG-machine has been optimised for fast update marker checks at the expense of making the pushing and popping of update markers more costly.In this paper we present a type based sharing analysis that can determine when updates can be safely omitted and marker checks bypassed. The type system is proved sound with respect to the lazy Krivine machine. We have implemented the analysis and the preliminary benchmarks seem very promising. Most notably, virtually all update marker checks can be avoided. This may make the tradeoffs of current implementations obsolete and calls for new abstract machine designs.</abstract><cop>New York, NY</cop><pub>Association for Computing Machinery, Special Interest Group on Programming Languages</pub><doi>10.1145/291251.289427</doi><tpages>12</tpages><oa>free_for_read</oa></addata></record>
fulltext fulltext
identifier ISSN: 0362-1340
ispartof ICFP 98: ICFP: International Conference on Functional Programming and Its Extension, 1999, Vol.34 (1), p.39-50
issn 0362-1340
1558-1160
language eng
recordid cdi_crossref_primary_10_1145_291251_289427
source ACM Digital Library
subjects Applied sciences
Automata. Abstract machines. Turing machines
Computer science
control theory
systems
Exact sciences and technology
Language theory and syntactical analysis
Software
Software engineering
Theoretical computing
title A type based sharing analysis for update avoidance and optimisation
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-24T20%3A22%3A16IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_cross&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=A%20type%20based%20sharing%20analysis%20for%20update%20avoidance%20and%20optimisation&rft.jtitle=ICFP%2098:%20ICFP:%20International%20Conference%20on%20Functional%20Programming%20and%20Its%20Extension&rft.au=GUSTAVSSON,%20J&rft.date=1999&rft.volume=34&rft.issue=1&rft.spage=39&rft.epage=50&rft.pages=39-50&rft.issn=0362-1340&rft.eissn=1558-1160&rft.isbn=9781581130249&rft.isbn_list=1581130244&rft_id=info:doi/10.1145/291251.289427&rft_dat=%3Cproquest_cross%3E29524639%3C/proquest_cross%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_pqid=29524639&rft_id=info:pmid/&rfr_iscdi=true