Execution of dataflow process networks on OpenCL platforms

Wictor Lund; Sudeep Kanur Chandra Shekar; Johan Ersfolk; Leonidas Tsiopoulos; Johan Lilius; Joakim Haldin; Ulf Falk

doi:10.1109/PDP.2015.29

Execution of dataflow process networks on OpenCL platforms

Wictor Lund, Sudeep Kanur Chandra Shekar, Johan Ersfolk, Leonidas Tsiopoulos, Johan Lilius, Joakim Haldin, Ulf Falk

Information Technology

Tutkimustuotos: Artikkeli kirjassa/raportissa/konferenssijulkaisussa › Konferenssiartikkeli › Tieteellinen › vertaisarvioitu

22 Sitaatiot (Scopus)

Abstrakti

The trend in computing systems is to combine various kinds of processing elements (PEs) to build more parallel architectures. This trend leads to more heterogeneous computing systems, for which abstractions are needed to efficiently program the systems without increasing the programming cost. This has lead to new programming languages and application program- ming interfaces (APIs). Parallel programming has always been a holy grail in computer science and dataflow programming promises a way to automatically provide parallel constructs for the programmer. This paper provides an approach to translate dataflow process networks (DPNs) into programs running some of the computations on the Open Computing Language (OpenCL) platform, supporting running programs on massively parallel hardware such as graphics processing units (GPUs). We show that certain DPN programs could run very efficiently on data- parallel architectures but also that there are certain patterns in DPN programs that prove problematic.

The trend in computing systems is to combine various kinds of processing elements (PEs) to build more parallel architectures. This trend leads to more heterogeneous computing systems, for which abstractions are needed to efficiently program the systems without increasing the programming cost. This has lead to new programming languages and application programming interfaces (APIs). Parallel programming has always been a holy grail in computer science and dataflow programming promises a way to automatically provide parallel constructs for the programmer. This paper provides an approach to translate dataflow process networks (DPNs) into programs running some of the computations on the Open Computing Language (OpenCL) platform, supporting running programs on massively parallel hardware such as graphics processing units (GPUs). We show that certain DPN programs could run very efficiently on dataparallel architectures but also that there are certain patterns in DPN programs that prove problematic.

Alkuperäiskieli	Ei tiedossa
Otsikko	Parallel, Distributed and Network-Based Processing (PDP), 2015 23rd Euromicro International Conference on
Toimittajat	Masoud Daneshtalab, Marco Aldinucci, Ville Leppänen, Johan Lilius, Mats Brorsson
Kustantaja	IEEE
Sivut	618–625
ISBN (painettu)	978-1-4799-8492-3
DOI - pysyväislinkit	https://doi.org/10.1109/PDP.2015.29
Tila	Julkaistu - 2015
OKM-julkaisutyyppi	A4 Artikkeli konferenssijulkaisuussa
Tapahtuma	Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP) - 23rd Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP 2015) Kesto: 4 maalisk. 2015 → 6 maalisk. 2015

Konferenssi

Konferenssi	Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP)
Ajanjakso	04/03/15 → 06/03/15

Pääsy asiakirjaan

10.1109/PDP.2015.29

http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=7092784

Viittausmuodot

Lund, W., Kanur Chandra Shekar, S., Ersfolk, J., Tsiopoulos, L., Lilius, J., Haldin, J., & Falk, U. (2015). Execution of dataflow process networks on OpenCL platforms. teoksessa M. Daneshtalab, M. Aldinucci, V. Leppänen, J. Lilius, & M. Brorsson (Toimittajat), Parallel, Distributed and Network-Based Processing (PDP), 2015 23rd Euromicro International Conference on (Sivut 618–625). IEEE. https://doi.org/10.1109/PDP.2015.29

@inproceedings{1ade362d9d4d4a68941f11f71b53fe8f,

title = "Execution of dataflow process networks on OpenCL platforms",

abstract = "The trend in computing systems is to combine various kinds of processing elements (PEs) to build more parallel architectures. This trend leads to more heterogeneous computing systems, for which abstractions are needed to efficiently program the systems without increasing the programming cost. This has lead to new programming languages and application program- ming interfaces (APIs). Parallel programming has always been a holy grail in computer science and dataflow programming promises a way to automatically provide parallel constructs for the programmer. This paper provides an approach to translate dataflow process networks (DPNs) into programs running some of the computations on the Open Computing Language (OpenCL) platform, supporting running programs on massively parallel hardware such as graphics processing units (GPUs). We show that certain DPN programs could run very efficiently on data- parallel architectures but also that there are certain patterns in DPN programs that prove problematic. The trend in computing systems is to combine various kinds of processing elements (PEs) to build more parallel architectures. This trend leads to more heterogeneous computing systems, for which abstractions are needed to efficiently program the systems without increasing the programming cost. This has lead to new programming languages and application programming interfaces (APIs). Parallel programming has always been a holy grail in computer science and dataflow programming promises a way to automatically provide parallel constructs for the programmer. This paper provides an approach to translate dataflow process networks (DPNs) into programs running some of the computations on the Open Computing Language (OpenCL) platform, supporting running programs on massively parallel hardware such as graphics processing units (GPUs). We show that certain DPN programs could run very efficiently on dataparallel architectures but also that there are certain patterns in DPN programs that prove problematic.",

author = "Wictor Lund and {Kanur Chandra Shekar}, Sudeep and Johan Ersfolk and Leonidas Tsiopoulos and Johan Lilius and Joakim Haldin and Ulf Falk",

year = "2015",

doi = "10.1109/PDP.2015.29",

language = "Odefinierat/ok{\"a}nt",

isbn = "978-1-4799-8492-3",

pages = "618–625",

editor = "Masoud Daneshtalab and Marco Aldinucci and Ville Lepp{\"a}nen and Johan Lilius and Mats Brorsson",

booktitle = "Parallel, Distributed and Network-Based Processing (PDP), 2015 23rd Euromicro International Conference on",

publisher = "IEEE",

note = "Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP) ; Conference date: 04-03-2015 Through 06-03-2015",

}

Lund, W, Kanur Chandra Shekar, S, Ersfolk, J, Tsiopoulos, L, Lilius, J, Haldin, J & Falk, U 2015, Execution of dataflow process networks on OpenCL platforms. julkaisussa M Daneshtalab, M Aldinucci, V Leppänen, J Lilius & M Brorsson (toim), Parallel, Distributed and Network-Based Processing (PDP), 2015 23rd Euromicro International Conference on. IEEE, Sivut 618–625, Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP), 04/03/15. https://doi.org/10.1109/PDP.2015.29

Execution of dataflow process networks on OpenCL platforms. / Lund, Wictor; Kanur Chandra Shekar, Sudeep; Ersfolk, Johan et al.
Parallel, Distributed and Network-Based Processing (PDP), 2015 23rd Euromicro International Conference on. toim. / Masoud Daneshtalab; Marco Aldinucci; Ville Leppänen; Johan Lilius; Mats Brorsson. IEEE, 2015. s. 618–625.

Tutkimustuotos: Artikkeli kirjassa/raportissa/konferenssijulkaisussa › Konferenssiartikkeli › Tieteellinen › vertaisarvioitu

TY - GEN

T1 - Execution of dataflow process networks on OpenCL platforms

AU - Lund, Wictor

AU - Kanur Chandra Shekar, Sudeep

AU - Ersfolk, Johan

AU - Tsiopoulos, Leonidas

AU - Lilius, Johan

AU - Haldin, Joakim

AU - Falk, Ulf

PY - 2015

Y1 - 2015

N2 - The trend in computing systems is to combine various kinds of processing elements (PEs) to build more parallel architectures. This trend leads to more heterogeneous computing systems, for which abstractions are needed to efficiently program the systems without increasing the programming cost. This has lead to new programming languages and application program- ming interfaces (APIs). Parallel programming has always been a holy grail in computer science and dataflow programming promises a way to automatically provide parallel constructs for the programmer. This paper provides an approach to translate dataflow process networks (DPNs) into programs running some of the computations on the Open Computing Language (OpenCL) platform, supporting running programs on massively parallel hardware such as graphics processing units (GPUs). We show that certain DPN programs could run very efficiently on data- parallel architectures but also that there are certain patterns in DPN programs that prove problematic. The trend in computing systems is to combine various kinds of processing elements (PEs) to build more parallel architectures. This trend leads to more heterogeneous computing systems, for which abstractions are needed to efficiently program the systems without increasing the programming cost. This has lead to new programming languages and application programming interfaces (APIs). Parallel programming has always been a holy grail in computer science and dataflow programming promises a way to automatically provide parallel constructs for the programmer. This paper provides an approach to translate dataflow process networks (DPNs) into programs running some of the computations on the Open Computing Language (OpenCL) platform, supporting running programs on massively parallel hardware such as graphics processing units (GPUs). We show that certain DPN programs could run very efficiently on dataparallel architectures but also that there are certain patterns in DPN programs that prove problematic.

AB - The trend in computing systems is to combine various kinds of processing elements (PEs) to build more parallel architectures. This trend leads to more heterogeneous computing systems, for which abstractions are needed to efficiently program the systems without increasing the programming cost. This has lead to new programming languages and application program- ming interfaces (APIs). Parallel programming has always been a holy grail in computer science and dataflow programming promises a way to automatically provide parallel constructs for the programmer. This paper provides an approach to translate dataflow process networks (DPNs) into programs running some of the computations on the Open Computing Language (OpenCL) platform, supporting running programs on massively parallel hardware such as graphics processing units (GPUs). We show that certain DPN programs could run very efficiently on data- parallel architectures but also that there are certain patterns in DPN programs that prove problematic. The trend in computing systems is to combine various kinds of processing elements (PEs) to build more parallel architectures. This trend leads to more heterogeneous computing systems, for which abstractions are needed to efficiently program the systems without increasing the programming cost. This has lead to new programming languages and application programming interfaces (APIs). Parallel programming has always been a holy grail in computer science and dataflow programming promises a way to automatically provide parallel constructs for the programmer. This paper provides an approach to translate dataflow process networks (DPNs) into programs running some of the computations on the Open Computing Language (OpenCL) platform, supporting running programs on massively parallel hardware such as graphics processing units (GPUs). We show that certain DPN programs could run very efficiently on dataparallel architectures but also that there are certain patterns in DPN programs that prove problematic.

U2 - 10.1109/PDP.2015.29

DO - 10.1109/PDP.2015.29

M3 - Konferensbidrag

SN - 978-1-4799-8492-3

SP - 618

EP - 625

BT - Parallel, Distributed and Network-Based Processing (PDP), 2015 23rd Euromicro International Conference on

A2 - Daneshtalab, Masoud

A2 - Aldinucci, Marco

A2 - Leppänen, Ville

A2 - Lilius, Johan

A2 - Brorsson, Mats

PB - IEEE

T2 - Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP)

Y2 - 4 March 2015 through 6 March 2015

ER -

Lund W, Kanur Chandra Shekar S, Ersfolk J, Tsiopoulos L, Lilius J, Haldin J et al. Execution of dataflow process networks on OpenCL platforms. julkaisussa Daneshtalab M, Aldinucci M, Leppänen V, Lilius J, Brorsson M, toimittajat, Parallel, Distributed and Network-Based Processing (PDP), 2015 23rd Euromicro International Conference on. IEEE. 2015. s. 618–625 doi: 10.1109/PDP.2015.29