Piotr Luszczek

Dr. Piotr Luszczek

orcid

Research Focus & Metrics

Academic Career Length

21Years (2006-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
1 July 2009 in Journal of Physics: Conference Series
Verified
Conference Paper
Closed access
PDF file
EAEmmanuel Agullo
Emmanuel Agullo
JDJim Demmel
Jim Demmel
JDJack Dongarra
Jack Dongarra
BHBilel Hadri
Bilel Hadri
JKJakub Kurzak
Jakub Kurzak
STStanimire Tomov
Stanimire Tomov

17 August 2015 in The International Journal of High Performance Computing Applications
Verified
Journal Article
Open access
JDJack Dongarra
Jack Dongarra
MHMichael A Heroux
Michael A Heroux
PLPiotr Luszczek
Piotr Luszczek
We describe a new high-performance conjugate-gradient (HPCG) benchmark. HPCG is composed of computations and data-access patterns commonly found in scientific applications. HPCG strives for a better correlation to existing codes from the computational science domain and to be representative of their performance. HPCG is meant to help drive the computer system design and implementation in directions that will better impact future performance improvement.

9 June 2014
Verified
Book Chapter
Closed access
PDF file
JDJack Dongarra
Jack Dongarra
MGMark Gates
Mark Gates
AHAzzam Haidar
Azzam Haidar
JKJakub Kurzak
Jakub Kurzak
PLPiotr Luszczek
Piotr Luszczek
IYIchitaro Yamazaki
Ichitaro Yamazaki

9 February 2015 in The International Journal of High Performance Computing Applications
Verified
Journal Article
Closed access
AHAzzam Haidar
Azzam Haidar
TDTingxing Dong
Tingxing Dong
PLPiotr Luszczek
Piotr Luszczek
STStanimire Tomov
Stanimire Tomov
JDJack Dongarra
Jack Dongarra
Scientific applications require solvers that work on many small size problems that are independent from each other. At the same time, the high-end hardware evolves rapidly and becomes ever more throughput-oriented and thus there is an increasing need for an effective approach to develop energy-efficient, high-performance codes for these small matrix problems that we call batched factorizations. The many applications that need this functionality could especially benefit from the use of GPUs, which currently are four to five times more energy efficient than multicore CPUs on important scientific workloads. This paper, consequently, describes the development of the most common, one-sided factorizations, Cholesky, LU, and QR, for a set of small dense matrices. The algorithms we present together with their implementations are, by design, inherently parallel. In particular, our approach is based on representing the process as a sequence of batched BLAS routines that are executed entirely on a GPU. Importantly, this is unlike the LAPACK and the hybrid MAGMA factorization algorithms that work under drastically different assumptions of hardware design and efficiency of execution of the various computational kernels involved in the implementation. Thus, our approach is more efficient than what works for a combination of multicore CPUs and GPUs for the problems sizes of interest of the application use cases. The paradigm where upon a single chip (a GPU or a CPU) factorizes a single problem at a time is not at all efficient in our applications’ context. We illustrate all of these claims through a detailed performance analysis. With the help of profiling and tracing tools, we guide our development of batched factorizations to achieve up to two-fold speedup and three-fold better energy efficiency as compared against our highly optimized batched CPU implementations based on MKL library. The tested system featured two sockets of Intel Sandy Bridge CPUs and we compared with a batched LU factorizations featured in the CUBLAS library for GPUs, we achieve as high as 2.5× speedup on the NVIDIA K40 GPU.

26 June 2021 in ACM Transactions on Mathematical Software
Verified
Journal Article
Open access
AAAhmad Abdelfattah
Ahmad Abdelfattah
TCTimothy Costa
Timothy Costa
JDJack Dongarra
Jack Dongarra
MGMark Gates
Mark Gates
AHAzzam Haidar
Azzam Haidar
MZMawussi Zounon
Mawussi Zounon
This article describes a standard API for a set of Batched Basic Linear Algebra Subprograms (Batched BLAS or BBLAS). The focus is on many independent BLAS operations on small matrices that are grouped together and processed by a single routine, called a Batched BLAS routine. The matrices are grouped together in uniformly sized groups, with just one group if all the matrices are of equal size. The aim is to provide more efficient, but portable, implementations of algorithms on high-performance many-core platforms. These include multicore and many-core CPU processors, GPUs and coprocessors, and other hardware accelerators with floating-point compute facility. As well as the standard types of single and double precision, we also include half and quadruple precision in the standard. In particular, half precision is used in many very large scale applications, such as those associated with machine learning.

22 June 2021 in IEEE Transactions on Parallel and Distributed Systems
Verified
Journal Article
Closed access
NLNeil Lindquist
Neil Lindquist
PLPiotr Luszczek
Piotr Luszczek
JDJack Dongarra
Jack Dongarra
The generalized minimum residual method (GMRES) is a commonly used iterative Krylov solver for sparse, non-symmetric systems of linear equations. Like other iterative solvers, data movement dominates its run time. To improve this performance, we propose running GMRES in reduced precision with key operations remaining in full precision. Additionally, we provide theoretical results linking the convergence of finite precision GMRES with classical Gram-Schmidt with reorthogonalization (CGSR) and its infinite precision counterpart which helps justify the convergence of this method to double-precision accuracy. We tested the mixed-precision approach with a variety of matrices and preconditioners on a GPU-accelerated node. Excluding the incomplete LU factorization without fill in (ILU(0)) preconditioner, we achieved average speedups ranging from 8 to 61 percent relative to comparable double-precision implementations, with the simpler preconditioners achieving the higher speedups.