Demo Data from EDBT 2026 / reviewers in the wild / expert
Fred G. Gustavson
dblp:29/6667
· DBLP profile ↗
21ranked-venue papers
9as first author
0since 2021 · last 2019
—ORCID · none
Domains — the database's venue-derived domains; a paper can count in several
Theory of computation · 12 · 7 first-authorSystems, architecture and hardware · 8 · 1 first-authorApplied, interdisciplinary, general and emerging computing · 1 · 1 first-author
Expertise — from the expertise taxonomy: the topics of the expert's papers under the CCF categories. A weight counts papers with recency: 1 for a paper about the topic, 0.3 when the topic is its context, halved every five years.
| Computer architecture, parallel and distributed computing, and storage systems
4 papers |
High-performance computing · 79% Integrated circuit design · 19% Parallel and multicore computing · 2% | |
| Theoretical computer science
1 paper |
Algorithms and data structures · 100% |
Topics — the 13 heaviest of 14, each with the papers that count most for it
| Topic | Weight | Papers | Last | Evidence papers |
|---|---|---|---|---|
High-performance computing › supercomputing
bluegene/l |
0.0 | 1 | 2002 | An overview of the BlueGene/L Supercomputer · SC 2002 |
High-performance computing
supercomputing |
0.0 | 1 | 2002 | An overview of the BlueGene/L Supercomputer · SC 2002 |
Integrated circuit design
system-on-chip |
0.0 | 1 | 2002 | An overview of the BlueGene/L Supercomputer · SC 2002 |
High-performance computing
performance optimization at scale |
0.0 | 3 | 1994 | A high performance parallel algorithm for 1-D FFT · SC 1994 A High Performance Algorithm Using Pre-Processing for the Sparse Matrix-Vector Multiplication · SC 1992 Vector and parallel algorithms for Cholesky factorization on IBM 3090 · SC 1989 |
High-performance computing
parallel numerical algorithms |
0.0 | 2 | 1994 | A high performance parallel algorithm for 1-D FFT · SC 1994 Vector and parallel algorithms for Cholesky factorization on IBM 3090 · SC 1989 |
High-performance computing
fast fourier transform |
0.0 | 1 | 1994 | A high performance parallel algorithm for 1-D FFT · SC 1994 |
High-performance computing › sparse linear algebra
sparse matrix computation |
0.0 | 1 | 1992 | A High Performance Algorithm Using Pre-Processing for the Sparse Matrix-Vector Multiplication · SC 1992 |
High-performance computing › sparse linear algebra › sparse matrix computation
sparse matrix-vector multiplication |
0.0 | 1 | 1992 | A High Performance Algorithm Using Pre-Processing for the Sparse Matrix-Vector Multiplication · SC 1992 |
High-performance computing › sparse linear solver
cholesky factorization |
0.0 | 1 | 1989 | Vector and parallel algorithms for Cholesky factorization on IBM 3090 · SC 1989 |
Parallel and multicore computing › parallel architecture
distributed-memory parallel computing |
0.0 | 1 | 1994 | A high performance parallel algorithm for 1-D FFT · SC 1994 |
Processor architecture and microarchitecture
vector processing |
0.0 | 1 | 1989 | Vector and parallel algorithms for Cholesky factorization on IBM 3090 · SC 1989 |
Algorithms and data structures › numerical linear algebra
sparse linear systems |
0.0 | 1 | 1970 | Symbolic Generation of an Optimal Crout Algorithm for Sparse Systems of Linear Equations · J. ACM 1970 |
Algorithms and data structures
numerical linear algebra |
0.0 | 1 | 1970 | Symbolic Generation of an Optimal Crout Algorithm for Sparse Systems of Linear Equations · J. ACM 1970 |
Methods — techniques the papers use, named apart from their topics
system architecture design · 0.0performance scaling studies · 0.0multi-dimensional formulation · 0.0preprocessing · 0.0feature extraction · 0.0vectorization · 0.0parallelization · 0.0blocking · 0.0
| Year | Publication | Venue | Position |
|---|---|---|---|
| 2019 | Algorithms for in-place matrix transpositionabstractSummary This paper presents implementations of in‐place algorithms for transposing rectangular matrices. One implementation is a swap‐based algorithm described by Tretyakov and Tyrtyshnikov,1 to which we have introduced a number of variations. In particular, we show how the original algorithm can be modified to require constant additional memory. A proof of correctness is also sketched. This algorithm is compared with cycle‐following approaches and with the swap‐based GCD Transpose algorithm that partitions the matrix into a hierarchy of square submatrices. The performance of parallel implementations on a multicore system is also investigated. Fred G. Gustavson, David W. Walker |
Concurr. Comput. Pract. Exp. | 1 |
| 2013 | Level-3 Cholesky Factorization Routines Improve Performance of Many Cholesky AlgorithmsabstractFour routines called DPOTF3i, i = a,b,c,d, are presented. DPOTF3i are a novel type of level-3 BLAS for use by BPF ( B locked P acked F ormat) Cholesky factorization and LAPACK routine DPOTRF. Performance of routines DPOTF3i are still increasing when the performance of Level-2 routine DPOTF2 of LAPACK starts decreasing. This is our main result and it implies, due to the use of larger block size nb , that DGEMM, DSYRK, and DTRSM performance also increases! The four DPOTF3i routines use simple register blocking. Different platforms have different numbers of registers. Thus, our four routines have different register blocking sizes. BPF is introduced. LAPACK routines for POTRF and PPTRF using BPF instead of full and packed format are shown to be trivial modifications of LAPACK POTRF source codes. We call these codes BPTRF. There are two variants of BPF: lower and upper. Upper BPF is “identical” to Square Block Packed Format (SBPF). “LAPACK” implementations on multicore processors use SBPF. Lower BPF is less efficient than upper BPF. Vector inplace transposition converts lower BPF to upper BPF very efficiently. Corroborating performance results for DPOTF3i versus DPOTF2 on a variety of common platforms are given for n ≈ nb as well as results for large n comparing DBPTRF versus DPOTRF. Fred G. Gustavson, Jerzy Wasniewski, Jack J. Dongarra, José R. Herrero 0001, Julien Langou |
ACM Trans. Math. Softw. | 1 |
| 2012 | Parallel and Cache-Efficient In-Place Matrix Storage Format ConversionabstractTechniques and algorithms for efficient in-place conversion to and from standard and blocked matrix storage formats are described. Such functionality is required by numerical libraries that use different data layouts internally. Parallel algorithms and a software package for in-place matrix storage format conversion based on in-place matrix transposition are presented and evaluated. A new algorithm for in-place transposition which efficiently determines the structure of the transposition permutation a priori is one of the key ingredients. It enables effective load balancing in a parallel environment. Fred G. Gustavson, Lars Karlsson, Bo Kågström |
ACM Trans. Math. Softw. | 1 |
| 2010 | Rectangular full packed format for cholesky's algorithm: factorization, solution, and inversionabstractWe describe a new data format for storing triangular, symmetric, and Hermitian matrices called Rectangular Full Packed Format (RFPF). The standard two-dimensional arrays of Fortran and C (also known as full format ) that are used to represent triangular and symmetric matrices waste nearly half of the storage space but provide high performance via the use of Level 3 BLAS. Standard packed format arrays fully utilize storage (array space) but provide low performance as there is no Level 3 packed BLAS. We combine the good features of packed and full storage using RFPF to obtain high performance via using Level 3 BLAS as RFPF is a standard full-format representation. Also, RFPF requires exactly the same minimal storage as packed the format. Each LAPACK full and/or packed triangular, symmetric, and Hermitian routine becomes a single new RFPF routine based on eight possible data layouts of RFPF. This new RFPF routine usually consists of two calls to the corresponding LAPACK full-format routine and two calls to Level 3 BLAS routines. This means no new software is required. As examples, we present LAPACK routines for Cholesky factorization, Cholesky solution, and Cholesky inverse computation in RFPF to illustrate this new work and to describe its performance on several commonly used computer platforms. Performance of LAPACK full routines using RFPF versus LAPACK full routines using the standard format for both serial and SMP parallel processing is about the same while using half the storage. Performance gains are roughly one to a factor of 43 for serial and one to a factor of 97 for SMP parallel times faster using vendor LAPACK full routines with RFPF than with using vendor and/or reference packed routines. Fred G. Gustavson, Jerzy Wasniewski, Jack J. Dongarra, Julien Langou |
ACM Trans. Math. Softw. | 1 |
| 2009 | Distributed SBP Cholesky factorization algorithms with near-optimal schedulingabstractThe minimal block storage Distributed Square Block Packed (DSBP) format for distributed memory computing on symmetric and triangular matrices is presented. Three algorithm variants (Basic, Static, and Dynamic) of the blocked right-looking Cholesky factorization are designed for the DSBP format, implemented, and evaluated. On our target machine, all variants outperform standard full-storage implementations while saving almost half the storage. Communication overhead is shown to be virtually eliminated by the Static and Dynamic variants, both of which take advantage of hardware parallelism to hide communication costs. The Basic variant is shown to yield comparable or slightly better performance than the full-storage ScaLAPACK routine PDPOTRF while clearly outperformed by both Static and Dynamic. Models of execution assuming zero communication costs and overhead are developed. For medium- and larger-sized problems, the Static schedule is near optimal on our target machine based on comparisons with these models and measurements of synchronization overhead. Fred G. Gustavson, Lars Karlsson, Bo Kågström |
ACM Trans. Math. Softw. | 1 |
| 2007 | An experimental comparison of cache-oblivious and cache-conscious programsabstractCache-oblivious algorithms have been advanced as a way of circumventing some of the difficulties of optimizing applications to take advantage of the memory hierarchy of modern microprocessors. These algorithms are based on the divide-and-conquer paradigm -- each division step creates sub-problems of smaller size, and when the working set of a sub-problem fits in some level of the memory hierarchy, the computations in that sub-problem can be executed without suffering capacity misses at that level. In this way, divide-and-conquer algorithms adapt automatically to all levels of the memory hierarchy; in fact, for problems like matrix multiplication, matrix transpose, and FFT, these recursive algorithms are optimal to within constant factors for some theoretical models of the memory hierarchy. Kamen Yotov, Tom Roeder, Keshav Pingali, John A. Gunnels, Fred G. Gustavson |
SPAA | 5 |
| 2007 | Algorithm 865: Fortran 95 subroutines for Cholesky factorization in block hybrid formatabstractWe present subroutines for the Cholesky factorization of a positive-definite symmetric matrix and for solving corresponding sets of linear equations. They exploit cache memory by using the block hybrid format proposed by the authors in a companion article. The matrix is packed into n ( n + 1)/2 real variables, and the speed is usually better than that of the LAPACK algorithm that uses full storage ( n 2 variables). Included are subroutines for rearranging a matrix whose upper or lower-triangular part is packed by columns to this format and for the inverse rearrangement. Also included is a kernel subroutine that is used for the Cholesky factorization of the diagonal blocks since it is suitable for any positive-definite symmetric matrix that is small enough to be held in cache. We provide a comprehensive test program and simple example programs. Fred G. Gustavson, John K. Reid, Jerzy Wasniewski |
ACM Trans. Math. Softw. | 1 |
| 2005 | A fully portable high performance minimal storage hybrid format cholesky algorithmabstractWe consider the efficient implementation of the Cholesky solution of symmetric positive-definite dense linear systems of equations using packed storage. We take the same starting point as that of LINPACK and LAPACK, with the upper (or lower) triangular part of the matrix stored by columns. Following LINPACK and LAPACK, we overwrite the given matrix by its Cholesky factor. We consider the use of a hybrid format in which blocks of the matrices are held contiguously and compare this to the present LAPACK code. Code based on this format has the storage advantages of the present code but substantially outperforms it. Furthermore, it compares favorably to using conventional full format (LAPACK) and using the recursive format of Andersen et al. [2001]. Bjarne Stig Andersen, John A. Gunnels, Fred G. Gustavson, John K. Reid, Jerzy Wasniewski |
ACM Trans. Math. Softw. | 3 |
| 2002 | Blue Gene/L, a System-On-A-ChipabstractSummary form only given. Large powerful networks coupled to state-of-the-art processors have traditionally dominated supercomputing. As technology advances, this approach is likely to be challenged by a more cost-effective System-On-A-Chip approach, with higher levels of system integration. The scalability of applications to architectures with tens to hundreds of thousands of processors is critical to the success of this approach. Significant progress has been made in mapping numerous compute-intensive applications, many of them grand challenges, to parallel architectures. Applications hoping to efficiently execute on future supercomputers of any architecture must be coded in a manner consistent with an enormous degree of parallelism. The BG/L program is developing a peak nominal 180 TFLOPS (360 TFLOPS for some applications) supercomputer to serve a broad range of science applications. BG/L generalizes QCDOC, the first System-On-A-Chip supercomputer that is expected in 2003. BG/L consists of 65,536 nodes, and contains five integrated networks: a 3D torus, a combining tree, a Gb Ethernet network, barrier/global interrupt network and JTAG. George S. Almási, Daniel K. Beece, Ralph Bellofatto, Gyan Bhanot, Randy Bickford, Matthias A. Blumrich, Arthur A. Bright, José R. Brunheroto, Calin Cascaval, José G. Castaños, Luis Ceze, Paul Coteus, Siddhartha Chatterjee, Dong Chen 0005, George L.-T. Chiu, Thomas M. Cipolla, Paul Crumley, Alina Deutsch, Marc Boris Dombrowa, Wilm E. Donath, Maria Eleftheriou, Blake G. Fitch, Joseph Gagliano, Alan Gara, Robert S. Germain, Mark Giampapa, Manish Gupta 0002, Fred G. Gustavson, Shawn Hall, Ruud A. Haring, David F. Heidel, Philip Heidelberger, Lorraine M. Herger, Dirk Hoenicke, T. Jamal-Eddine, Gerard V. Kopcsay, Alphonso P. Lanzetta, Derek Lieber, M. Lu, Mark P. Mendell, Lawrence S. Mok, José E. Moreira, Ben J. Nathanson, Matthew Newton, Martin Ohmacht, Rick A. Rand, Richard D. Regan, Ramendra K. Sahoo, Alda Sanomiya, Eugen Schenfeld, Sarabjeet Singh, Peilin Song, Burkhard D. Steinmacher-Burow, Karin Strauss, Richard A. Swetz, Todd Takken, R. Brett Tremaine, Mickey Tsao, Pavlos Vranas, T. J. Christopher Ward, Michael E. Wazlowski, J. Brown, Thomas A. Liebsch, A. Schram, G. Ulsh |
CLUSTER | 28 |
| 2002 | An overview of the BlueGene/L SupercomputerabstractThis paper gives an overview of the BlueGene/L Supercomputer. This is a jointly funded research partnership between IBM and the Lawrence Livermore National Laboratory as part of the United States Department of Energy ASCI Advanced Architecture Research Program. Application performance and scaling studies have recently been initiated with partners at a number of academic and government institutions,including the San Diego Supercomputer Center and the California Institute of Technology. This massively parallel system of 65,536 nodes is based on a new architecture that exploits system-on-a-chip technology to deliver target peak processing power of 360 teraFLOPS (trillion floating-point operations per second). The machine is scheduled to be operational in the 2004-2005 time frame, at price/performance and power consumption/performance targets unobtainable with conventional architectures. Narasimha R. Adiga, Gheorghe Almási 0001, George S. Almási, Yariv Aridor, Rajkishore Barik, Daniel K. Beece, Ralph Bellofatto, Gyan Bhanot, Randy Bickford, Matthias A. Blumrich, Arthur A. Bright, José R. Brunheroto, Calin Cascaval, José G. Castaños, Waiman Chan, Luis Ceze, Paul Coteus, Siddhartha Chatterjee, Dong Chen 0005, George L.-T. Chiu, Thomas M. Cipolla, Paul Crumley, K. M. Desai, Alina Deutsch, Tamar Domany, Marc Boris Dombrowa, Wilm E. Donath, Maria Eleftheriou, C. Christopher Erway, J. Esch, Blake G. Fitch, Joseph Gagliano, Alan Gara, Rahul Garg 0001, Robert S. Germain, Mark Giampapa, Balaji Gopalsamy, John A. Gunnels, Manish Gupta 0002, Fred G. Gustavson, Shawn Hall, Ruud A. Haring, David F. Heidel, Philip Heidelberger, Lorraine M. Herger, Dirk Hoenicke, R. D. Jackson, T. Jamal-Eddine, Gerard V. Kopcsay, Elie Krevat, Manish P. Kurhekar, Alphonso P. Lanzetta, Derek Lieber, L. K. Liu, M. Lu, Mark P. Mendell, A. Misra, Yosef Moatti, Lawrence S. Mok, José E. Moreira, Ben J. Nathanson, Matthew Newton, Martin Ohmacht, Adam J. Oliner, Vinayaka Pandit, R. B. Pudota, Rick A. Rand, Richard D. Regan, Bradley Rubin, Albert E. Ruehli, Silvius Vasile Rus, Ramendra K. Sahoo, Alda Sanomiya, Eugen Schenfeld, M. Sharma, Edi Shmueli, Sarabjeet Singh, Peilin Song, Vijay Srinivasan, Burkhard D. Steinmacher-Burow, Karin Strauss, Christopher W. Surovic, Richard A. Swetz, Todd Takken, R. Brett Tremaine, Mickey Tsao, Arun R. Umamaheshwaran, P. Verma, Pavlos Vranas, T. J. Christopher Ward, Michael E. Wazlowski, W. Barrett, C. Engel, B. Drehmel, B. Hilgart, D. Hill, F. Kasemkhani, David J. Krolak, Chun-Tao Li 0001, Thomas A. Liebsch, James A. Marcella, A. Muff, A. Okomo, M. Rouse, A. Schram, M. Tubbs, G. Ulsh, Charles D. Wait, J. Wittrup, Myung Bae, Kenneth A. Dockser, Lynn Kissel, Mark K. Seager, Jeffrey S. Vetter, K. Yates |
SC | 40 |
| 2001 | A recursive formulation of Cholesky factorization of a matrix in packed storageabstractA new compact way to store a symmetric or triangular matrix called RPF for Recursive Packed Format is fully described. Novel ways to transform RPF to and from standard packed format are included. A new algorithm, called RPC for Recursive Packed Cholesky, that operates on the RPG format is presented. ALgorithm RPC is basd on level-3 BLAS and requires variants of algorithms TRSM and SYRK that work on RPF. We call these RP_TRSM and RP_SYRK and find that they do most of their work by calling GEMM . It follows that most of the execution time of RPC lies in GEMM . The advantage of this storage scheme compared to traditional packed and full storage is demonstrated. First, the RPC storage format uses the minimal amount of storage for the symmetric or triangular matrix. Second, RPC gives a level-3 implementation of Cholesky factorization whereas standard packed implementations are only level 2. Hence, the performance of our RPC implementation is decidedly superior. Third, unlike fixed block size algorithms, RPC, requires no block size tuning parameter. We present performance measurements on several current architectures that demonstrate improvements over the traditional packed routines. Also MSP parallel computations on the IBM SMP computer are made. The graphs that are attached in Section 7 show that the RPC algorithms are superior by a factor between 1.6 and 7.4 for order around 1000, and between 1.9 and 10.3 for order around 3000 over the traditional packed algorithms. For some architectures, the RPC performance results are almost the same or even better than the traditional full-storage algorithms results. Bjarne Stig Andersen, Jerzy Wasniewski, Fred G. Gustavson |
ACM Trans. Math. Softw. | 3 |
| 2001 | FLAME: Formal Linear Algebra Methods EnvironmentabstractSince the advent of high-performance distributed-memory parallel computing, the need for intelligible code has become ever greater. The development and maintenance of libraries for these architectures is simply too complex to be amenable to conventional approaches to implementation. Attempts to employ traditional methodology have led, in our opinion, to the production of an abundance of anfractuous code that is difficult to maintain and almost impossible to upgrade.Having struggled with these issues for more than a decade, we have concluded that a solution is to apply a technique from theoretical computer science, formal derivation, to the development of high-performance linear algebra libraries. We think the resulting approach results in aesthetically pleasing, coherent code that greatly facilitates intelligent modularity and high performance while enhancing confidence in its correctness. Since the technique is language-independent, it lends itself equally well to a wide spectrum of programming languages (and paradigms) ranging from C and Fortran to C++ and Java. In this paper, we illustrate our observations by looking at the Formal Linear Algebra Methods Environment (FLAME), a framework that facilitates the derivation and implementation of linear algebra algorithms on sequential architectures. This environment demonstrates that lessons learned in the distributed-memory world can guide us toward better approaches even in the sequential world.We present performance experiments on the Intel (R) Pentium (R) III processor that demonstrate that high performance can be attained by coding at a high level of abstraction. John A. Gunnels, Fred G. Gustavson, Greg Henry, Robert A. van de Geijn |
ACM Trans. Math. Softw. | 2 |
| 1999 | Series Approximation Methods for Divide and Square Root in the Power3(TM) ProcessorabstractThe Power3 processor is a 64-bit implementation of the PowerPC/sup TM/ architecture and is the successor to the Power2/sup TM/ processor for workstations and servers which require high performance floating point capability. The previous processors used Newton-Raphson algorithms for their implementations of divide and square root. The Power3 processor has a longer pipeline latency, which would substantially increase the latency for these instructions. Instead, new algorithms based on power series approximations were developed which provide significantly better performance than the Newton-Raphson algorithm for this processor. This paper describes the algorithms, and then shows how both the series based algorithms and the Newton-Raphson algorithms are affected by pipeline length. For the Power3, the power series algorithms reduce the divide latency by over 20% and the square root latency by 35%. Martin S. Schmookler, Ramesh C. Agarwal, Fred G. Gustavson |
IEEE Symposium on Computer Arithmetic | 3 |
| 1999 | Experience with a Recursive Perturbation Based Algorithm for Symmetric Indefinite Linear Systems
Fred G. Gustavson, Alexander Karaivanov, Jerzy Wasniewski, Plamen Y. Yalamov |
Euro-Par | 2 |
| 1998 | The Design, Implementation, and Evaluation of a Symmetric Banded Linear Solver for Distributed-Memory Parallel ComputersabstractThis article describes the design, implementation, and evaluation of a parallel algorithm for the Cholesky factorization of symmetric banded matrices. The algorithm is part of IBM's parallel engineering and scientific subroutine library version 1.2 and is compatible with ScaLAPACK's banded solver. Analysis, as well as experiments on an IBM SP2 distributed-memory parallel computer, shows that the algorithm efficiently factors banded matrices with wide bandwidth. For example, a 31-mode SP2 factors a large matrix more than 16 times faster than a single node would factor it using the best sequential algorithm, and more than 20 times faster than a single node would using LAPACK's DPBTRF. The algorithm uses novel ideas in the area of distributed dense-matrix computations that include the use of a dynamic schedule for a blocked systolic-like algorithm and the separation of the input and output layouts from the layout the algorithm uses internally. The algorithm alson uses known techniques such as blocking to improve its communication-to-computation ratio and its data-cache behavior. Fred G. Gustavson, Mahesh V. Joshi, Sivan Toledo |
ACM Trans. Math. Softw. | 2 |
| 1994 | A high performance parallel algorithm for 1-D FFTabstractProposes a parallel high-performance fast Fourier transform (FFT) algorithm based on a multi-dimensional formulation. We use this to solve a commonly encountered FFT based kernel on a distributed memory parallel machine, the IBM scalable parallel system, SP1. The kernel requires a forward FFT computation of an input sequence, multiplication of the transformed data by a coefficient array, and finally an inverse FFT computation of the resultant data. We show that the multi-dimensional formulation helps in reducing the communication costs and also improves the single node performance by effectively utilizing the memory system of the node. We implemented this kernel on the IBM SP1 and observed a performance of 1.25 GFLOPS on a 64-node machine.> Ramesh C. Agarwal, Fred G. Gustavson, Mohammad Zubair |
SC | 2 |
| 1992 | A High Performance Algorithm Using Pre-Processing for the Sparse Matrix-Vector MultiplicationabstractThe authors propose a feature-extraction-based algorithm (FEBA) for sparse matrix-vector multiplication. The key idea of FEBA is to exploit any regular structure present in the sparse matrix by extracting it and processing it separately. The order in which these structures are extracted is determined by the relative efficiency with which they can be processed. The authors have tested FEBA on IBM 3000 VF for matrices from the Harwell Boeing and OSL collection. The results obtained were on average five times faster than the ESSL routine which is based on the ITPACK storage structure.> Ramesh C. Agarwal, Fred G. Gustavson, Mohammad Zubair |
SC | 2 |
| 1989 | Vector and parallel algorithms for Cholesky factorization on IBM 3090abstractIn many engineering applications, a solution of Fx = b is required, where F is a positive definite symmetric matrix. This is usually done by the Cholesky factorization, F = RRT, where R is the lower triangular Cholesky factor. This is a compute intensive problem. However, in order to achieve the best possible performance on IBM 3090 Vector Facility, the problem requires blocking at various levels to match 3090 memory hierarchy. A large problem which does not fit in a particular level of memory is blocked so that each block fits in memory. This minimizes data transfers between various levels of memory. In this paper, various blocking schemes are described for vector and parallel implementation on 3090 VF. Some of these algorithms have been included in the Engineering and Scientific Subroutine Library (ESSL). Performance numbers are also included. These algorithms achieve close to the peak performance of the 3090 uniprocessor and multiprocessors. Ramesh C. Agarwal, Fred G. Gustavson |
SC | 2 |
| 1978 | Two Fast Algorithms for Sparse Matrices: Multiplication and Permuted Transpositionabstractarticle Free Access Share on Two Fast Algorithms for Sparse Matrices: Multiplication and Permuted Transposition Author: Fred G. Gustavson Mathematical Sciences Department, IBM T.J. Watson Research Center, P.O. Box, 218, Yorktown Heights, NY Mathematical Sciences Department, IBM T.J. Watson Research Center, P.O. Box, 218, Yorktown Heights, NYView Profile Authors Info & Claims ACM Transactions on Mathematical SoftwareVolume 4Issue 3Sept. 1978 pp 250–269https://doi.org/10.1145/355791.355796Published:01 September 1978Publication History 251citation5,639DownloadsMetricsTotal Citations251Total Downloads5,639Last 12 Months809Last 6 weeks334 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF Fred G. Gustavson |
ACM Trans. Math. Softw. | 1 |
| 1978 | Remark on "Algorithm 408: A Sparse Matrix Package (Part I) [F4]"
Fred G. Gustavson |
ACM Trans. Math. Softw. | 1 |
| 1970 | Symbolic Generation of an Optimal Crout Algorithm for Sparse Systems of Linear EquationsabstractAn efficient implementation of the Crout elimination method in solving large sparse systems of linear algebraic equations of arbitrary structure is described.A computer program, GNSO, by symbolic processing, generates another program, SOLVE, which represents the optimal reduced Crout algorithm in the sense that only nonzero elements are stored and operated on.The method presented is particularly powerful when a system of fixed sparseness structure must be solved repeatedly with different numerical values.In practical examples, the execution of SOLVE was observed to be typically N times as fast as that of the full Crout algorithm, where N is the order of the system. Fred G. Gustavson, Werner Liniger, R. Willoughby |
J. ACM | 1 |