Package magma. February 15, 2013

Transcription

1 Package magma February 15, 2013 Title Matrix Algebra on GPU and Multicore Architectures Version Date Author Brian J Smith <brian-j-smith@uiowa.edu> Maintainer Brian J Smith <brian-j-smith@uiowa.edu> Depends R (>= ), methods SystemRequirements MAGMA shared libraries (== release 0.2), LAPACK shared library, NVIDIA CUDA Toolkit (>= release 3.0) Description Magma matrix classes and methods for parallel processing of matrix algebra operations. Operations are performed with algorithms developed by the MAGMA research project. MAGMA aims to achieve the fastest possible linear algebra libraries on hybrid multicore CPU and GPU architectures by exploiting their massive parallelism and minimizing communication latencies. License GPL (>= 3) URL OS_type unix Repository CRAN Date/Publication :36:31 NeedsCompilation yes 1

2 2 backsolve R topics documented: backsolve gpu lu magma magma-class magmalu-class magmaqr-class Index 13 backsolve Solve an Upper or Lower Triangular System Description Solves a system of linear equations where the coefficient matrix is upper (or right, R ) or lower ( left, L ) triangular using parallelized computational algorithms. x <- backsolve(r, b) solves Rx = b, and x <- forwardsolve(l, b) solve Lx = b, respectively. Usage backsolve(r, x, k = ncol(r), upper.tri=true, transpose=false) forwardsolve(l, x, k = ncol(l), upper.tri=false, transpose=false) Arguments r, l an upper (or lower) triangular matrix-like object giving the coefficients for the system to be solved. Values below (above) the diagonal are ignored. x k upper.tri a matrix-like object whose columns give the right-hand sides for the equations. The number of columns of r and rows of x to use. logical; if TRUE (default), the upper triangular part of r is used. Otherwise, the lower one. transpose logical; if TRUE, solve r y = x for y, i.e. t(r) %*% y == x. Value The solution of the triangular system. The result will be a vector if x is a vector and a magma class matrix if x is a magma or matrix object. Note that forwardsolve(l, b) is just a wrapper for backsolve(l, b, upper.tri=false).

3 gpu 3 Methods signature(r = "magma", x = "magma") signature(r = "magma", x = "matrix") signature(r = "magma", x = "numeric") signature(r = "matrix", x = "magma") Author(s) Brian J. Smith <brian-j-smith@uiowa.edu> References Stanimire Tomov, Rajib Nath, Hatem Ltaief, and Jack Dongarra (2010) Dense Linear Algebra Solvers for Multicore with GPU Accelerators, Proceedings of IPDPS 2010: 24th IEEE International Parallel and Distributed Processing Symposium, Atlanta, GA, April 2010 ( org/netlib/utk/people/jackdongarra/papers/lawn225.pdf). See Also magma Examples ## upper triangular magma matrix and base vector ma <- magma(c(1, 2, 3, 0, 1, 1, 0, 0, 2), nrow=3, ncol=3, byrow=true) x <- c(8, 4, 2) ## triangular linear solver y <- backsolve(ma, x) ma %*% y gpu GPU Optimization for magma Matrices Description Retrieve or set the MAGMA interface (GPU or CPU) for an magma matrix. Usage ## S4 method for signature magma gpu(object) ## S4 replacement method for signature magma gpu(object) <- value

4 4 lu Arguments object value a magma class object. logical. If TRUE, the MAGMA library GPU interface is used for matrix operations, when available. Otherwise, the CPU interface is used. Details The MAGMA library of C functions offers two LAPACK-style interfaces, referred to as the GPU interface and the CPU interface. The GPU interface takes input and produces results in the GPU s memory, whereas the CPU interface produces results in the CPU s memory. The GPU and CPU interfaces, although similar, are not derivatives of each other, but instead have different communication patters. The gpu function returns or sets the logical flag indicating whether the GPU interface is to be used for caluculations involving the specified magma matrix. Author(s) See Also Brian J. Smith <brian-j-smith@uiowa.edu> magma Examples x <- magma(1:6, nrow=2, ncol=3) gpu(x) gpu(x) <-!gpu(x) gpu(x) lu The LU Decomposition Description Usage Parallelized computation of an LU factorization of an m n general matrix A using partial pivoting with row interchanges. ## S4 method for signature magma lu(x,...) Arguments x a magma matrix object.... further arguments passed to or from other methods.

5 magma 5 Details The decomposition has the form A = P LU where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n). Value A magmalu class object storing the factors L and U from the decomposition. The unit diagonal elements of L are not stored. Author(s) Brian J. Smith <brian-j-smith@uiowa.edu> References Stanimire Tomov, Rajib Nath, Hatem Ltaief, and Jack Dongarra (2010) Dense Linear Algebra Solvers for Multicore with GPU Accelerators, Proceedings of IPDPS 2010: 24th IEEE International Parallel and Distributed Processing Symposium, Atlanta, GA, April 2010 ( org/netlib/utk/people/jackdongarra/papers/lawn225.pdf). See Also magma, magmalu Examples ma <- magma(c(1, 0.4, 0.2, 0.4, 1, 0.3, 0.2, 0.3, 1), 3, 3) lu(ma) magma Matrix Class "magma" Constructor Description Constructs a magma class object that inherits from matrix. Usage magma(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL, gpu = TRUE)

6 6 magma Arguments data nrow ncol byrow dimnames gpu a numeric data vector or matrix. when data is not a matrix, the desired number of rows when data is not a matrix, the desired number of columns logical. If FALSE (the default) the matrix is filled by columns, otherwise the matrix is filled by rows. a dimnames attribute for the matrix: a list of two character components. They are set if not NULL (as per default). logical. If TRUE, the MAGMA library GPU interface is used for matrix operations, when available (default). Otherwise, the CPU interface is used. Details If either of nrow or ncol is not given, an attempt is made to infer its value from the length of data and the other parameter. The MAGMA library of C functions offers two LAPACK-style interfaces, referred to as the GPU interface and the CPU interface. The GPU interface takes input and produces results in the GPU s memory, whereas the CPU interface produces results in the CPU s memory. The GPU and CPU interfaces, although similar, are not derivatives of each other, but instead have different communication patters. The gpu argument allows specification of the interface to be used for caluculations involving the resulting magma matrix. Value Returns a magma class matrix. The arguments nrow, ncol, byrow, and dimnames are made use of only if data is not a matrix or magma object. Author(s) Brian J. Smith <brian-j-smith@uiowa.edu> See Also gpu, magma, matrix Examples magma(1:6, nrow = 2, ncol = 3, byrow = TRUE, dimnames = list(c("row1", "row2"), c("col1", "col2", "col3")), gpu = TRUE)

7 magma-class 7 magma-class Matrix Class "magma" Description Details The "magma" class is provided by the magma package and provides method functions for parallel matrix and linear algebra computations on hybrid multicore CPU and GPU architectures. It inherits from the R base matrix class. It is possible to mix R base scalars, matrices, and vectors, with "magma" class objects. In general, magma matrices can be used in operations and functions that support "matrix" class objects. The MAGMA library of C functions offers two LAPACK-style interfaces, referred to as the GPU interface and the CPU interface. The GPU interface takes input and produces results in the GPU s memory, whereas the CPU interface produces results in the CPU s memory. The GPU and CPU interfaces, although similar, are not derivatives of each other, but instead have different communication patters. Magma objects have a gpu slot that specifies the interface to be used for matrix and linear algebra operations. Objects from the Class Slots Objects can be created by calls of the form new("magma", data, nrow, ncol, byrow, dimnames,...) or to the constructor function magma. Extends data a numeric data vector or matrix. nrow when data is not a matrix, the desired number of rows ncol when data is not a matrix, the desired number of columns byrow logical. If FALSE (the default) the matrix is filled by columns, otherwise the matrix is filled by rows. dimnames a dimnames attribute for the matrix: a list of two character components. They are set if not NULL (as per default). gpu logical. If FALSE, heterogeneous CPU+GPU parallel algorithms are utilized for matrix operations (default). Otherwise, GPU-only parallel algorithms are used, if available. gpu logical. If TRUE, the MAGMA library GPU interface is used for matrix operations, when available (default). Otherwise, the CPU interface is used..data: Object of class "matrix". gpu: Object of class "logical". Class "matrix", from data part. Class "array", by class "matrix", distance 2. Class "structure", by class "matrix", distance 3. Class "vector", by class "matrix", distance 4, with explicit coerce.

8 8 magma-class Methods Arith signature(e1 = "magma", e2 = "magma"):... Arith signature(e1 = "magma", e2 = "matrix"):... Arith signature(e1 = "magma", e2 = "numeric"):... Arith signature(e1 = "matrix", e2 = "magma"):... Arith signature(e1 = "numeric", e2 = "magma"):... backsolve signature(r = "magma", x = "magma"):... backsolve signature(r = "magma", x = "matrix"):... backsolve signature(r = "magma", x = "numeric"):... backsolve signature(r = "matrix", x = "magma"):... [ signature(x = "magma", i = "ANY", j = "ANY"):... [ signature(x = "magma", i = "ANY", j = "missing"):... [ signature(x = "magma", i = "missing", j = "ANY"):... [ signature(x = "magma", i = "missing", j = "missing"):... %*% signature(x = "magma", y = "magma"):... %*% signature(x = "magma", y = "matrix"):... %*% signature(x = "magma", y = "numeric"):... %*% signature(x = "matrix", y = "magma"):... %*% signature(x = "numeric", y = "magma"):... chol2inv signature(x = "magma"):... chol signature(x = "magma"):... crossprod signature(x = "magma", y = "magma"):... crossprod signature(x = "magma", y = "matrix"):... crossprod signature(x = "magma", y = "missing"):... crossprod signature(x = "magma", y = "numeric"):... crossprod signature(x = "matrix", y = "magma"):... crossprod signature(x = "numeric", y = "magma"):... gpu<- signature(object = "magma"):... gpu signature(object = "magma"):... lu signature(x = "magma"):... qr signature(x = "magma"):... show signature(object = "magma"):... solve signature(a = "magma", b = "magma"):... solve signature(a = "magma", b = "matrix"):... solve signature(a = "magma", b = "missing"):... solve signature(a = "magma", b = "numeric"):... solve signature(a = "matrix", b = "magma"):...

9 magma-class 9 tcrossprod signature(x = "magma", y = "magma"):... tcrossprod signature(x = "magma", y = "matrix"):... tcrossprod signature(x = "magma", y = "missing"):... tcrossprod signature(x = "magma", y = "numeric"):... tcrossprod signature(x = "matrix", y = "magma"):... tcrossprod signature(x = "numeric", y = "magma"):... Author(s) Brian J. Smith <brian-j-smith@uiowa.edu> References Stanimire Tomov, Rajib Nath, Hatem Ltaief, and Jack Dongarra (2010) Dense Linear Algebra Solvers for Multicore with GPU Accelerators, Proceedings of IPDPS 2010: 24th IEEE International Parallel and Distributed Processing Symposium, Atlanta, GA, April 2010 ( org/netlib/utk/people/jackdongarra/papers/lawn225.pdf). See Also magma, gpu, crossprod, tcrossprod, backsolve, forwardsolve, chol, chol2inv, lu, qr, solve Examples ## magma matrix and base matrix and vector ma <- magma(c(1, 0.4, 0.2, 0.4, 1, 0.3, 0.2, 0.3, 1), 3, 3) B <- matrix(1, 3, 4) x <- c(1, 2, 3) ## element extraction ma[1,2] ma[1,] ma[1,,drop=false] ma[,2] ma[,2,drop=false] ## matrix algebra x + 10 * ma %*% B ## crossproduct crossprod(b, ma) crossprod(x, ma) ## general linear solver solve(ma) solve(ma, x) ## triangular solver mb <- ma mb[lower.tri(mb)] <- 0

10 10 magmalu-class backsolve(mb, diag(nrow(mb))) backsolve(mb, x) ## Cholesky decomposition and inverse U <- chol(ma) print(u) chol2inv(u) ## LU decomposition and solver LU <- lu(ma) solve(lu) solve(lu, x) ## QR decomposition and solver QR <- qr(ma) solve(qr) solve(qr, x) magmalu-class Class "magmalu" Description Storage for an LU decomposition as computed for a magma matrix using the lu method function. Objects from the Class Objects can be created by calls of the form new("magmalu", data, nrow, ncol, byrow, dimnames,...). More commonly the objects are created explicitly from calls of the form lu(x) where x is an object that inherits from the "magma" class or as a side-effect of other functions applied to "magma" objects. Slots.Data: Object of class "matrix" pivot: Object of class "numeric" gpu: Object of class "logical" Extends Class "magma", directly. Class "matrix", by class "magma", distance 2. Class "array", by class "magma", distance 3. Class "structure", by class "magma", distance 4. Class "vector", by class "magma", distance 5, with explicit coerce.

11 magmaqr-class 11 Methods show signature(object = "magmalu"):... solve signature(a = "magmalu", b = "matrix"):... solve signature(a = "magmalu", b = "missing"):... solve signature(a = "magmalu", b = "numeric"):... Author(s) Brian J. Smith <brian-j-smith@uiowa.edu> References Stanimire Tomov, Rajib Nath, Hatem Ltaief, and Jack Dongarra (2010) Dense Linear Algebra Solvers for Multicore with GPU Accelerators, Proceedings of IPDPS 2010: 24th IEEE International Parallel and Distributed Processing Symposium, Atlanta, GA, April 2010 ( org/netlib/utk/people/jackdongarra/papers/lawn225.pdf). See Also lu Examples ma <- magma(c(1, 0.4, 0.2, 0.4, 1, 0.3, 0.2, 0.3, 1), 3, 3) y <- c(1, 2, 3) ## magmalu object LU <- lu(ma) ## solution to A %*% x = y x <- solve(lu, y) ## check solution val <- ma %*% x all.equal(as.numeric(val), as.numeric(y)) magmaqr-class Class "magmaqr" Description Storage for a QR decomposition as computed for a magma matrix using the qr function. Objects from the Class Objects can be created by calls of the form new("magmaqr",...). More commonly the objects are created explicitly from calls of the form qr(x) where x is an object that inherits from the "magma" class or as a side-effect of other functions applied to "magma" objects.

12 12 magmaqr-class Slots Extends work: Object of class "numeric"..s3class: Object of class "qr". Class "qr", directly. Class "oldclass", by class "qr", distance 2. Methods show signature(object = "magmaqr"):... solve signature(a = "magmaqr", b = "matrix"):... solve signature(a = "magmaqr", b = "missing"):... solve signature(a = "magmaqr", b = "numeric"):... Author(s) Brian J. Smith <brian-j-smith@uiowa.edu> References Stanimire Tomov, Rajib Nath, Hatem Ltaief, and Jack Dongarra (2010) Dense Linear Algebra Solvers for Multicore with GPU Accelerators, Proceedings of IPDPS 2010: 24th IEEE International Parallel and Distributed Processing Symposium, Atlanta, GA, April 2010 ( org/netlib/utk/people/jackdongarra/papers/lawn225.pdf). See Also magma, qr Examples ma <- magma(c(1, 0.4, 0.2, 0.4, 1, 0.3, 0.2, 0.3, 1), 3, 3) y <- c(1, 2, 3) ## magmaqr object QR <- qr(ma) ## solution to A %*% x = y x <- solve(qr, y) ## check solution val <- ma %*% x all.equal(as.numeric(val), as.numeric(y))

13 Index Topic algebra backsolve, 2 lu, 4 magma, 5 magma-class, 7 magmalu-class, 10 magmaqr-class, 11 Topic array backsolve, 2 lu, 4 magma, 5 Topic classes gpu, 3 magma-class, 7 magmalu-class, 10 magmaqr-class, 11 [,magma,any,any-method [,magma,any,missing-method [,magma,missing,any-method [,magma,missing,missing-method %*%,magma,magma-method %*%,magma,matrix-method %*%,magma,numeric-method (magma-class), 7 %*%,matrix,magma-method %*%,numeric,magma-method (magma-class), 7 Arith,magma,magma-method (magma-class), 7 Arith,magma,matrix-method Arith,magma,numeric-method Arith,matrix,magma-method Arith,numeric,magma-method array, 7, 10 backsolve, 2, 9 backsolve,magma,magma-method (backsolve), 2 backsolve,magma,matrix-method (backsolve), 2 backsolve,magma,numeric-method (backsolve), 2 backsolve,matrix,magma-method (backsolve), 2 chol, 9 chol,magma-method chol2inv, 9 chol2inv,magma-method crossprod, 9 crossprod,magma,magma-method crossprod,magma,matrix-method crossprod,magma,missing-method crossprod,magma,numeric-method crossprod,matrix,magma-method crossprod,numeric,magma-method dimnames, 6, 7 forwardsolve, 9 forwardsolve (backsolve), 2 gpu, 3, 6, 9 gpu,magma-method (gpu), 3 gpu<- (gpu), 3 gpu<-,magma-method (gpu), 3 13

14 14 INDEX lu, 4, 9 11 lu,magma-method (lu), 4 magma, 2 5, 5, 6, 7, 9, 10, 12 magma-class, 7 magmalu, 5 magmalu-class, 10 magmaqr-class, 11 matrix, 5 7, 10 NULL, 6, 7 tcrossprod,magma,missing-method tcrossprod,magma,numeric-method tcrossprod,matrix,magma-method tcrossprod,numeric,magma-method vector, 7, 10 oldclass, 12 qr, 9, 11, 12 qr,magma-method show,magma-method show,magmalu-method (magmalu-class), 10 show,magmaqr-method (magmaqr-class), 11 solve, 9 solve,magma,magma-method (magma-class), 7 solve,magma,matrix-method solve,magma,missing-method solve,magma,numeric-method solve,magmalu,matrix-method (magmalu-class), 10 solve,magmalu,missing-method (magmalu-class), 10 solve,magmalu,numeric-method (magmalu-class), 10 solve,magmaqr,matrix-method (magmaqr-class), 11 solve,magmaqr,missing-method (magmaqr-class), 11 solve,magmaqr,numeric-method (magmaqr-class), 11 solve,matrix,magma-method structure, 7, 10 tcrossprod, 9 tcrossprod,magma,magma-method tcrossprod,magma,matrix-method