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...
Gespeichert in:
Veröffentlicht in: | ICFP 98: ICFP: International Conference on Functional Programming and Its Extension 1999, Vol.34 (1), p.39-50 |
---|---|
1. Verfasser: | |
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&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 |