Regular, shape-polymorphic, parallel arrays in Haskell
We present a novel approach to regular, multi-dimensional arrays in Haskell. The main highlights of our approach are that it (1) is purely functional, (2) supports reuse through shape polymorphism, (3) avoids unnecessary intermediate structures rather than relying on subsequent loop fusion, and (4)...
Gespeichert in:
Veröffentlicht in: | SIGPLAN notices 2010-09, Vol.45 (9), p.261-272 |
---|---|
Hauptverfasser: | , , , , |
Format: | Artikel |
Sprache: | eng |
Online-Zugang: | Volltext |
Tags: |
Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
|
container_end_page | 272 |
---|---|
container_issue | 9 |
container_start_page | 261 |
container_title | SIGPLAN notices |
container_volume | 45 |
creator | Keller, Gabriele Chakravarty, Manuel M.T. Leshchinskiy, Roman Peyton Jones, Simon Lippmeier, Ben |
description | We present a novel approach to regular, multi-dimensional arrays in Haskell. The main highlights of our approach are that it (1) is purely functional, (2) supports reuse through shape polymorphism, (3) avoids unnecessary intermediate structures rather than relying on subsequent loop fusion, and (4) supports transparent parallelisation.
We show how to embed two forms of shape polymorphism into Haskell's type system using type classes and type families. In particular, we discuss the generalisation of regular array transformations to arrays of higher rank, and introduce a type-safe specification of array slices.
We discuss the runtime performance of our approach for three standard array algorithms. We achieve absolute performance comparable to handwritten C code. At the same time, our implementation scales well up to 8 processor cores. |
doi_str_mv | 10.1145/1932681.1863582 |
format | Article |
fullrecord | <record><control><sourceid>crossref</sourceid><recordid>TN_cdi_crossref_primary_10_1145_1932681_1863582</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>10_1145_1932681_1863582</sourcerecordid><originalsourceid>FETCH-LOGICAL-c271t-deea934392b46bfaeb6f27f80d2131c5870203f4558f2f48d8431a525638d6983</originalsourceid><addsrcrecordid>eNotz7FOwzAUhWELgUQpzKx5gLq919d2nBFVQJEqISGYo5vEpgGXRDYMeXtAzXS2X-cT4hZhjajNBitS1uEanSXj1JlYoDFOIlo4FwsgqySShktxlfMHABAotxD2xb__RE6rIh949HIc4nQc0njo21UxcuIYfSw4JZ5y0X8VO86fPsZrcRE4Zn8z71K8Pdy_bndy__z4tL3by1aV-C0777kiTZVqtG0C-8YGVQYHnULC1rgSFFDQf0eDCtp1ThOyUcaS62zlaCk2p26bhpyTD_WY-iOnqUao_9n1zK5nNv0CVwpI2A</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype></control><display><type>article</type><title>Regular, shape-polymorphic, parallel arrays in Haskell</title><source>ACM Digital Library</source><creator>Keller, Gabriele ; Chakravarty, Manuel M.T. ; Leshchinskiy, Roman ; Peyton Jones, Simon ; Lippmeier, Ben</creator><creatorcontrib>Keller, Gabriele ; Chakravarty, Manuel M.T. ; Leshchinskiy, Roman ; Peyton Jones, Simon ; Lippmeier, Ben</creatorcontrib><description>We present a novel approach to regular, multi-dimensional arrays in Haskell. The main highlights of our approach are that it (1) is purely functional, (2) supports reuse through shape polymorphism, (3) avoids unnecessary intermediate structures rather than relying on subsequent loop fusion, and (4) supports transparent parallelisation.
We show how to embed two forms of shape polymorphism into Haskell's type system using type classes and type families. In particular, we discuss the generalisation of regular array transformations to arrays of higher rank, and introduce a type-safe specification of array slices.
We discuss the runtime performance of our approach for three standard array algorithms. We achieve absolute performance comparable to handwritten C code. At the same time, our implementation scales well up to 8 processor cores.</description><identifier>ISSN: 0362-1340</identifier><identifier>EISSN: 1558-1160</identifier><identifier>DOI: 10.1145/1932681.1863582</identifier><language>eng</language><ispartof>SIGPLAN notices, 2010-09, Vol.45 (9), p.261-272</ispartof><woscitedreferencessubscribed>false</woscitedreferencessubscribed><citedby>FETCH-LOGICAL-c271t-deea934392b46bfaeb6f27f80d2131c5870203f4558f2f48d8431a525638d6983</citedby><cites>FETCH-LOGICAL-c271t-deea934392b46bfaeb6f27f80d2131c5870203f4558f2f48d8431a525638d6983</cites></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>315,781,785,27929,27930</link.rule.ids></links><search><creatorcontrib>Keller, Gabriele</creatorcontrib><creatorcontrib>Chakravarty, Manuel M.T.</creatorcontrib><creatorcontrib>Leshchinskiy, Roman</creatorcontrib><creatorcontrib>Peyton Jones, Simon</creatorcontrib><creatorcontrib>Lippmeier, Ben</creatorcontrib><title>Regular, shape-polymorphic, parallel arrays in Haskell</title><title>SIGPLAN notices</title><description>We present a novel approach to regular, multi-dimensional arrays in Haskell. The main highlights of our approach are that it (1) is purely functional, (2) supports reuse through shape polymorphism, (3) avoids unnecessary intermediate structures rather than relying on subsequent loop fusion, and (4) supports transparent parallelisation.
We show how to embed two forms of shape polymorphism into Haskell's type system using type classes and type families. In particular, we discuss the generalisation of regular array transformations to arrays of higher rank, and introduce a type-safe specification of array slices.
We discuss the runtime performance of our approach for three standard array algorithms. We achieve absolute performance comparable to handwritten C code. At the same time, our implementation scales well up to 8 processor cores.</description><issn>0362-1340</issn><issn>1558-1160</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2010</creationdate><recordtype>article</recordtype><recordid>eNotz7FOwzAUhWELgUQpzKx5gLq919d2nBFVQJEqISGYo5vEpgGXRDYMeXtAzXS2X-cT4hZhjajNBitS1uEanSXj1JlYoDFOIlo4FwsgqySShktxlfMHABAotxD2xb__RE6rIh949HIc4nQc0njo21UxcuIYfSw4JZ5y0X8VO86fPsZrcRE4Zn8z71K8Pdy_bndy__z4tL3by1aV-C0777kiTZVqtG0C-8YGVQYHnULC1rgSFFDQf0eDCtp1ThOyUcaS62zlaCk2p26bhpyTD_WY-iOnqUao_9n1zK5nNv0CVwpI2A</recordid><startdate>20100901</startdate><enddate>20100901</enddate><creator>Keller, Gabriele</creator><creator>Chakravarty, Manuel M.T.</creator><creator>Leshchinskiy, Roman</creator><creator>Peyton Jones, Simon</creator><creator>Lippmeier, Ben</creator><scope>AAYXX</scope><scope>CITATION</scope></search><sort><creationdate>20100901</creationdate><title>Regular, shape-polymorphic, parallel arrays in Haskell</title><author>Keller, Gabriele ; Chakravarty, Manuel M.T. ; Leshchinskiy, Roman ; Peyton Jones, Simon ; Lippmeier, Ben</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c271t-deea934392b46bfaeb6f27f80d2131c5870203f4558f2f48d8431a525638d6983</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2010</creationdate><toplevel>online_resources</toplevel><creatorcontrib>Keller, Gabriele</creatorcontrib><creatorcontrib>Chakravarty, Manuel M.T.</creatorcontrib><creatorcontrib>Leshchinskiy, Roman</creatorcontrib><creatorcontrib>Peyton Jones, Simon</creatorcontrib><creatorcontrib>Lippmeier, Ben</creatorcontrib><collection>CrossRef</collection><jtitle>SIGPLAN notices</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Keller, Gabriele</au><au>Chakravarty, Manuel M.T.</au><au>Leshchinskiy, Roman</au><au>Peyton Jones, Simon</au><au>Lippmeier, Ben</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Regular, shape-polymorphic, parallel arrays in Haskell</atitle><jtitle>SIGPLAN notices</jtitle><date>2010-09-01</date><risdate>2010</risdate><volume>45</volume><issue>9</issue><spage>261</spage><epage>272</epage><pages>261-272</pages><issn>0362-1340</issn><eissn>1558-1160</eissn><abstract>We present a novel approach to regular, multi-dimensional arrays in Haskell. The main highlights of our approach are that it (1) is purely functional, (2) supports reuse through shape polymorphism, (3) avoids unnecessary intermediate structures rather than relying on subsequent loop fusion, and (4) supports transparent parallelisation.
We show how to embed two forms of shape polymorphism into Haskell's type system using type classes and type families. In particular, we discuss the generalisation of regular array transformations to arrays of higher rank, and introduce a type-safe specification of array slices.
We discuss the runtime performance of our approach for three standard array algorithms. We achieve absolute performance comparable to handwritten C code. At the same time, our implementation scales well up to 8 processor cores.</abstract><doi>10.1145/1932681.1863582</doi><tpages>12</tpages></addata></record> |
fulltext | fulltext |
identifier | ISSN: 0362-1340 |
ispartof | SIGPLAN notices, 2010-09, Vol.45 (9), p.261-272 |
issn | 0362-1340 1558-1160 |
language | eng |
recordid | cdi_crossref_primary_10_1145_1932681_1863582 |
source | ACM Digital Library |
title | Regular, shape-polymorphic, parallel arrays in Haskell |
url | https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2024-12-14T08%3A10%3A10IST&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=Regular,%20shape-polymorphic,%20parallel%20arrays%20in%20Haskell&rft.jtitle=SIGPLAN%20notices&rft.au=Keller,%20Gabriele&rft.date=2010-09-01&rft.volume=45&rft.issue=9&rft.spage=261&rft.epage=272&rft.pages=261-272&rft.issn=0362-1340&rft.eissn=1558-1160&rft_id=info:doi/10.1145/1932681.1863582&rft_dat=%3Ccrossref%3E10_1145_1932681_1863582%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 |