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)...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Veröffentlicht in:SIGPLAN notices 2010-09, Vol.45 (9), p.261-272
Hauptverfasser: Keller, Gabriele, Chakravarty, Manuel M.T., Leshchinskiy, Roman, Peyton Jones, Simon, Lippmeier, Ben
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