@article {,
	title = {A Set of Batched Basic Linear Algebra Subprograms and LAPACK Routines},
	journal = {ACM Transactions on Mathematical Software (TOMS)},
	volume = {47},
	number = {3},
	year = {2021},
	pages = {1{\textendash}23},
	abstract = {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.},
	keywords = {Computations on matrices, Mathematical analysis, Mathematics of computing, Numerical analysis},
	doi = {10.1145/3431921},
	author = {Abdelfattah, Ahmad and Costa, Timothy and Jack Dongarra and Mark Gates and Haidar, Azzam and Hammarling, Sven and Higham, Nicholas J and Kurzak, Jakub and Piotr Luszczek and Stanimire Tomov and others}
}
@article {,
	title = {A Set of Batched Basic Linear Algebra Subprograms},
	journal = {ACM Transactions on Mathematical Software},
	year = {2020},
	month = {2020-10},
	abstract = {This paper 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.},
	author = {Ahmad Abdelfattah and Timothy Costa and Jack Dongarra and Mark Gates and Azzam Haidar and Sven Hammarling and Nicholas J. Higham and Jakub Kurzak and Piotr Luszczek and Stanimire Tomov and Mawussi Zounon}
}
@article {,
	title = {SLATE: Software for Linear Algebra Targeting Exascale (POSTER)},
	year = {2020},
	month = {2020-02},
	publisher = {2020 Exascale Computing Project Annual Meeting},
	address = {Houston, TX},
	author = {Mark Gates and Ali Charara and Jakub Kurzak and Asim YarKhan and Mohammed Al Farhan and Dalal Sukkari and Jack Dongarra}
}
@article {1464,
	title = {SLATE Tutorial},
	year = {2020},
	month = {2020-02},
	publisher = {2020 ECP Annual Meeting},
	address = {Houston, TX},
	author = {Mark Gates and Jakub Kurzak and Asim YarKhan and Ali Charara and Jamie Finney and Dalal Sukkari and Mohammed Al Farhan and Ichitaro Yamazaki and Panruo Wu and Jack Dongarra}
}
@techreport {1278,
	title = {SLATE Users{\textquoteright} Guide},
	journal = {SLATE Working Notes},
	number = {10, ICL-UT-19-01},
	year = {2020},
	month = {2020-07},
	publisher = {Innovative Computing Laboratory, University of Tennessee},
	type = {SLATE Working Notes},
	author = {Mark Gates and Ali Charara and Jakub Kurzak and Asim YarKhan and Mohammed Al Farhan and Dalal Sukkari and Jack Dongarra}
}
@techreport {1396,
	title = {An Empirical View of SLATE Algorithms on Scalable Hybrid System},
	journal = {Innovative Computing Laboratory Technical Report},
	number = {ICL-UT-19-08},
	year = {2019},
	month = {2019-09},
	publisher = {University of Tennessee, Knoxville},
	author = {Asim YarKhan and Jakub Kurzak and Ahmad Abdelfattah and Jack Dongarra}
}
@inproceedings {1404,
	title = {Least Squares Solvers for Distributed-Memory Machines with GPU Accelerators},
	journal = {ACM International Conference on Supercomputing (ICS {\textquoteright}19)},
	year = {2019},
	month = {2019-06},
	pages = {117{\textendash}126},
	publisher = {ACM},
	address = {Phoenix, Arizona},
	isbn = {9781450360791},
	doi = {https://dl.acm.org/doi/abs/10.1145/3330345.3330356},
	author = {Jakub Kurzak and Mark Gates and Ali Charara and Asim YarKhan and Jack Dongarra}
}
@inproceedings {1405,
	title = {Linear Systems Solvers for Distributed-Memory Machines with GPU Accelerators},
	journal = {Euro-Par 2019: Parallel Processing},
	volume = {11725},
	year = {2019},
	month = {2019-08},
	pages = {495{\textendash}506},
	publisher = {Springer},
	isbn = {978-3-030-29399-4},
	doi = {https://doi.org/10.1007/978-3-030-29400-7_35},
	url = {https://link.springer.com/chapter/10.1007/978-3-030-29400-7_35},
	author = {Kurzak, Jakub and Mark Gates and Charara, Ali and Asim YarKhan and Yamazaki, Ichitaro and Jack Dongarra},
	editor = {Yahyapour, Ramin}
}
@conference {1373,
	title = {Massively Parallel Automated Software Tuning},
	booktitle = {48th International Conference on Parallel Processing (ICPP 2019)},
	year = {2019},
	month = {2019-08},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {Kyoto, Japan},
	abstract = {This article presents an implementation of a distributed autotuning engine developed as part of the Bench-testing OpenN Software Autotuning Infrastructure project. The system is geared towards performance optimization of computational kernels for graphics processing units, and allows for the deployment of vast autotuning sweeps to massively parallel machines. The software implements dynamic work scheduling to distributed-memory resources and takes advantage of multithreading for parallel compilation and dispatches kernel launches to multiple accelerators. This paper lays out the main design principles of the system and discusses the basic mechanics of the initial implementation. Preliminary performance results are presented, encountered challenges are discussed, and the future directions are outlined.},
	doi = {https://doi.org/10.1145/3337821.3337908},
	author = {Jakub Kurzak and Yaohung Tsai and Mark Gates and Ahmad Abdelfattah and Jack Dongarra}
}
@article {1270,
	title = {PLASMA: Parallel Linear Algebra Software for Multicore Using OpenMP},
	journal = {ACM Transactions on Mathematical Software},
	volume = {45},
	year = {2019},
	month = {2019-06},
	doi = {https://doi.org/10.1145/3264491},
	author = {Jack Dongarra and Mark Gates and Azzam Haidar and Jakub Kurzak and Piotr Luszczek and Panruo Wu and Ichitaro Yamazaki and Asim YarKhan and Maksims Abalenkovs and Negin Bagherpour and Sven Hammarling and Jakub Sistek}
}
@article {1463,
	title = {SLATE: Design of a Modern Distributed and Accelerated Linear Algebra Library},
	year = {2019},
	month = {2019-11},
	publisher = {International Conference for High Performance Computing, Networking, Storage and Analysis (SC19)},
	address = {Denver, CO},
	author = {Mark Gates and Jakub Kurzak and Ali Charara and Asim YarKhan and Jack Dongarra}
}
@conference {1450,
	title = {SLATE: Design of a Modern Distributed and Accelerated Linear Algebra Library},
	booktitle = {International Conference for High Performance Computing, Networking, Storage and Analysis (SC19)},
	year = {2019},
	month = {2019-11},
	publisher = {ACM},
	organization = {ACM},
	address = {Denver, CO},
	abstract = {The SLATE (Software for Linear Algebra Targeting Exascale) library is being developed to provide fundamental dense linear algebra capabilities for current and upcoming distributed high-performance systems, both accelerated CPU-GPU based and CPU based. SLATE will provide coverage of existing ScaLAPACK functionality, including the parallel BLAS; linear systems using LU and Cholesky; least squares problems using QR; and eigenvalue and singular value problems. In this respect, it will serve as a replacement for ScaLAPACK, which after two decades of operation, cannot adequately be retrofitted for modern accelerated architectures. SLATE uses modern techniques such as communication-avoiding algorithms, lookahead panels to overlap communication and computation, and task-based scheduling, along with a modern C++ framework. Here we present the design of SLATE and initial reports of several of its components.},
	doi = {https://doi.org/10.1145/3295500.3356223},
	author = {Mark Gates and Jakub Kurzak and Ali Charara and Asim YarKhan and Jack Dongarra}
}
@techreport {1279,
	title = {SLATE Developers{\textquoteright} Guide},
	journal = {SLATE Working Notes},
	number = {11, ICL-UT-19-02},
	year = {2019},
	month = {2019-12},
	publisher = {Innovative Computing Laboratory, University of Tennessee},
	type = {SLATE Working Notes},
	author = {Ali Charara and Mark Gates and Jakub Kurzak and Asim YarKhan and Jack Dongarra}
}
@techreport {1304,
	title = {SLATE Mixed Precision Performance Report},
	journal = {Innovative Computing Laboratory Technical Report},
	number = {ICL-UT-19-03},
	year = {2019},
	month = {2019-04},
	publisher = {University of Tennessee},
	author = {Ali Charara and Jack Dongarra and Mark Gates and Jakub Kurzak and Asim YarKhan}
}
@techreport {1321,
	title = {SLATE Working Note 12: Implementing Matrix Inversions},
	journal = {SLATE Working Notes},
	number = {12, ICL-UT-19-04},
	year = {2019},
	month = {2019-06},
	publisher = {Innovative Computing Laboratory, University of Tennessee},
	author = {Jakub Kurzak and Mark Gates and Ali Charara and Asim YarKhan and Jack Dongarra}
}
@techreport {1394,
	title = {SLATE Working Note 13: Implementing Singular Value and Symmetric/Hermitian Eigenvalue Solvers},
	journal = {SLATE Working Notes},
	number = {13, ICL-UT-19-07},
	year = {2019},
	note = {revision 06-2023},
	month = {2019-09},
	publisher = {Innovative Computing Laboratory, University of Tennessee},
	type = {SLATE Working Notes},
	author = {Mark Gates and Mohammed Al Farhan and Ali Charara and Jakub Kurzak and Dalal Sukkari and Asim YarKhan and Jack Dongarra}
}
@article {1271,
	title = {Autotuning Numerical Dense Linear Algebra for Batched Computation With GPU Hardware Accelerators},
	journal = {Proceedings of the IEEE},
	volume = {106},
	year = {2018},
	month = {2018-11},
	pages = {2040{\textendash}2055},
	abstract = {Computational problems in engineering and scientific disciplines often rely on the solution of many instances of small systems of linear equations, which are called batched solves. In this paper, we focus on the important variants of both batch Cholesky factorization and subsequent substitution. The former requires the linear system matrices to be symmetric positive definite (SPD). We describe the implementation and automated performance engineering of these kernels that implement the factorization and the two substitutions. Our target platforms are graphics processing units (GPUs), which over the past decade have become an attractive high-performance computing (HPC) target for solvers of linear systems of equations. Due to their throughput-oriented design, GPUs exhibit the highest processing rates among the available processors. However, without careful design and coding, this speed is mostly restricted to large matrix sizes. We show an automated exploration of the implementation space as well as a new data layout for the batched class of SPD solvers. Our tests involve the solution of many thousands of linear SPD systems of exactly the same size. The primary focus of our techniques is on the individual matrices in the batch that have dimensions ranging from 5-by-5 up to 100-by-100. We compare our autotuned solvers against the state-of-the-art solvers such as those provided through NVIDIA channels and publicly available in the optimized MAGMA library. The observed performance is competitive and many times superior for many practical cases. The advantage of the presented methodology lies in achieving these results in a portable manner across matrix storage formats and GPU hardware architecture platforms.},
	keywords = {Dense numerical linear algebra, performance autotuning},
	doi = {10.1109/JPROC.2018.2868961},
	author = {Jack Dongarra and Mark Gates and Jakub Kurzak and Piotr Luszczek and Yaohung Tsai}
}
@article {1277,
	title = {Autotuning Techniques for Performance-Portable Point Set Registration in 3D},
	journal = {Supercomputing Frontiers and Innovations},
	volume = {5},
	number = {4},
	year = {2018},
	month = {2018-12},
	chapter = {42},
	abstract = {We present an autotuning approach applied to exhaustive performance engineering of the EM-ICP algorithm for the point set registration problem with a known reference. We were able to achieve progressively higher performance levels through a variety of code transformations and an automated procedure of generating a large number of implementation variants. Furthermore, we managed to exploit code patterns that are not common when only attempting manual optimization but which yielded in our tests better performance for the chosen registration algorithm. Finally, we also show how we maintained high levels of the performance rate in a portable fashion across a wide range of hardware platforms including multicore, manycore coprocessors, and accelerators. Each of these hardware classes is much different from the others and, consequently, cannot reliably be mastered by a single developer in a short time required to deliver a close-to-optimal implementation. We assert in our concluding remarks that our methodology as well as the presented tools provide a valid automation system for software optimization tasks on modern HPC hardware.},
	doi = {10.14529/jsfi180404},
	author = {Piotr Luszczek and Jakub Kurzak and Ichitaro Yamazaki and David Keffer and Vasileios Maroulas and Jack Dongarra}
}
@techreport {1203,
	title = {Implementation of the C++ API for Batch BLAS},
	journal = {SLATE Working Notes},
	number = {07, ICL-UT-18-04},
	year = {2018},
	month = {2018-06},
	publisher = {Innovative Computing Laboratory, University of Tennessee},
	author = {Ahmad Abdelfattah and Mark Gates and Jakub Kurzak and Piotr Luszczek and Jack Dongarra}
}
@techreport {1273,
	title = {Least Squares Performance Report},
	journal = {SLATE Working Notes},
	number = {09, ICL-UT-18-10},
	year = {2018},
	month = {2018-12},
	publisher = {Innovative Computing Laboratory, University of Tennessee},
	type = {SLATE Working Notes},
	author = {Mark Gates and Ali Charara and Jakub Kurzak and Asim YarKhan and Ichitaro Yamazaki and Jack Dongarra}
}
@techreport {1228,
	title = {Linear Systems Performance Report},
	journal = {SLATE Working Notes},
	number = {08, ICL-UT-18-08},
	year = {2018},
	month = {2018-09},
	publisher = {Innovative Computing Laboratory, University of Tennessee},
	type = {SLATE Working Notes},
	author = {Jakub Kurzak and Mark Gates and Ichitaro Yamazaki and Ali Charara and Asim YarKhan and Jamie Finney and Gerald Ragghianti and Piotr Luszczek and Jack Dongarra}
}
@techreport {1191,
	title = {Parallel BLAS Performance Report},
	journal = {SLATE Working Notes},
	number = {05, ICL-UT-18-01},
	year = {2018},
	month = {2018-04},
	publisher = {University of Tennessee},
	author = {Jakub Kurzak and Mark Gates and Asim YarKhan and Ichitaro Yamazaki and Panruo Wu and Piotr Luszczek and Jamie Finney and Jack Dongarra}
}
@techreport {1206,
	title = {Parallel Norms Performance Report},
	journal = {SLATE Working Notes},
	number = {06, ICL-UT-18-06},
	year = {2018},
	month = {2018-06},
	publisher = {Innovative Computing Laboratory, University of Tennessee},
	author = {Jakub Kurzak and Mark Gates and Asim YarKhan and Ichitaro Yamazaki and Piotr Luszczek and Jamie Finney and Jack Dongarra}
}
@article {1258,
	title = {The Singular Value Decomposition: Anatomy of Optimizing an Algorithm for Extreme Scale},
	journal = {SIAM Review},
	volume = {60},
	year = {2018},
	month = {2018-11},
	pages = {808{\textendash}865},
	abstract = {The computation of the singular value decomposition, or SVD, has a long history with many improvements over the years, both in its implementations and algorithmically. Here, we survey the evolution of SVD algorithms for dense matrices, discussing the motivation and performance impacts of changes. There are two main branches of dense SVD methods: bidiagonalization and Jacobi. Bidiagonalization methods started with the implementation by Golub and Reinsch in Algol60, which was subsequently ported to Fortran in the EISPACK library, and was later more efficiently implemented in the LINPACK library, targeting contemporary vector machines. To address cache-based memory hierarchies, the SVD algorithm was reformulated to use Level 3 BLAS in the LAPACK library. To address new architectures, ScaLAPACK was introduced to take advantage of distributed computing, and MAGMA was developed for accelerators such as GPUs. Algorithmically, the divide and conquer and MRRR algorithms were developed to reduce the number of operations. Still, these methods remained memory bound, so two-stage algorithms were developed to reduce memory operations and increase the computational intensity, with efficient implementations in PLASMA, DPLASMA, and MAGMA. Jacobi methods started with the two-sided method of Kogbetliantz and the one-sided method of Hestenes. They have likewise had many developments, including parallel and block versions and preconditioning to improve convergence. In this paper, we investigate the impact of these changes by testing various historical and current implementations on a common, modern multicore machine and a distributed computing platform. We show that algorithmic and implementation improvements have increased the speed of the SVD by several orders of magnitude, while using up to 40 times less energy.},
	keywords = {bidiagonal matrix, bisection, Divide and conquer, Hestenes method, Jacobi method, Kogbetliantz method, MRRR, QR iteration, Singular value decomposition, SVD},
	issn = {0036-1445},
	doi = {10.1137/17M1117732},
	url = {https://epubs.siam.org/doi/10.1137/17M1117732},
	author = {Jack Dongarra and Mark Gates and Azzam Haidar and Jakub Kurzak and Piotr Luszczek and Stanimire Tomov and Ichitaro Yamazaki}
}
@article {1189,
	title = {Symmetric Indefinite Linear Solver using OpenMP Task on Multicore Architectures},
	journal = {IEEE Transactions on Parallel and Distributed Systems},
	volume = {29},
	year = {2018},
	month = {2018-08},
	pages = {1879{\textendash}1892},
	abstract = {Recently, the Open Multi-Processing (OpenMP) standard has incorporated task-based programming, where a function call with input and output data is treated as a task. At run time, OpenMP{\textquoteright}s superscalar scheduler tracks the data dependencies among the tasks and executes the tasks as their dependencies are resolved. On a shared-memory architecture with multiple cores, the independent tasks are executed on different cores in parallel, thereby enabling parallel execution of a seemingly sequential code. With the emergence of many-core architectures, this type of programming paradigm is gaining attention-not only because of its simplicity, but also because it breaks the artificial synchronization points of the program and improves its thread-level parallelization. In this paper, we use these new OpenMP features to develop a portable high-performance implementation of a dense symmetric indefinite linear solver. Obtaining high performance from this kind of solver is a challenge because the symmetric pivoting, which is required to maintain numerical stability, leads to data dependencies that prevent us from using some common performance-improving techniques. To fully utilize a large number of cores through tasking, while conforming to the OpenMP standard, we describe several techniques. Our performance results on current many-core architectures-including Intel{\textquoteright}s Broadwell, Intel{\textquoteright}s Knights Landing, IBM{\textquoteright}s Power8, and Arm{\textquoteright}s ARMv8-demonstrate the portable and superior performance of our implementation compared with the Linear Algebra PACKage (LAPACK). The resulting solver is now available as a part of the PLASMA software package.},
	keywords = {linear algebra, multithreading, runtime, symmetric indefinite matrices},
	doi = {10.1109/TPDS.2018.2808964},
	author = {Ichitaro Yamazaki and Jakub Kurzak and Panruo Wu and Mawussi Zounon and Jack Dongarra}
}
@article {1448,
	title = {Task Based Cholesky Decomposition on Xeon Phi Architectures using OpenMP},
	journal = {International Journal of Computational Science and Engineering (IJCSE)},
	volume = {17},
	number = {3},
	year = {2018},
	month = {2018-10},
	abstract = {The increasing number of computational cores in modern many-core processors, as represented by the Intel Xeon Phi architectures, has created the need for an open-source, high performance and scalable task-based dense linear algebra package that can efficiently use this type of many-core hardware. In this paper, we examined the design modifications necessary when porting PLASMA, a task-based dense linear algebra library, run effectively on two generations of Intel{\textquoteright}s Xeon Phi architecture, known as knights corner (KNC) and knights landing (KNL). First, we modified PLASMA{\textquoteright}s tiled Cholesky decomposition to use OpenMP tasks for its scheduling mechanism to enable Xeon Phi compatibility. We then compared the performance of our modified code to that of the original dynamic scheduler running on an Intel Xeon Sandy Bridge CPU. Finally, we looked at the performance of the OpenMP tiled Cholesky decomposition on knights corner and knights landing processors. We detail the optimisations required to obtain performance on these platforms and compare with the highly tuned Intel MKL math library.},
	doi = {http://dx.doi.org/10.1504/IJCSE.2018.095851},
	author = {Joseph Dorris and Asim YarKhan and Jakub Kurzak and Piotr Luszczek and Jack Dongarra}
}
@conference {1169,
	title = {Autotuning Batch Cholesky Factorization in CUDA with Interleaved Layout of Matrices},
	booktitle = {Parallel and Distributed Processing Symposium Workshops (IPDPSW)},
	year = {2017},
	month = {2017-06},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Orlando, FL},
	abstract = {Batch matrix operations address the case of solving the same linear algebra problem for a very large number of very small matrices. In this paper, we focus on implementing the batch Cholesky factorization in CUDA, in single precision arithmetic, for NVIDIA GPUs. Specifically, we look into the benefits of using noncanonical data layouts, where consecutive memory locations store elements with the same row and column index in a set of consecutive matrices. We discuss a number of different implementation options and tuning parameters. We demonstrate superior performance to traditional implementations for the case of very small matrices.},
	keywords = {batch computation, Cholesky Factorization, data layout, GPU computing, numerical linear algebra},
	doi = {10.1109/IPDPSW.2017.18},
	author = {Mark Gates and Jakub Kurzak and Piotr Luszczek and Yu Pei and Jack Dongarra}
}
@inbook {1167,
	title = {Bringing High Performance Computing to Big Data Algorithms},
	booktitle = {Handbook of Big Data Technologies},
	year = {2017},
	publisher = {Springer},
	organization = {Springer},
	isbn = {978-3-319-49339-8},
	doi = {10.1007/978-3-319-49340-4},
	author = {Hartwig Anzt and Jack Dongarra and Mark Gates and Jakub Kurzak and Piotr Luszczek and Stanimire Tomov and Ichitaro Yamazaki}
}
@techreport {1175,
	title = {C++ API for Batch BLAS},
	journal = {SLATE Working Notes},
	number = {04, ICL-UT-17-12},
	year = {2017},
	month = {2017-12},
	publisher = {University of Tennessee},
	author = {Ahmad Abdelfattah and Konstantin Arturov and Cris Cecka and Jack Dongarra and Chip Freitag and Mark Gates and Azzam Haidar and Jakub Kurzak and Piotr Luszczek and Stanimire Tomov and Panruo Wu}
}
@techreport {1081,
	title = {C++ API for BLAS and LAPACK},
	journal = {SLATE Working Notes},
	number = {02, ICL-UT-17-03},
	year = {2017},
	note = {Revision 02-21-2018},
	month = {2017-06},
	publisher = {Innovative Computing Laboratory, University of Tennessee},
	author = {Mark Gates and Piotr Luszczek and Ahmad Abdelfattah and Jakub Kurzak and Jack Dongarra and Konstantin Arturov and Cris Cecka and Chip Freitag}
}
@techreport {1138,
	title = {The Case for Directive Programming for Accelerator Autotuner Optimization},
	journal = {Innovative Computing Laboratory Technical Report},
	number = {ICL-UT-17-07},
	year = {2017},
	month = {2017-10},
	publisher = {University of Tennessee},
	abstract = {In this work, we present the use of compiler pragma directives for parallelizing autotuning of specialized compute kernels for hardware accelerators. A set of constructs, that include prallelizing a source code that prune a generated search space with a large number of constraints for an autotunning infrastructure. For a better performance we studied optimization aimed at minimization of the run time.We also studied the behavior of the parallel load balance and the speedup on four different machines: x86, Xeon Phi, ARMv8, and POWER8.},
	author = {Diana Fayad and Jakub Kurzak and Piotr Luszczek and Panruo Wu and Jack Dongarra}
}
@article {1165,
	title = {Design and Implementation of the PULSAR Programming System for Large Scale Computing},
	journal = {Supercomputing Frontiers and Innovations},
	volume = {4},
	year = {2017},
	abstract = {The objective of the PULSAR project was to design a programming model suitable for large scale machines with complex memory hierarchies, and to deliver a prototype implementation of a runtime system supporting that model. PULSAR tackled the challenge by proposing a programming model based on systolic processing and virtualization. The PULSAR programming model is quite simple, with point-to-point channels as the main communication abstraction. The runtime implementation is very lightweight and fully distributed, and provides multithreading, message-passing and multi-GPU offload capabilities. Performance evaluation shows good scalability up to one thousand nodes with one thousand GPU accelerators.},
	doi = {10.14529/jsfi170101},
	url = {http://superfri.org/superfri/article/view/121/210},
	author = {Jakub Kurzak and Piotr Luszczek and Ichitaro Yamazaki and Yves Robert and Jack Dongarra}
}
@techreport {1133,
	title = {Designing SLATE: Software for Linear Algebra Targeting Exascale},
	journal = {SLATE Working Notes},
	number = {03, ICL-UT-17-06},
	year = {2017},
	month = {2017-10},
	publisher = {Innovative Computing Laboratory, University of Tennessee},
	type = {SLATE Working Notes},
	author = {Jakub Kurzak and Panruo Wu and Mark Gates and Ichitaro Yamazaki and Piotr Luszczek and Gerald Ragghianti and Jack Dongarra}
}
@techreport {1130,
	title = {MAGMA-sparse Interface Design Whitepaper},
	journal = {Innovative Computing Laboratory Technical Report},
	number = {ICL-UT-17-05},
	year = {2017},
	month = {2017-09},
	type = {Technical Report},
	abstract = {In this report we describe the logic and interface we develop for the MAGMA-sparse library
to allow for easy integration as third-party library into a top-level software ecosystem. The
design choices are based on extensive consultation with other software library developers, in
particular the Trilinos software development team. The interface documentation is at this point
not exhaustive, but a first proposal for setting a standard. Although the interface description
targets the MAGMA-sparse software module, we hope that the design choices carry beyond this
specific library, and are attractive for adoption in other packages.
This report is not intended as static document, but will be updated over time to reflect the agile
software development in the ECP 1.3.3.11 STMS11-PEEKS project.},
	author = {Hartwig Anzt and Erik Boman and Jack Dongarra and Goran Flegar and Mark Gates and Mike Heroux and Mark Hoemmen and Jakub Kurzak and Piotr Luszczek and Sivasankaran Rajamanickam and Stanimire Tomov and Stephen Wood and Ichitaro Yamazaki}
}
@techreport {1173,
	title = {PLASMA 17 Performance Report},
	journal = {Innovative Computing Laboratory Technical Report},
	number = {ICL-UT-17-11},
	year = {2017},
	month = {2017-06},
	publisher = {University of Tennessee},
	abstract = {PLASMA (Parallel Linear Algebra for Multicore Architectures) is a dense linear algebra package at the forefront of multicore computing. PLASMA is designed to deliver the highest possible performance from a system with multiple sockets of multicore processors. PLASMA achieves this objective by combining state of the art solutions in parallel algorithms, scheduling, and software engineering. PLASMA currently offers a collection of routines for solving linear systems of equations and least square problems.},
	author = {Maksims Abalenkovs and Negin Bagherpour and Jack Dongarra and Mark Gates and Azzam Haidar and Jakub Kurzak and Piotr Luszczek and Samuel Relton and Jakub Sistek and David Stevens and Panruo Wu and Ichitaro Yamazaki and Asim YarKhan and Mawussi Zounon}
}
@techreport {1172,
	title = {PLASMA 17.1 Functionality Report},
	journal = {Innovative Computing Laboratory Technical Report},
	number = {ICL-UT-17-10},
	year = {2017},
	month = {2017-06},
	publisher = {University of Tennessee},
	abstract = {PLASMA (Parallel Linear Algebra for Multicore Architectures) is a dense linear algebra package at the forefront of multicore computing. PLASMA is designed to deliver the highest possible performance from a system with multiple sockets of multicore processors. PLASMA achieves this objective by combining state of the art solutions in parallel algorithms, scheduling, and software engineering. PLASMA currently offers a collection of routines for solving linear systems of equations and least square problems.},
	author = {Maksims Abalenkovs and Negin Bagherpour and Jack Dongarra and Mark Gates and Azzam Haidar and Jakub Kurzak and Piotr Luszczek and Samuel Relton and Jakub Sistek and David Stevens and Panruo Wu and Ichitaro Yamazaki and Asim YarKhan and Mawussi Zounon}
}
@techreport {1080,
	title = {Roadmap for the Development of a Linear Algebra Library for Exascale Computing: SLATE: Software for Linear Algebra Targeting Exascale},
	journal = {SLATE Working Notes},
	number = {01, ICL-UT-17-02},
	year = {2017},
	month = {2017-06},
	publisher = {Innovative Computing Laboratory, University of Tennessee},
	type = {SLATE Working Notes},
	author = {Ahmad Abdelfattah and Hartwig Anzt and Aurelien Bouteiller and Anthony Danalis and Jack Dongarra and Mark Gates and Azzam Haidar and Jakub Kurzak and Piotr Luszczek and Stanimire Tomov and Stephen Wood and Panruo Wu and Ichitaro Yamazaki and Asim YarKhan}
}
@conference {,
	title = {Scaling Point Set Registration in 3D Across Thread Counts on Multicore and Hardware Accelerator Platforms through Autotuning for Large Scale Analysis of Scientific Point Clouds},
	booktitle = {IEEE International Workshop on Benchmarking, Performance Tuning and Optimization for Big Data Applications (BPOD 2017)},
	year = {2017},
	month = {2017-12},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Boston, MA},
	abstract = {In this article, we present an autotuning approach applied to systematic performance engineering of the EM-ICP (Expectation-Maximization Iterative Closest Point) algorithm for the point set registration problem. We show how we were able to exceed the performance achieved by the reference code through multiple dependence transformations and automated procedure of generating and evaluating numerous implementation variants. Furthermore, we also managed to exploit code transformations that are not that common during manual optimization but yielded better performance in our tests for the EM-ICP algorithm. Finally, we maintained high levels of performance rate in a portable fashion across a wide range of HPC hardware platforms including multicore, many-core, and GPU-based accelerators. More importantly, the results indicate consistently high performance level and ability to move the task of data analysis through point-set registration to any modern compute platform without the concern of inferior asymptotic efficiency.},
	doi = {https://doi.org/10.1109/BigData.2017.8258258},
	author = {Piotr Luszczek and Jakub Kurzak and Ichitaro Yamazaki and David Keffer and Jack Dongarra}
}
@conference {,
	title = {Towards Numerical Benchmark for Half-Precision Floating Point Arithmetic},
	booktitle = {2017 IEEE High Performance Extreme Computing Conference (HPEC)},
	year = {2017},
	month = {2017-09},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Waltham, MA},
	abstract = {With NVIDA Tegra Jetson X1 and Pascal P100 GPUs, NVIDIA introduced hardware-based computation on FP16 numbers also called half-precision arithmetic. In this talk, we will introduce the steps required to build a viable benchmark for this new arithmetic format. This will include the connections to established IEEE floating point standards and existing HPC benchmarks. The discussion will focus on performance and numerical stability issues that are important for this kind of benchmarking and how they relate to NVIDIA platforms.},
	doi = {https://doi.org/10.1109/HPEC.2017.8091031},
	author = {Piotr Luszczek and Jakub Kurzak and Ichitaro Yamazaki and Jack Dongarra}
}
@article {,
	title = {With Extreme Computing, the Rules Have Changed},
	journal = {Computing in Science \& Engineering},
	volume = {19},
	year = {2017},
	month = {2017-05},
	pages = {52-62},
	abstract = {On the eve of exascale computing, traditional wisdom no longer applies. High-performance computing is gone as we know it. This article discusses a range of new algorithmic techniques emerging in the context of exascale computing, many of which defy the common wisdom of high-performance computing and are considered unorthodox, but could turn out to be a necessity in near future.},
	doi = {https://doi.org/10.1109/MCSE.2017.48},
	author = {Jack Dongarra and Stanimire Tomov and Piotr Luszczek and Jakub Kurzak and Mark Gates and Ichitaro Yamazaki and Hartwig Anzt and Azzam Haidar and Ahmad Abdelfattah}
}
@article {1472,
	title = {Linear Algebra Software for Large-Scale Accelerated Multicore Computing},
	journal = {Acta Numerica},
	volume = {25},
	year = {2016},
	month = {2016-05},
	pages = {1-160},
	abstract = {Many crucial scientific computing applications, ranging from national security to medical advances, rely on high-performance linear algebra algorithms and technologies, underscoring their importance and broad impact. Here we present the state-of-the-art design and implementation practices for the acceleration of the predominant linear algebra algorithms on large-scale accelerated multicore systems. Examples are given with fundamental dense linear algebra algorithms {\textendash} from the LU, QR, Cholesky, and LDLT factorizations needed for solving linear systems of equations, to eigenvalue and singular value decomposition (SVD) problems. The implementations presented are readily available via the open-source PLASMA and MAGMA libraries, which represent the next generation modernization of the popular LAPACK library for accelerated multicore systems. To generate the extreme level of parallelism needed for the efficient use of these systems, algorithms of interest are redesigned and then split into well-chosen computational tasks. The task execution is scheduled over the computational components of a hybrid system of multicore CPUs with GPU accelerators and/or Xeon Phi coprocessors, using either static scheduling or light-weight runtime systems. The use of light-weight runtime systems keeps scheduling overheads low, similar to static scheduling, while enabling the expression of parallelism through sequential-like code. This simplifies the development effort and allows exploration of the unique strengths of the various hardware components. Finally, we emphasize the development of innovative linear algebra algorithms using three technologies {\textendash} mixed precision arithmetic, batched operations, and asynchronous iterations {\textendash} that are currently of high interest for accelerated multicore systems.},
	doi = {10.1017/S0962492916000015},
	author = {Ahmad Abdelfattah and Hartwig Anzt and Jack Dongarra and Mark Gates and Azzam Haidar and Jakub Kurzak and Piotr Luszczek and Stanimire Tomov and undefined and Asim YarKhan}
}
@article {986,
	title = {Porting the PLASMA Numerical Library to the OpenMP Standard},
	journal = {International Journal of Parallel Programming},
	year = {2016},
	month = {2016-06},
	abstract = {PLASMA is a numerical library intended as a successor to LAPACK for solving problems in dense linear algebra on multicore processors. PLASMA relies on the QUARK scheduler for efficient multithreading of algorithms expressed in a serial fashion. QUARK is a superscalar scheduler and implements automatic parallelization by tracking data dependencies and resolving data hazards at runtime. Recently, this type of scheduling has been incorporated in the OpenMP standard, which allows to transition PLASMA from the proprietary solution offered by QUARK to the standard solution offered by OpenMP. This article studies the feasibility of such transition.},
	issn = {0885-7458},
	doi = {10.1007/s10766-016-0441-6},
	url = {http://link.springer.com/10.1007/s10766-016-0441-6http://link.springer.com/content/pdf/10.1007/s10766-016-0441-6http://link.springer.com/content/pdf/10.1007/s10766-016-0441-6.pdfhttp://link.springer.com/article/10.1007/s10766-016-0441-6/fulltext.html},
	author = {Asim YarKhan and Jakub Kurzak and Piotr Luszczek and Jack Dongarra}
}
@conference {962,
	title = {Search Space Generation and Pruning System for Autotuners},
	booktitle = {30th IEEE International Parallel \& Distributed Processing Symposium (IPDPS)},
	year = {2016},
	month = {2016-05},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Chicago, IL},
	abstract = {This work tackles two simultaneous challenges faced by autotuners: the ease of describing a complex, multidimensional search space, and the speed of evaluating that space, while applying a multitude of pruning constraints. This article presents a declarative notation for describing a search space and a translation system for conversion to a standard C code for fast and multithreaded, as necessary, evaluation. The notation is Python-based and thus simple in syntax and easy to assimilate by the user interested in tuning rather than learning a new programming language. A large number of dimensions and a large number of pruning constraints may be expressed with little effort. The system is discussed in the context of autotuning the canonical matrix multiplication kernel for NVIDIA GPUs, where the search space has 15 dimensions and involves application of 10 complex pruning constrains. The speed of evaluation is compared against generators created using imperative programming style in various scripting and compiled languages.},
	author = {Piotr Luszczek and Mark Gates and Jakub Kurzak and Anthony Danalis and Jack Dongarra}
}
@conference {880,
	title = {Accelerating Collaborative Filtering for Implicit Feedback Datasets using GPUs},
	booktitle = {2015 IEEE International Conference on Big Data (IEEE BigData 2015)},
	year = {2015},
	month = {2015-11},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Santa Clara, CA},
	abstract = {In this paper we accelerate the Alternating Least Squares (ALS) algorithm used for generating product recommendations on the basis of implicit feedback datasets. We approach the algorithm with concepts proven to be successful in High Performance Computing. This includes the formulation of the algorithm as a mix of cache-optimized algorithm-specific kernels and standard BLAS routines, acceleration via graphics processing units (GPUs), use of parallel batched kernels, and autotuning to identify performance winners. For benchmark datasets, the multi-threaded CPU implementation we propose achieves more than a 10 times speedup over the implementations available in the GraphLab and Spark MLlib software packages. For the GPU implementation, the parameters of an algorithm-specific kernel were optimized using a comprehensive autotuning sweep. This results in an additional 2 times speedup over our CPU implementation.},
	author = {Mark Gates and Hartwig Anzt and Jakub Kurzak and Jack Dongarra}
}
@conference {842,
	title = { A Data Flow Divide and Conquer Algorithm for Multicore Architecture},
	booktitle = {29th IEEE International Parallel \& Distributed Processing Symposium (IPDPS)},
	year = {2015},
	month = {2015-05},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Hyderabad, India},
	abstract = {Computing eigenpairs of a symmetric matrix is a problem arising in many industrial applications, including quantum physics and finite-elements computation for automobiles. A classical approach is to reduce the matrix to tridiagonal form before computing eigenpairs of the tridiagonal matrix. Then, a back-transformation allows one to obtain the final solution. Parallelism issues of the reduction stage have already been tackled in different shared-memory libraries. In this article, we focus on solving the tridiagonal eigenproblem, and we describe a novel implementation of the Divide and Conquer algorithm. The algorithm is expressed as a sequential task-flow, scheduled in an out-of-order fashion by a dynamic runtime which allows the programmer to play with tasks granularity. The resulting implementation is between two and five times faster than the equivalent routine from the Intel MKL library, and outperforms the best MRRR implementation for many matrices.},
	keywords = {Eigensolver, lapack, Multicore, plasma, task-based programming},
	author = {Azzam Haidar and Jakub Kurzak and Gregoire Pichon and Mathieu Faverge}
}
@article {873,
	title = {Experiences in autotuning matrix multiplication for energy minimization on GPUs},
	journal = {Concurrency in Computation: Practice and Experience},
	volume = {27},
	year = {2015},
	month = {2015-12},
	pages = {5096-5113},
	doi = {10.1002/cpe.3516},
	author = {Hartwig Anzt and Blake Haugen and Jakub Kurzak and Piotr Luszczek and Jack Dongarra}
}
@article {982,
	title = {Experiences in Autotuning Matrix Multiplication for Energy Minimization on GPUs},
	journal = {Concurrency and Computation: Practice and Experience},
	volume = {27},
	year = {2015},
	month = {12-Oct},
	pages = {5096 - 5113},
	abstract = {In this paper, we report extensive results and analysis of autotuning the computationally intensive graphics processing units kernel for dense matrix{\textendash}matrix multiplication in double precision. In contrast to traditional autotuning and/or optimization for runtime performance only, we also take the energy efficiency into account. For kernels achieving equal performance, we show significant differences in their energy balance. We also identify the memory throughput as the most influential metric that trades off performance and energy efficiency. As a result, the performance optimal case ends up not being the most efficient kernel in overall resource use.},
	keywords = {Autotuning, energy efficiency, hardware accelerators, matrix multiplication, power},
	doi = {10.1002/cpe.3516},
	url = {http://doi.wiley.com/10.1002/cpe.3516https://api.wiley.com/onlinelibrary/tdm/v1/articles/10.1002\%2Fcpe.3516},
	author = {Hartwig Anzt and Blake Haugen and Jakub Kurzak and Piotr Luszczek and Jack Dongarra}
}
@article {881,
	title = {Implementation and Tuning of Batched Cholesky Factorization and Solve for NVIDIA GPUs},
	journal = {IEEE Transactions on Parallel and Distributed Systems},
	number = {1045-9219},
	year = {2015},
	month = {2015-11},
	author = {Jakub Kurzak and Hartwig Anzt and Mark Gates and Jack Dongarra}
}
@conference {891,
	title = {Mixed-precision Block Gram Schmidt Orthogonalization},
	booktitle = {6th Workshop on Latest Advances in Scalable Algorithms for Large-Scale Systems},
	year = {2015},
	month = {2015-11},
	publisher = {ACM},
	organization = {ACM},
	address = {Austin, TX},
	abstract = {The mixed-precision Cholesky QR (CholQR) can orthogonalize the columns of a dense matrix with the minimum communication cost. Moreover, its orthogonality error depends only linearly to the condition number of the input matrix. However, when the desired higher-precision is not supported by the hardware, the software-emulated arithmetics are needed, which could significantly increase its computational cost. When there are a large number of columns to be orthogonalized, this computational overhead can have a significant
impact on the orthogonalization time, and the mixed-precision CholQR can be much slower than the standard CholQR. In this paper, we examine several block variants of the algorithm, which reduce the computational overhead associated with the software-emulated arithmetics, while maintaining the same orthogonality error bound as the mixed-precision CholQR. Our numerical and performance results on multicore CPUs with a GPU, as well as a hybrid CPU/GPU cluster, demonstrate that compared to the mixed-precision CholQR, such a block variant can obtain speedups of up to 7:1 while maintaining about the same order of the numerical errors.},
	author = {Ichitaro Yamazaki and Stanimire Tomov and Jakub Kurzak and Jack Dongarra and Jesse Barlow}
}
@conference {897,
	title = {Mixed-precision orthogonalization process Performance on multicore CPUs with GPUs},
	booktitle = {2015 SIAM Conference on Applied Linear Algebra},
	year = {2015},
	month = {2015-10},
	publisher = {SIAM},
	organization = {SIAM},
	address = {Atlanta, GA},
	abstract = {Orthogonalizing a set of dense vectors is an important computational kernel in subspace projection methods for solving large-scale problems. In this talk, we discuss our efforts to improve the performance of the kernel, while maintaining its numerical accuracy. Our experimental results demonstrate the effectiveness of our approaches.},
	author = {Ichitaro Yamazaki and Jesse Barlow and Stanimire Tomov and Jakub Kurzak and Jack Dongarra}
}
@article {936,
	title = {Parallel Programming Models for Dense Linear Algebra on Heterogeneous Systems},
	journal = {Supercomputing Frontiers and Innovations},
	volume = {2},
	number = {4},
	year = {2015},
	month = {2015-10},
	abstract = {We present a review of the current best practices in parallel programming models for dense linear algebra (DLA) on heterogeneous architectures. We consider multicore CPUs, stand alone manycore coprocessors, GPUs, and combinations of these. Of interest is the evolution of the programming models for DLA libraries {\textendash} in particular, the evolution from the popular LAPACK and ScaLAPACK libraries to their modernized counterparts PLASMA (for multicore CPUs) and MAGMA (for heterogeneous architectures), as well as other programming models and libraries. Besides providing insights into the programming techniques of the libraries considered, we outline our view of the current strengths and weaknesses of their programming models {\textendash} especially in regards to hardware trends and ease of programming high-performance numerical software that current applications need {\textendash} in order to motivate work and future directions for the next generation of parallel programming models for high-performance linear algebra libraries on heterogeneous systems.},
	keywords = {dense linear algebra, gpu, HPC, Multicore, plasma, Programming models, runtime},
	doi = {10.14529/jsfi1504},
	author = {Maksims Abalenkovs and Ahmad Abdelfattah and Jack Dongarra and Mark Gates and Azzam Haidar and Jakub Kurzak and Piotr Luszczek and Stanimire Tomov and Ichitaro Yamazaki and Asim YarKhan}
}
@conference {884,
	title = {Performance of Random Sampling for Computing Low-rank Approximations of a Dense Matrix on GPUs},
	booktitle = {The International Conference for High Performance Computing, Networking, Storage and Analysis (SC15)},
	year = {2015},
	month = {2015-11},
	publisher = {ACM},
	organization = {ACM},
	address = {Austin, TX},
	author = {Theo Mary and Ichitaro Yamazaki and Jakub Kurzak and Piotr Luszczek and Stanimire Tomov and Jack Dongarra}
}
@conference {885,
	title = {Randomized Algorithms to Update Partial Singular Value Decomposition on a Hybrid CPU/GPU Cluster},
	booktitle = {The International Conference for High Performance Computing, Networking, Storage and Analysis (SC15)},
	year = {2015},
	month = {2015-11},
	publisher = {ACM},
	organization = {ACM},
	address = {Austin, TX},
	author = {Ichitaro Yamazaki and Jakub Kurzak and Piotr Luszczek and Jack Dongarra}
}
@article {699,
	title = {A Survey of Recent Developments in Parallel Implementations of Gaussian Elimination},
	journal = {Concurrency and Computation: Practice and Experience},
	volume = {27},
	year = {2015},
	month = {2015-04},
	pages = {1292-1309},
	abstract = {Gaussian elimination is a canonical linear algebra procedure for solving linear systems of equations. In the last few years, the algorithm has received a lot of attention in an attempt to improve its parallel performance. This article surveys recent developments in parallel implementations of Gaussian elimination for shared memory architecture. Five different flavors are investigated. Three of them are based on different strategies for pivoting: partial pivoting, incremental pivoting, and tournament pivoting. The fourth one replaces pivoting with the Partial Random Butterfly Transformation, and finally, an implementation without pivoting is used as a performance baseline. The technique of iterative refinement is applied to recover numerical accuracy when necessary. All parallel implementations are produced using dynamic, superscalar, runtime scheduling and tile matrix layout. Results on two multisocket multicore systems are presented. Performance and numerical accuracy is analyzed.},
	keywords = {Gaussian elimination, lu factorization, Multicore, parallel, plasma, shared memory},
	doi = {10.1002/cpe.3306},
	author = {Simplice Donfack and Jack Dongarra and Mathieu Faverge and Mark Gates and Jakub Kurzak and Piotr Luszczek and Ichitaro Yamazaki}
}
@conference {892,
	title = {Visualizing Execution Traces with Task Dependencies},
	booktitle = {2nd Workshop on Visual Performance Analysis (VPA {\textquoteright}15)},
	year = {2015},
	month = {2015-11},
	publisher = {ACM},
	organization = {ACM},
	address = {Austin, TX},
	abstract = {Task-based scheduling has emerged as one method to reduce the complexity of parallel computing. When using task-based schedulers, developers must frame their computation as a series of tasks with various data dependencies. The scheduler can take these tasks, along with their input and output dependencies, and schedule the task in parallel across a node or cluster. While these schedulers simplify the process of parallel software development, they can obfuscate the performance characteristics of the execution of an algorithm. The execution trace has been used for many years to give developers a visual representation of how their computations are performed. These methods can be employed to visualize when and where each of the tasks in a task-based algorithm is scheduled. In addition, the task dependencies can be used to create a directed acyclic graph (DAG) that can also be visualized to demonstrate the dependencies of the various tasks that make up a workload. The work presented here aims to combine these two data sets and extend execution trace visualization to better suit task-based workloads. This paper presents a brief description of task-based schedulers and the performance data they produce. It will then describe an interactive extension to the current trace visualization methods that combines the trace and DAG data sets. This new tool allows users to gain a greater understanding of how their tasks are scheduled. It also provides a simplified way for developers to evaluate and debug the performance of their scheduler. },
	author = {Blake Haugen and Stephen Richmond and Jakub Kurzak and Chad A. Steed and Jack Dongarra}
}
@inbook {780,
	title = {Accelerating Numerical Dense Linear Algebra Calculations with GPUs},
	booktitle = {Numerical Computations with GPUs},
	year = {2014},
	pages = {3-28},
	publisher = {Springer International Publishing},
	organization = {Springer International Publishing},
	chapter = {1},
	isbn = {978-3-319-06547-2},
	doi = {10.1007/978-3-319-06548-9_1},
	author = {Jack Dongarra and Mark Gates and Azzam Haidar and Jakub Kurzak and Piotr Luszczek and Stanimire Tomov and Ichitaro Yamazaki}
}
@conference {818,
	title = {Access-averse Framework for Computing Low-rank Matrix Approximations},
	booktitle = {First International Workshop on High Performance Big Graph Data Management, Analysis, and Mining},
	year = {2014},
	month = {2014-10},
	address = {Washington, DC},
	author = {Ichitaro Yamazaki and Theo Mary and Jakub Kurzak and Stanimire Tomov and Jack Dongarra}
}
@conference {710,
	title = {Design and Implementation of a Large Scale Tree-Based QR Decomposition Using a 3D Virtual Systolic Array and a Lightweight Runtime},
	booktitle = {Workshop on Large-Scale Parallel Processing, IPDPS 2014},
	year = {2014},
	month = {2014-05},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Phoenix, AZ},
	abstract = {A systolic array provides an alternative computing paradigm to the von Neuman architecture. Though its hardware implementation has failed as a paradigm to design integrated circuits in the past, we are now discovering that the systolic array as a software virtualization layer can lead to an extremely scalable execution paradigm. To demonstrate this scalability, in this paper, we design and implement a 3D virtual systolic array to compute a tile QR decomposition of a tall-and-skinny dense matrix. Our implementation is based on a state-of-the-art algorithm that factorizes a panel based on a tree-reduction. Using a runtime developed as a part of the Parallel Ultra Light Systolic Array Runtime (PULSAR) project, we demonstrate on a Cray-XT5 machine how our virtual systolic array can be mapped to a large-scale machine and obtain excellent parallel performance. This is an important contribution since such a QR decomposition is used, for example, to compute a least squares solution of an overdetermined system, which arises in many scientific and engineering problems.},
	keywords = {dataflow, message-passing, multithreading, QR decomposition, runtime, systolic array},
	author = {Ichitaro Yamazaki and Jakub Kurzak and Piotr Luszczek and Jack Dongarra}
}
@article {760,
	title = {Looking Back at Dense Linear Algebra Software},
	journal = {Journal of Parallel and Distributed Computing},
	volume = {74},
	year = {2014},
	month = {2014-07},
	pages = {2548{\textendash}2560},
	chapter = {2548},
	abstract = {Over the years, computational physics and chemistry served as an ongoing source of problems that demanded the ever increasing performance from hardware as well as the software that ran on top of it. Most of these problems could be translated into solutions for systems of linear equations: the very topic of numerical linear algebra. Seemingly then, a set of efficient linear solvers could be solving important scientific problems for years to come. We argue that dramatic changes in hardware designs precipitated by the shifting nature of the marketplace of computer hardware had a continuous effect on the software for numerical linear algebra. The extraction of high percentages of peak performance continues to require adaptation of software. If the past history of this adaptive nature of linear algebra software is any guide then the future theme will feature changes as well{\textendash}changes aimed at harnessing the incredible advances of the evolving hardware infrastructure.},
	keywords = {decompositional approach, dense linear algebra, parallel algorithms},
	doi = {10.1016/j.jpdc.2013.10.005},
	author = {Piotr Luszczek and Jakub Kurzak and Jack Dongarra}
}
@article {831,
	title = {Model-Driven One-Sided Factorizations on Multicore, Accelerated Systems},
	journal = {Supercomputing Frontiers and Innovations},
	volume = {1},
	year = {2014},
	abstract = {Hardware heterogeneity of the HPC platforms is no longer considered unusual but instead have become the most viable way forward towards Exascale.  In fact, the multitude of the heterogeneous resources available to modern computers are designed for different workloads and their efficient use is closely aligned with the specialized role envisaged by their design.  Commonly in order to efficiently use such GPU resources, the workload in question must have a much greater degree of parallelism than workloads often associated with multicore processors (CPUs).  Available GPU variants differ in their internal architecture and, as a result, are capable of handling workloads of varying degrees of complexity and a range of computational patterns.  This vast array of applicable workloads will likely lead to an ever accelerated mixing of multicore-CPUs and GPUs in multi-user environments with the ultimate goal of offering adequate computing facilities for a wide range of scientific and technical workloads.  In the following paper, we present a research prototype that uses a lightweight runtime environment to manage the resource-specific workloads, and to control the dataflow and parallel execution in hybrid systems.  Our lightweight runtime environment uses task superscalar concepts to enable the developer to write serial code while providing parallel execution.  This concept is reminiscent of dataflow and systolic architectures in its conceptualization of a workload as a set of side-effect-free tasks that pass data items whenever the associated work assignment have been completed.  Additionally, our task abstractions and their parametrization enable uniformity in the algorithmic development across all the heterogeneous resources without sacrificing precious compute cycles.  We include performance results for dense linear algebra functions which demonstrate the practicality and effectiveness of our approach that is aptly capable of full utilization of a wide range of accelerator hardware.},
	keywords = {dense linear algebra, hardware accelerators, task superscalar scheduling},
	doi = {http://dx.doi.org/10.14529/jsfi1401},
	author = {Jack Dongarra and Azzam Haidar and Jakub Kurzak and Piotr Luszczek and Stanimire Tomov and Asim YarKhan}
}
@techreport {827,
	title = {PULSAR Users{\textquoteright} Guide, Parallel Ultra-Light Systolic Array Runtime},
	journal = {University of Tennessee EECS Technical Report},
	number = {UT-EECS-14-733},
	year = {2014},
	month = {2014-11},
	publisher = {University of Tennessee},
	abstract = {PULSAR version 2.0, released in November 2014, is a complete programming platform for large-scale distributed memory systems with multicore processors and hardware accelerators. PULSAR provides a simple abstraction layer over multithreading, message passing, and multi-GPU, multi-stream programming. PULSAR offers a general-purpose programming model, suitable for a wide range of scientific and engineering applications. PULSAR was inspired by systolic arrays, popularized by Hsiang-Tsung Kung and Charles E. Leiserson.},
	author = {Jack Dongarra and Jakub Kurzak and Piotr Luszczek and Ichitaro Yamazaki}
}
@conference {879,
	title = {Search Space Pruning Constraints Visualization},
	booktitle = {VISSOFT{\textquoteright}14: 2nd IEEE Working Conference on Software Visualization},
	year = {2014},
	month = {2014-09},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Victoria, BC, Canada},
	abstract = {The field of software optimization, among others, is interested in finding an optimal solution in a large search space. These search spaces are often large, complex, non-linear and even non-continuous at times. The size of the search space makes a brute force solution intractable. As a result, one or more search space pruning constraints are often used to reduce the number of candidate configurations that must be evaluated in order to solve the optimization problem.

If more than one pruning constraint is employed, it can be challenging to understand how the pruning constraints interact and overlap. This work presents a visualization technique based on a radial, space-filling technique that allows the user to gain a better understanding of how the pruning constraints remove candidates from the search space. The technique is then demonstrated using a search space pruning data set derived from the optimization of a matrix multiplication code for NVIDIA CUDA accelerators.},
	author = {Blake Haugen and Jakub Kurzak}
}
@techreport {682,
	title = {Implementing a systolic algorithm for QR factorization on multicore clusters with PaRSEC},
	journal = {Lawn 277},
	number = {UT-CS-13-709},
	year = {2013},
	month = {2013-05},
	abstract = {This article introduces a new systolic algorithm for QR factorization, and its implementation on a supercomputing cluster of multicore nodes. The algorithm targets a virtual 3D-array and requires only local communications. The implementation of the algorithm uses threads at the node level, and MPI for inter-node communications. The complexity of the implementation is addressed with the PaRSEC software, which takes as input a parametrized dependence graph, which is derived from the algorithm, and only requires the user to decide, at the high-level, the allocation of tasks to nodes. We show that the new algorithm exhibits competitive performance with state-of-the-art QR routines on a supercomputer called Kraken, which shows that high-level programming environments, such as PaRSEC, provide a viable alternative to enhance the production of quality software on complex and hierarchical architectures},
	author = {Guillaume Aupy and Mathieu Faverge and Yves Robert and Jakub Kurzak and Piotr Luszczek and Jack Dongarra}
}
@techreport {704,
	title = {An Improved Parallel Singular Value Algorithm and Its Implementation for Multicore Hardware},
	journal = {University of Tennessee Computer Science Technical Report (also LAWN 283)},
	number = {ut-eecs-13-720},
	year = {2013},
	month = {2013-10},
	publisher = {University of Tennessee},
	keywords = {lapack, plasma, scalapack},
	author = {Azzam Haidar and Piotr Luszczek and Jakub Kurzak and Jack Dongarra}
}
@conference {696,
	title = {An Improved Parallel Singular Value Algorithm and Its Implementation for Multicore Hardware},
	booktitle = {Supercomputing 2013},
	year = {2013},
	month = {2013-11},
	address = {Denver, CO},
	author = {Azzam Haidar and Piotr Luszczek and Jakub Kurzak and Jack Dongarra}
}
@article {icl:693,
	title = {LU Factorization with Partial Pivoting for a Multicore System with Accelerators},
	journal = {IEEE Transactions on Parallel and Distributed Computing},
	volume = {24},
	year = {2013},
	month = {2013-08},
	pages = {1613-1621},
	chapter = {1613},
	abstract = {LU factorization with partial pivoting is a canonical numerical procedure and the main component of the high performance LINPACK benchmark. This paper presents an implementation of the algorithm for a hybrid, shared memory, system with standard CPU cores and GPU accelerators. The difficulty of implementing the algorithm for such a system lies in the disproportion between the computational power of the CPUs, compared to the GPUs, and in the meager bandwidth of the communication link between their memory systems. An additional challenge comes from the complexity of the memory-bound and synchronization-rich nature of the panel factorization component of the block LU algorithm, imposed by the use of partial pivoting. The challenges are tackled with the use of a data layout geared toward complex memory hierarchies, autotuning of GPU kernels, fine-grain parallelization of memory-bound CPU operations and dynamic scheduling of tasks to different devices. Performance in excess of one TeraFLOPS is achieved using four AMD Magny Cours CPUs and four NVIDIA Fermi GPUs.},
	keywords = {accelerator, Gaussian elimination, gpu, lu factorization, manycore, Multicore, partial pivoting, plasma},
	doi = {http://doi.ieeecomputersociety.org/10.1109/TPDS.2012.242},
	author = {Jakub Kurzak and Piotr Luszczek and Jack Dongarra}
}
@article {icl:704,
	title = {Multithreading in the PLASMA Library},
	journal = {Multi and Many-Core Processing: Architecture, Programming, Algorithms, \& Applications},
	year = {2013},
	month = {2013-00},
	publisher = {Taylor \& Francis},
	keywords = {plasma},
	author = {Jakub Kurzak and Piotr Luszczek and Asim YarKhan and Mathieu Faverge and Julien Langou and Henricus Bouwmeester and Jack Dongarra},
	editor = {Mohamed Ahmed and Reda Ammar and Sanguthevar Rajasekaran}
}
@inbook {695,
	title = {Scalable Dense Linear Algebra on Heterogeneous Hardware},
	booktitle = {HPC: Transition Towards Exascale Processing, in the series Advances in Parallel Computing},
	year = {2013},
	abstract = {Abstract. Design of systems exceeding 1 Pflop/s and the push toward 1 Eflop/s, forced a dramatic shift in hardware design. Various physical and engineering constraints resulted in introduction of massive parallelism and functional hybridization with the use of accelerator units. This paradigm change brings about a serious challenge for application developers, as the management of multicore proliferation and heterogeneity rests on software. And it is reasonable to expect, that this situation will not change in the foreseeable future. This chapter presents a methodology of dealing with this issue in three common scenarios. In the context of shared-memory multicore installations, we show how high performance and scalability go hand in hand, when the well-known linear algebra algorithms are recast in terms of Direct Acyclic Graphs (DAGs), which are then transparently scheduled at runtime inside the Parallel Linear Algebra Software for Multicore Architectures (PLASMA) project. Similarly, Matrix Algebra on GPU and Multicore Architectures (MAGMA) schedules DAG-driven computations on multicore processors and accelerators. Finally, Distributed PLASMA (DPLASMA), takes the approach to distributed-memory machines with the use of automatic dependence analysis and the Direct Acyclic Graph Engine (DAGuE) to deliver high performance at the scale of many thousands of cores.},
	author = {George Bosilca and Aurelien Bouteiller and Anthony Danalis and Thomas Herault and Jakub Kurzak and Piotr Luszczek and Stanimire Tomov and Jack Dongarra}
}
@conference {icl:692,
	title = {Virtual Systolic Array for QR Decomposition},
	booktitle = {15th Workshop on Advances in Parallel and Distributed Computational Models, IEEE International Parallel \& Distributed Processing Symposium (IPDPS 2013)},
	year = {2013},
	month = {2013-05},
	publisher = {IEEE},
	organization = {IEEE},
	address = {Boston, MA},
	abstract = {Systolic arrays offer a very attractive, data-centric, execution model as an alternative to the von Neumann architecture. Hardware implementations of systolic arrays turned out not to be viable solutions in the past. This article shows how the systolic design principles can be applied to a software solution to deliver an algorithm with unprecedented strong scaling capabilities. Systolic array for the QR decomposition is developed and a virtualization layer is used for mapping of the algorithm to a large distributed memory system. Strong scaling properties are discovered, superior to existing solutions.},
	keywords = {dataflow programming, message passing, multi-core, QR decomposition, roofline model, systolic array},
	doi = {10.1109/IPDPS.2013.119},
	author = {Jakub Kurzak and Piotr Luszczek and Mark Gates and Ichitaro Yamazaki and Jack Dongarra}
}
@techreport {688,
	title = {On Algorithmic Variants of Parallel Gaussian Elimination: Comparison of Implementations in Terms of Performance and Numerical Properties},
	journal = {University of Tennessee Computer Science Technical Report},
	number = {UT-CS-13-715},
	year = {2012},
	month = {2013-07},
	abstract = {Gaussian elimination is a canonical linear algebra procedure for solving linear systems of equations. In the last few years, the algorithm received a lot of attention in an attempt to improve its parallel performance. This article surveys recent developments in parallel implementations of the Gaussian elimination. Five different flavors are investigated. Three of them are based on different strategies for pivoting: partial pivoting, incremental pivoting, and tournament pivoting. The fourth one replaces pivoting with the Random Butterfly Transformation, and finally, an implementation without pivoting is used as a performance baseline. The technique of iterative refinement is applied to recover numerical accuracy when necessary. All parallel implementations are produced using dynamic, superscalar, runtime scheduling and tile matrix layout. Results on two multi-socket multicore systems are presented. Performance and numerical accuracy is analyzed.},
	author = {Simplice Donfack and Jack Dongarra and Mathieu Faverge and Mark Gates and Jakub Kurzak and Piotr Luszczek and Ichitaro Yamazaki}
}
@article {,
	title = {Autotuning GEMM Kernels for the Fermi GPU},
	journal = {IEEE Transactions on Parallel and Distributed Systems},
	volume = {23},
	number = {11},
	year = {2012},
	month = {2012-11},
	abstract = {Abstract{\textemdash}In recent years, the use of graphics chips has been recognized as a viable way of accelerating scientific and engineering applications, even more so since the introduction of the Fermi architecture by NVIDIA, with features essential to numerical computing, such as fast double precision arithmetic and memory protected with error correction codes. Being the crucial component of numerical software packages, such as LAPACK and ScaLAPACK, the general dense matrix multiplication routine is one of the more important workloads to be implemented on these devices. This paper presents a methodology for producing matrix multiplication kernels tuned for a specific architecture, through a canonical process of heuristic autotuning, based on generation of multiple code variants and selecting the fastest ones through benchmarking. The key contribution of this work is in the method for generating the search space; specifically, pruning it to a manageable size. Performance numbers match or exceed other available implementations.},
	doi = {https://doi.org/10.1109/TPDS.2011.311},
	author = {Jakub Kurzak and Stanimire Tomov and Jack Dongarra}
}
@article {icl:703,
	title = {Dense Linear Algebra on Accelerated Multicore Hardware},
	journal = {High Performance Scientific Computing: Algorithms and Applications},
	year = {2012},
	month = {2012-00},
	publisher = {Springer-Verlag},
	address = {London, UK},
	author = {Jack Dongarra and Jakub Kurzak and Piotr Luszczek and Stanimire Tomov},
	editor = {Michael Berry and et al.,}
}
@article {icl:690,
	title = {An Implementation of the Tile QR Factorization for a GPU and Multiple CPUs},
	journal = {Applied Parallel and Scientific Computing},
	volume = {7133},
	year = {2012},
	month = {2012-00},
	pages = {248-257},
	author = {Jakub Kurzak and Rajib Nath and Peng Du and Jack Dongarra},
	editor = {Kristj{\'a}n J{\'o}nasson}
}
@article {icl:705,
	title = {Looking Back at Dense Linear Algebra Software},
	journal = {Perspectives on Parallel and Distributed Processing: Looking Back and What{\textquoteright}s Ahead (to appear)},
	year = {2012},
	month = {2012-00},
	author = {Piotr Luszczek and Jakub Kurzak and Jack Dongarra},
	editor = {Viktor K. Prasanna and Yves Robert and Per Stenstr{\"o}m}
}
@article {icl:718,
	title = {Preliminary Results of Autotuning GEMM Kernels for the NVIDIA Kepler Architecture},
	journal = {LAWN 267},
	year = {2012},
	month = {2012-00},
	author = {Jakub Kurzak and Piotr Luszczek and Stanimire Tomov and Jack Dongarra}
}
@inproceedings {icl:665,
	title = {Programming the LU Factorization for a Multicore System with Accelerators},
	journal = {Proceedings of VECPAR{\textquoteright}12},
	year = {2012},
	month = {2012-04},
	address = {Kobe, Japan},
	keywords = {plasma, quark},
	author = {Jakub Kurzak and Piotr Luszczek and Mathieu Faverge and Jack Dongarra}
}
@techreport {icl:630,
	title = {Autotuning GEMMs for Fermi},
	journal = {University of Tennessee Computer Science Technical Report, UT-CS-11-671, (also Lawn 245)},
	year = {2011},
	month = {2011-04},
	keywords = {magma},
	author = {Jakub Kurzak and Stanimire Tomov and Jack Dongarra}
}
@article {icl:587,
	title = {Changes in Dense Linear Algebra Kernels - Decades Long Perspective},
	journal = {in Solving the Schrodinger Equation: Has everything been tried? (to appear)},
	year = {2011},
	month = {2011-00},
	publisher = {Imperial College Press},
	author = {Piotr Luszczek and Jakub Kurzak and Jack Dongarra},
	editor = {P. Popular}
}
@inproceedings {icl:676,
	title = {Flexible Development of Dense Linear Algebra Algorithms on Massively Parallel Architectures with DPLASMA},
	journal = {Proceedings of the Workshops of the 25th IEEE International Symposium on Parallel and Distributed Processing (IPDPS 2011 Workshops)},
	year = {2011},
	month = {2011-05},
	pages = {1432-1441},
	publisher = {IEEE},
	address = {Anchorage, Alaska, USA},
	keywords = {dague, dplasma, parsec},
	author = {George Bosilca and Aurelien Bouteiller and Anthony Danalis and Mathieu Faverge and Azzam Haidar and Thomas Herault and Jakub Kurzak and Julien Langou and Pierre Lemariner and Hatem Ltaeif and Piotr Luszczek and Asim YarKhan and Jack Dongarra}
}
@techreport {icl:609,
	title = {QUARK Users{\textquoteright} Guide: QUeueing And Runtime for Kernels},
	journal = {University of Tennessee Innovative Computing Laboratory Technical Report},
	number = {ICL-UT-11-02},
	year = {2011},
	month = {2011-00},
	keywords = {magma, plasma, quark},
	author = {Asim YarKhan and Jakub Kurzak and Jack Dongarra}
}
@article {icl:572,
	title = {A Class of Parallel Tiled Linear Algebra Algorithms for Multicore Architectures},
	journal = {Parallel Computing (to appear)},
	year = {2010},
	month = {2010-00},
	author = {Alfredo Buttari and Julien Langou and Jakub Kurzak and Jack Dongarra}
}
@techreport {icl:563,
	title = {Distributed Dense Numerical Linear Algebra Algorithms on Massively Parallel Architectures: DPLASMA},
	journal = {University of Tennessee Computer Science Technical Report, UT-CS-10-660},
	year = {2010},
	month = {2010-09},
	keywords = {dague, dplasma, parsec, plasma},
	author = {George Bosilca and Aurelien Bouteiller and Anthony Danalis and Mathieu Faverge and Azzam Haidar and Thomas Herault and Jakub Kurzak and Julien Langou and Pierre Lemariner and Hatem Ltaeif and Piotr Luszczek and Asim YarKhan and Jack Dongarra}
}
@techreport {icl:529,
	title = {Distributed-Memory Task Execution and Dependence Tracking within DAGuE and the DPLASMA Project},
	journal = {Innovative Computing Laboratory Technical Report},
	number = {ICL-UT-10-02},
	year = {2010},
	month = {2010-00},
	keywords = {dague, plasma},
	author = {George Bosilca and Aurelien Bouteiller and Anthony Danalis and Mathieu Faverge and Azzam Haidar and Thomas Herault and Jakub Kurzak and Julien Langou and Pierre Lemariner and Hatem Ltaeif and Piotr Luszczek and Asim YarKhan and Jack Dongarra}
}
@article {icl:569,
	title = {Parallel Band Two-Sided Matrix Bidiagonalization for Multicore Architectures},
	journal = {IEEE Transactions on Parallel and Distributed Systems},
	year = {2010},
	month = {2010-04},
	pages = {417-423},
	author = {Hatem Ltaeif and Jakub Kurzak and Jack Dongarra}
}
@article {icl:571,
	title = {QR Factorization for the CELL Processor},
	journal = {Scientific Programming},
	volume = {17},
	number = {1-2},
	year = {2010},
	month = {2010-00},
	pages = {31-42},
	author = {Jakub Kurzak and Jack Dongarra}
}
@article {icl:540,
	title = {Scheduling Dense Linear Algebra Operations on Multicore Processors},
	journal = {Concurrency and Computation: Practice and Experience},
	volume = {22},
	number = {1},
	year = {2010},
	month = {2010-01},
	pages = {15-44},
	keywords = {gridpac, plasma},
	author = {Jakub Kurzak and Hatem Ltaeif and Jack Dongarra and Rosa M. Badia}
}
@article {icl:473,
	title = {Scheduling Two-sided Transformations using Tile Algorithms on Multicore Architectures},
	journal = {Journal of Scientific Computing},
	volume = {18},
	number = {1},
	year = {2010},
	month = {2010-00},
	pages = {33-50},
	keywords = {plasma},
	author = {Hatem Ltaeif and Jakub Kurzak and Jack Dongarra and Rosa M. Badia}
}
@article {,
	title = {Accelerating Scientific Computations with Mixed Precision Algorithms},
	journal = {Computer Physics Communications},
	volume = {180},
	year = {2009},
	month = {2009-12},
	pages = {2526-2533},
	abstract = {On modern architectures, the performance of 32-bit operations is often at least twice as fast as the performance of 64-bit operations. By using a combination of 32-bit and 64-bit floating point arithmetic, the performance of many dense and sparse linear algebra algorithms can be significantly enhanced while maintaining the 64-bit accuracy of the resulting solution. The approach presented here can apply not only to conventional processors but also to other technologies such as Field Programmable Gate Arrays (FPGA), Graphical Processing Units (GPU), and the STI Cell BE processor. Results on modern processor architectures and the STI Cell BE are presented.},
	doi = {https://doi.org/10.1016/j.cpc.2008.11.005},
	author = {Marc Baboulin and Alfredo Buttari and Jack Dongarra and Jakub Kurzak and Julie Langou and Julien Langou and Piotr Luszczek and Stanimire Tomov}
}
@article {icl:509,
	title = {A Class of Parallel Tiled Linear Algebra Algorithms for Multicore Architectures},
	journal = {Parallel Computing},
	volume = {35},
	year = {2009},
	month = {2009-00},
	pages = {38-53},
	keywords = {plasma},
	author = {Alfredo Buttari and Julien Langou and Jakub Kurzak and Jack Dongarra}
}
@article {icl:518,
	title = {Dependency-Driven Scheduling of Dense Matrix Factorizations on Shared-Memory Systems},
	journal = {PPAM 2009},
	year = {2009},
	month = {2009-09},
	address = {Poland},
	author = {Jakub Kurzak and Hatem Ltaeif and Jack Dongarra and Rosa M. Badia}
}
@techreport {icl:494,
	title = {Fully Dynamic Scheduler for Numerical Computing on Multicore Processors},
	journal = {University of Tennessee Computer Science Department Technical Report, UT-CS-09-643 (Also LAPACK Working Note 220)},
	year = {2009},
	month = {2009-00},
	author = {Jakub Kurzak and Jack Dongarra}
}
@article {1352,
	title = {Numerical Linear Algebra on Emerging Architectures: The PLASMA and MAGMA Projects},
	year = {2009},
	month = {2009-11},
	publisher = {The International Conference for High Performance Computing, Networking, Storage, and Analysis (SC09)},
	address = {Portland, OR},
	author = {Emmanuel Agullo and James Demmel and Jack Dongarra and Bilel Hadri and Jakub Kurzak and Julien Langou and Hatem Ltaeif and Piotr Luszczek and Rajib Nath and Stanimire Tomov and Asim YarKhan and Vasily Volkov}
}
@inproceedings {icl:486,
	title = {Numerical Linear Algebra on Emerging Architectures: The PLASMA and MAGMA Projects},
	journal = {Journal of Physics: Conference Series},
	volume = {180},
	year = {2009},
	month = {2009-00},
	keywords = {magma, plasma},
	author = {Emmanuel Agullo and James Demmel and Jack Dongarra and Bilel Hadri and Jakub Kurzak and Julien Langou and Hatem Ltaeif and Piotr Luszczek and Stanimire Tomov}
}
@article {icl:492,
	title = {Optimizing Matrix Multiplication for a Short-Vector SIMD Architecture - CELL Processor},
	journal = {Parallel Computing},
	volume = {35},
	year = {2009},
	month = {2009-00},
	pages = {138-150},
	author = {Wesley Alvaro and Jakub Kurzak and Jack Dongarra}
}
@article {icl:489,
	title = {Parallel Band Two-Sided Matrix Bidiagonalization for Multicore Architectures},
	journal = {IEEE Transactions on Parallel and Distributed Systems (to appear)},
	year = {2009},
	month = {2009-05},
	author = {Hatem Ltaeif and Jakub Kurzak and Jack Dongarra}
}
@article {icl:505,
	title = {Parallel Dense Linear Algebra Software in the Multicore Era},
	journal = {in Cyberinfrastructure Technologies and Applications},
	year = {2009},
	month = {2009-00},
	pages = {9-24},
	publisher = {Nova Science Publishers, Inc.},
	keywords = {plasma},
	author = {Alfredo Buttari and Jack Dongarra and Jakub Kurzak and Julien Langou},
	editor = {Junwei Cao}
}
@article {icl:508,
	title = {QR Factorization for the CELL Processor},
	journal = {Scientific Programming (to appear)},
	year = {2009},
	month = {2009-00},
	keywords = {plasma},
	author = {Jakub Kurzak and Jack Dongarra}
}
@techreport {icl:495,
	title = {Scheduling Linear Algebra Operations on Multicore Processors},
	journal = {University of Tennessee Computer Science Department Technical Report, UT-CS-09-636 (Also LAPACK Working Note 213)},
	year = {2009},
	month = {2009-00},
	author = {Jakub Kurzak and Hatem Ltaeif and Jack Dongarra and Rosa M. Badia}
}
@article {icl:510,
	title = {Scheduling Linear Algebra Operations on Multicore Processors},
	journal = {Concurrency Practice and Experience (to appear)},
	year = {2009},
	month = {2009-00},
	keywords = {plasma},
	author = {Jakub Kurzak and Hatem Ltaeif and Jack Dongarra and Rosa M. Badia}
}
@article {icl:449,
	title = {Exploiting Mixed Precision Floating Point Hardware in Scientific Computations},
	journal = {in High Performance Computing and Grids in Action},
	year = {2008},
	month = {2008-01},
	publisher = {IOS Press},
	address = {Amsterdam},
	author = {Alfredo Buttari and Jack Dongarra and Jakub Kurzak and Julien Langou and Julien Langou and Piotr Luszczek and Stanimire Tomov},
	editor = {Lucio Grandinetti}
}
@techreport {icl:405,
	title = {Fast and Small Short Vector SIMD Matrix Multiplication Kernels for the CELL Processor},
	journal = {University of Tennessee Computer Science Technical Report},
	number = {UT-CS-08-609, (also LAPACK Working Note 189)},
	year = {2008},
	month = {2008-01},
	keywords = {plasma},
	author = {Wesley Alvaro and Jakub Kurzak and Jack Dongarra}
}
@techreport {icl:431,
	title = {Parallel Block Hessenberg Reduction using Algorithms-By-Tiles for Multicore Architectures Revisited},
	journal = {University of Tennessee Computer Science Technical Report, UT-CS-08-624 (also LAPACK Working Note 208)},
	year = {2008},
	month = {2008-08},
	keywords = {plasma},
	author = {Hatem Ltaeif and Jakub Kurzak and Jack Dongarra}
}
@article {icl:446,
	title = {Parallel Tiled QR Factorization for Multicore Architectures},
	journal = {Concurrency and Computation: Practice and Experience},
	volume = {20},
	year = {2008},
	month = {2008-01},
	pages = {1573-1590},
	author = {Alfredo Buttari and Julien Langou and Jakub Kurzak and Jack Dongarra}
}
@article {icl:444,
	title = {The PlayStation 3 for High Performance Scientific Computing},
	journal = {Computing in Science and Engineering},
	year = {2008},
	month = {2008-01},
	pages = {80-83},
	author = {Jakub Kurzak and Alfredo Buttari and Piotr Luszczek and Jack Dongarra}
}
@techreport {icl:406,
	title = {The PlayStation 3 for High Performance Scientific Computing},
	journal = {University of Tennessee Computer Science Technical Report},
	number = {UT-CS-08-608},
	year = {2008},
	month = {2008-01},
	author = {Jakub Kurzak and Alfredo Buttari and Piotr Luszczek and Jack Dongarra}
}
@techreport {icl:421,
	title = {QR Factorization for the CELL Processor},
	journal = {University of Tennessee Computer Science Technical Report, UT-CS-08-616 (also LAPACK Working Note 201)},
	year = {2008},
	month = {2008-05},
	keywords = {plasma},
	author = {Jakub Kurzak and Jack Dongarra}
}
@article {icl:445,
	title = {Solving Systems of Linear Equations on the CELL Processor Using Cholesky Factorization},
	journal = {IEEE Transactions on Parallel and Distributed Systems},
	volume = {19},
	number = {9},
	year = {2008},
	month = {2008-01},
	pages = {1-11},
	author = {Jakub Kurzak and Alfredo Buttari and Jack Dongarra}
}
@article {icl:424,
	title = {Using Mixed Precision for Sparse Matrix Computations to Enhance the Performance while Achieving 64-bit Accuracy},
	journal = {ACM Transactions on Mathematical Software},
	volume = {34},
	number = {4},
	year = {2008},
	month = {2008-00},
	pages = {17-22},
	keywords = {plasma},
	author = {Alfredo Buttari and Jack Dongarra and Jakub Kurzak and Piotr Luszczek and Stanimire Tomov}
}
@techreport {icl:375,
	title = {A Class of Parallel Tiled Linear Algebra Algorithms for Multicore Architectures},
	journal = {University of Tennessee Computer Science Technical Report},
	number = {UT-CS-07-600 (also LAPACK Working Note 191)},
	year = {2007},
	month = {2007-01},
	keywords = {plasma},
	author = {Alfredo Buttari and Julien Langou and Jakub Kurzak and Jack Dongarra}
}
@article {icl:392,
	title = {Exploiting Mixed Precision Floating Point Hardware in Scientific Computations},
	journal = {In High Performance Computing and Grids in Action (to appear)},
	year = {2007},
	month = {2007-00},
	publisher = {IOS Press},
	address = {Amsterdam},
	author = {Alfredo Buttari and Jack Dongarra and Jakub Kurzak and Julien Langou and Julie Langou and Piotr Luszczek and Stanimire Tomov},
	editor = {Lucio Grandinetti}
}
@article {icl:399,
	title = {Implementation of Mixed Precision in Solving Systems of Linear Equations on the Cell Processor},
	journal = {Concurrency and Computation: Practice and Experience},
	volume = {19},
	number = {10},
	year = {2007},
	month = {2007-07},
	pages = {1371-1385},
	author = {Jakub Kurzak and Jack Dongarra}
}
@techreport {icl:404,
	title = {Limitations of the Playstation 3 for High Performance Cluster Computing},
	journal = {University of Tennessee Computer Science Technical Report, UT-CS-07-597 (Also LAPACK Working Note 185)},
	year = {2007},
	month = {2007-00},
	author = {Alfredo Buttari and Jack Dongarra and Jakub Kurzak}
}
@article {icl:395,
	title = {Mixed Precision Iterative Refinement Techniques for the Solution of Dense Linear Systems},
	journal = {International Journal of High Performance Computer Applications (to appear)},
	year = {2007},
	month = {2007-08},
	author = {Alfredo Buttari and Jack Dongarra and Julien Langou and Julie Langou and Piotr Luszczek and Jakub Kurzak}
}
@inproceedings {icl:388,
	title = {Multithreading for synchronization tolerance in matrix factorization},
	journal = {Journal of Physics: Conference Series, SciDAC 2007},
	volume = {78},
	number = {2007},
	year = {2007},
	month = {2007-01},
	author = {Alfredo Buttari and Jack Dongarra and Parry Husbands and Jakub Kurzak and Katherine Yelick}
}
@techreport {icl:363,
	title = {Parallel Tiled QR Factorization for Multicore Architectures},
	journal = {University of Tennessee Computer Science Dept. Technical Report, UT-CS-07-598 (also LAPACK Working Note 190)},
	year = {2007},
	month = {2007-00},
	keywords = {plasma},
	author = {Alfredo Buttari and Julien Langou and Jakub Kurzak and Jack Dongarra}
}
@techreport {icl:364,
	title = {SCOP3: A Rough Guide to Scientific Computing On the PlayStation 3},
	journal = {University of Tennessee Computer Science Dept. Technical Report, UT-CS-07-595},
	year = {2007},
	month = {2007-00},
	keywords = {multi-core},
	author = {Alfredo Buttari and Piotr Luszczek and Jakub Kurzak and Jack Dongarra and George Bosilca}
}
@techreport {icl:341,
	title = {Solving Systems of Linear Equations on the CELL Processor Using Cholesky Factorization},
	journal = {UT Computer Science Technical Report (Also LAPACK Working Note 184)},
	number = {UT-CS-07-596},
	year = {2007},
	month = {2007-01},
	keywords = {lapack},
	author = {Jakub Kurzak and Alfredo Buttari and Jack Dongarra}
}
@article {icl:317,
	title = {Exploiting the Performance of 32 bit Floating Point Arithmetic in Obtaining 64 bit Accuracy},
	journal = {University of Tennessee Computer Science Tech Report},
	number = {UT-CS-06-574, LAPACK Working Note $\#$175},
	year = {2006},
	month = {2006-04},
	keywords = {iter-ref},
	author = {Julien Langou and Julien Langou and Piotr Luszczek and Jakub Kurzak and Alfredo Buttari and Jack Dongarra}
}
@article {icl:369,
	title = {The Impact of Multicore on Math Software},
	journal = {PARA 2006},
	year = {2006},
	month = {2006-06},
	address = {Umea, Sweden},
	keywords = {plasma},
	author = {Alfredo Buttari and Jack Dongarra and Jakub Kurzak and Julien Langou and Piotr Luszczek and Stanimire Tomov}
}
@article {icl:318,
	title = {Implementation of the Mixed-Precision High Performance LINPACK Benchmark on the CELL Processor},
	journal = {University of Tennessee Computer Science Tech Report},
	number = {UT-CS-06-580, LAPACK Working Note $\#$177},
	year = {2006},
	month = {2006-09},
	keywords = {iter-ref},
	author = {Jakub Kurzak and Jack Dongarra}
}
@article {icl:321,
	title = {Implementing Linear Algebra Routines on Multi-Core Processors with Pipelining and a Look Ahead},
	journal = {University of Tennessee Computer Science Tech Report, UT-CS-06-581, LAPACK Working Note $\#$178},
	year = {2006},
	month = {2006-01},
	author = {Jakub Kurzak and Jack Dongarra}
}
@article {icl:370,
	title = {Prospectus for the Next LAPACK and ScaLAPACK Libraries},
	journal = {PARA 2006},
	year = {2006},
	month = {2006-06},
	address = {Umea, Sweden},
	author = {James Demmel and Jack Dongarra and B. Parlett and William Kahan and Ming Gu and David Bindel and Yozo Hida and Xiaoye Li and Osni Marques and Jason E. Riedy and Christof Voemel and Julien Langou and Piotr Luszczek and Jakub Kurzak and Alfredo Buttari and Julien Langou and Stanimire Tomov}
}
