Matrix Types
[Overview of the Implementation]

Detailed Description

The matrix types module implements an internal run-time database of matrix types available to the library implementation.

Matrix types are identified by three pieces of information:

  1. Matrix type name: a unique string descriptor (e.g., "CSR", "CSC", "BCSR", ...)
  2. Integer index type ID: An integer ID number indicating the type of the integer indices stored by this data structure (see oski/scalinfo.h for a list of available types).
  3. Non-zero value type ID: An integer ID number indicating the type of the scalar non-zero values stored by this data structure (see oski/scalinfo.h).

The library maintains a list of the available matrix types (g_avail_mattypes). This list is managed via the matrix type manager module (oski/mattypes.h).

We use this matrix type system for two reasons:

  1. Kernel implementations may be registered at run-time on systems supporting shared libraries and dynamic linking.
  2. Kernel implementations may be "incomplete". For example, the user may define a new matrix type, but only has to provide an implementation of matrix-vector multiply on that type.

Regarding incomplete kernel implementations, an implementor of a new matrix type does not, for example, have to define sparse $A^TA\cdot x$ kernel since a default implementation based on just matrix-vector multiply is possible. However, if she can provide a special tuned implementation, she may do so.

Matrix types implement the interface defined in Matrix Type Interface, where we distinguish betwen the methods a matrix type must provide versus those it may provide.

If you are implementing a new matrix type, start with the code in the matrix type template (Matrix Type Template) and refer to any of the existing types for detailed examples.


file  mattypes.h
 Matrix type management routines.
file  mattypes_internal.h
 Defines a matrix type record.
file  scalinfo.h
 Define the scalar types available to the library.
file  TRIPART/format.h
 \ Block compressed sparse row data structure.


 Matrix Type Interface
 This interface defines the list of possible routines the library expects a matrix type may implement.
 Block Compressed Sparse Row (BCSR) Format
 Single Block Diagonal (BDIAG1) Format
 BDIAG1 format stores only 1 block diagonal of a matrix, where the blocks are stored as dense blocks of size $b\times b$.
 Cache Blocked (CB) Format
 Cache blocking implementation in which each submatrix is stored as a complete matrix handle to an arbitrary matrix type.
 Compressed Sparse Column (CSC) Format
 The CSC implementation reuses most of the CSR (Compressed Sparse Row (CSR) Format) infrastructure, since the arrays representing a matrix $A$ in CSC format are the same as the arrays that would be used to store $A^T$ in CSR format.
 Compressed Sparse Row (CSR) Format
 BeBOP-OSKI supports a general form of compressed sparse row, with the following "features":
  • Either 0-based or 1-based indexing, for C and Fortran compatibility.

 Dense (DENSE) Format
 Dense matrix in unpacked column major format.
 Generalized Compressed Sparse Row (GCSR) Format
 Generalized compressed sparse row (GCSR) format augments the traditional CSR with an optional list of row indices, allowing entire rows to be sparse.
 Matrix Type Template
 Developers implementing their own matrix types can start with this template, replacing all instances of MATTYPE_TEMPLATE within these files to the custom matrix type name (e.g., CSR, BCSR).
 Modified Block Compressed Sparse Row (MBCSR) Format
 Modified block compressed sparse row format stores the block diagonal elements separately from the off-diagonal elements.
 Variable Block Row (VBR) Format
 Variable block row (VBR) format logically partitions the rows and columns, and stores all non-zero blocks block-row-wise.

Generated on Wed Sep 19 16:41:23 2007 for BeBOP Optimized Sparse Kernel Interface Library by  doxygen 1.4.6