PVTOL

Providing productivity, performance, and portability to DoD signal processing applications on multicore processors

Hahn Kim, Edward Rutledge, Sharon Sacco, Sanjeev Mohindra, Matthew Marzilli, Jeremy Kepner, Ryan Haney, Jim Daly, Nadya Bliss

Research output: Chapter in Book/Report/Conference proceedingConference contribution

12 Citations (Scopus)

Abstract

PVTOL provides an object-oriented C++ API that hides the complexity of multicore architectures within a PGAS programming model, improving programmer productivity. Tasks and conduits enable data flow patterns such as pipelining and round-robining. Hierarchical maps concisely describe how to allocate hierarchical arrays across processor and memory hierarchies and provide a simple API for moving data across these hierarchies. Functors encapsulate computational kernels; new functors can be easily developed using the PVTOL API and can be fused for more efficient computation. Existing computation and communication technologies that are optimized for various architectures are used to achieve high performance. PVTOL abstracts the details of the underlying processor architectures to provide portability. We are actively developing PVTOL for Intel, PowerPC and Cell architectures and intend to add support for more computational kernels on these architectures. FPGAs are becoming popular for accelerating computation in both the high performance computing (HPC) and high performance embedded computing (HPEC) communities. Integrated processor-FPGA technologies are now available from both HPC and HPEC vendors, e.g. Cray and Mercury Computer Systems. We plan to support FPGAs as co-processors in PVTOL. Finally, automated mapping technology has been demonstrated with pMatlab. We plan to begin implementing automated mapping in PVTOL next year. Similar to PVL, as PVTOL matures and is used in more projects at Lincoln, we plan to propose concepts demonstrated in PVTOL to HPEC-SI for adoption into future versions of VSIPL++.

Original languageEnglish (US)
Title of host publication2008 Proceedings of the Department of Defense High Performance Computing Modernization Program: Users Group Conference - Solving the Hard Problems
Pages327-333
Number of pages7
DOIs
StatePublished - 2008
Externally publishedYes
Event2008 Department of Defense High Performance Computing Modernization Program: Users Group Conference - Solving the Hard Problems - Seattle, WA, United States
Duration: Jul 14 2007Jul 17 2007

Other

Other2008 Department of Defense High Performance Computing Modernization Program: Users Group Conference - Solving the Hard Problems
CountryUnited States
CitySeattle, WA
Period7/14/077/17/07

Fingerprint

Multi-core Processor
Portability
Application programming interfaces (API)
Productivity
Program processors
Signal Processing
Field programmable gate arrays (FPGA)
Signal processing
High Performance
Computing
Field Programmable Gate Array
Parallel processing systems
Flow patterns
Functor
Computer systems
kernel
Data storage equipment
Pipelining
Memory Hierarchy
Mercury

ASJC Scopus subject areas

  • Computational Theory and Mathematics
  • Computer Science Applications
  • Theoretical Computer Science

Cite this

Kim, H., Rutledge, E., Sacco, S., Mohindra, S., Marzilli, M., Kepner, J., ... Bliss, N. (2008). PVTOL: Providing productivity, performance, and portability to DoD signal processing applications on multicore processors. In 2008 Proceedings of the Department of Defense High Performance Computing Modernization Program: Users Group Conference - Solving the Hard Problems (pp. 327-333). [4755886] https://doi.org/10.1109/DoD.HPCMP.UGC.2008.35

PVTOL : Providing productivity, performance, and portability to DoD signal processing applications on multicore processors. / Kim, Hahn; Rutledge, Edward; Sacco, Sharon; Mohindra, Sanjeev; Marzilli, Matthew; Kepner, Jeremy; Haney, Ryan; Daly, Jim; Bliss, Nadya.

2008 Proceedings of the Department of Defense High Performance Computing Modernization Program: Users Group Conference - Solving the Hard Problems. 2008. p. 327-333 4755886.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Kim, H, Rutledge, E, Sacco, S, Mohindra, S, Marzilli, M, Kepner, J, Haney, R, Daly, J & Bliss, N 2008, PVTOL: Providing productivity, performance, and portability to DoD signal processing applications on multicore processors. in 2008 Proceedings of the Department of Defense High Performance Computing Modernization Program: Users Group Conference - Solving the Hard Problems., 4755886, pp. 327-333, 2008 Department of Defense High Performance Computing Modernization Program: Users Group Conference - Solving the Hard Problems, Seattle, WA, United States, 7/14/07. https://doi.org/10.1109/DoD.HPCMP.UGC.2008.35
Kim H, Rutledge E, Sacco S, Mohindra S, Marzilli M, Kepner J et al. PVTOL: Providing productivity, performance, and portability to DoD signal processing applications on multicore processors. In 2008 Proceedings of the Department of Defense High Performance Computing Modernization Program: Users Group Conference - Solving the Hard Problems. 2008. p. 327-333. 4755886 https://doi.org/10.1109/DoD.HPCMP.UGC.2008.35
Kim, Hahn ; Rutledge, Edward ; Sacco, Sharon ; Mohindra, Sanjeev ; Marzilli, Matthew ; Kepner, Jeremy ; Haney, Ryan ; Daly, Jim ; Bliss, Nadya. / PVTOL : Providing productivity, performance, and portability to DoD signal processing applications on multicore processors. 2008 Proceedings of the Department of Defense High Performance Computing Modernization Program: Users Group Conference - Solving the Hard Problems. 2008. pp. 327-333
@inproceedings{b3639e86ce8644ea9b1c558f8e0ac65f,
title = "PVTOL: Providing productivity, performance, and portability to DoD signal processing applications on multicore processors",
abstract = "PVTOL provides an object-oriented C++ API that hides the complexity of multicore architectures within a PGAS programming model, improving programmer productivity. Tasks and conduits enable data flow patterns such as pipelining and round-robining. Hierarchical maps concisely describe how to allocate hierarchical arrays across processor and memory hierarchies and provide a simple API for moving data across these hierarchies. Functors encapsulate computational kernels; new functors can be easily developed using the PVTOL API and can be fused for more efficient computation. Existing computation and communication technologies that are optimized for various architectures are used to achieve high performance. PVTOL abstracts the details of the underlying processor architectures to provide portability. We are actively developing PVTOL for Intel, PowerPC and Cell architectures and intend to add support for more computational kernels on these architectures. FPGAs are becoming popular for accelerating computation in both the high performance computing (HPC) and high performance embedded computing (HPEC) communities. Integrated processor-FPGA technologies are now available from both HPC and HPEC vendors, e.g. Cray and Mercury Computer Systems. We plan to support FPGAs as co-processors in PVTOL. Finally, automated mapping technology has been demonstrated with pMatlab. We plan to begin implementing automated mapping in PVTOL next year. Similar to PVL, as PVTOL matures and is used in more projects at Lincoln, we plan to propose concepts demonstrated in PVTOL to HPEC-SI for adoption into future versions of VSIPL++.",
author = "Hahn Kim and Edward Rutledge and Sharon Sacco and Sanjeev Mohindra and Matthew Marzilli and Jeremy Kepner and Ryan Haney and Jim Daly and Nadya Bliss",
year = "2008",
doi = "10.1109/DoD.HPCMP.UGC.2008.35",
language = "English (US)",
isbn = "9780769535159",
pages = "327--333",
booktitle = "2008 Proceedings of the Department of Defense High Performance Computing Modernization Program: Users Group Conference - Solving the Hard Problems",

}

TY - GEN

T1 - PVTOL

T2 - Providing productivity, performance, and portability to DoD signal processing applications on multicore processors

AU - Kim, Hahn

AU - Rutledge, Edward

AU - Sacco, Sharon

AU - Mohindra, Sanjeev

AU - Marzilli, Matthew

AU - Kepner, Jeremy

AU - Haney, Ryan

AU - Daly, Jim

AU - Bliss, Nadya

PY - 2008

Y1 - 2008

N2 - PVTOL provides an object-oriented C++ API that hides the complexity of multicore architectures within a PGAS programming model, improving programmer productivity. Tasks and conduits enable data flow patterns such as pipelining and round-robining. Hierarchical maps concisely describe how to allocate hierarchical arrays across processor and memory hierarchies and provide a simple API for moving data across these hierarchies. Functors encapsulate computational kernels; new functors can be easily developed using the PVTOL API and can be fused for more efficient computation. Existing computation and communication technologies that are optimized for various architectures are used to achieve high performance. PVTOL abstracts the details of the underlying processor architectures to provide portability. We are actively developing PVTOL for Intel, PowerPC and Cell architectures and intend to add support for more computational kernels on these architectures. FPGAs are becoming popular for accelerating computation in both the high performance computing (HPC) and high performance embedded computing (HPEC) communities. Integrated processor-FPGA technologies are now available from both HPC and HPEC vendors, e.g. Cray and Mercury Computer Systems. We plan to support FPGAs as co-processors in PVTOL. Finally, automated mapping technology has been demonstrated with pMatlab. We plan to begin implementing automated mapping in PVTOL next year. Similar to PVL, as PVTOL matures and is used in more projects at Lincoln, we plan to propose concepts demonstrated in PVTOL to HPEC-SI for adoption into future versions of VSIPL++.

AB - PVTOL provides an object-oriented C++ API that hides the complexity of multicore architectures within a PGAS programming model, improving programmer productivity. Tasks and conduits enable data flow patterns such as pipelining and round-robining. Hierarchical maps concisely describe how to allocate hierarchical arrays across processor and memory hierarchies and provide a simple API for moving data across these hierarchies. Functors encapsulate computational kernels; new functors can be easily developed using the PVTOL API and can be fused for more efficient computation. Existing computation and communication technologies that are optimized for various architectures are used to achieve high performance. PVTOL abstracts the details of the underlying processor architectures to provide portability. We are actively developing PVTOL for Intel, PowerPC and Cell architectures and intend to add support for more computational kernels on these architectures. FPGAs are becoming popular for accelerating computation in both the high performance computing (HPC) and high performance embedded computing (HPEC) communities. Integrated processor-FPGA technologies are now available from both HPC and HPEC vendors, e.g. Cray and Mercury Computer Systems. We plan to support FPGAs as co-processors in PVTOL. Finally, automated mapping technology has been demonstrated with pMatlab. We plan to begin implementing automated mapping in PVTOL next year. Similar to PVL, as PVTOL matures and is used in more projects at Lincoln, we plan to propose concepts demonstrated in PVTOL to HPEC-SI for adoption into future versions of VSIPL++.

UR - http://www.scopus.com/inward/record.url?scp=63249127899&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=63249127899&partnerID=8YFLogxK

U2 - 10.1109/DoD.HPCMP.UGC.2008.35

DO - 10.1109/DoD.HPCMP.UGC.2008.35

M3 - Conference contribution

SN - 9780769535159

SP - 327

EP - 333

BT - 2008 Proceedings of the Department of Defense High Performance Computing Modernization Program: Users Group Conference - Solving the Hard Problems

ER -