/home/brandes/workspace/LAMA/src/lama/storage/MatrixStorage.hpp

Go to the documentation of this file.

#ifndef LAMA_MATRIX_STORAGE_HPP_
#define LAMA_MATRIX_STORAGE_HPP_

#include <ostream>

// others
#include <lama/LAMAArray.hpp>

#include <lama/io/FileType.hpp>

namespace lama
{

class Distribution;  // Forward declaration

typedef enum
{
  CSR,
  ELL,
  DIA,
  JDS,
  COO,
  DENSE,
  ASSEMBLY,
  UNDEFINED
} MatrixStorageFormat;

std::ostream& operator<< ( std::ostream& stream, 
                           const MatrixStorageFormat storageFormat );

class LAMA_DLL_IMPORTEXPORT _MatrixStorage : public Printable
{
public:

    _MatrixStorage( const IndexType numRows, const IndexType numColumns);

    _MatrixStorage();

    virtual ~_MatrixStorage();

    virtual const char* getTypeName() const = 0;

    void init( const IndexType numRows, const IndexType numColumns );

    virtual Scalar::ScalarType getValueType() const = 0;

    virtual void clear() = 0;

    virtual void purge() = 0;

    virtual void allocate( const IndexType numRows, const IndexType numColumns) = 0;

    /******************************************************************
    *  mContext  : setter / getter for preferred context              *
    ******************************************************************/
 
    void setContext( ContextPtr context );

    ContextPtr getContextPtr() const { return mContext; }

    const Context& getContext() const { return *mContext; }

    virtual void prefetch( const ContextPtr context ) const = 0;

    void prefetch() const { prefetch( mContext ); }

    virtual void wait() const = 0;

    void setCompressThreshold(float ratio);

    inline IndexType getNumRows() const;

    inline IndexType getNumColumns() const;

    virtual void writeAt(std::ostream& stream) const;

    void resetDiagonalProperty();

    inline bool hasDiagonalProperty() const;

    virtual MatrixStorageFormat getFormat() const = 0;

    virtual void setIdentity( const IndexType n ) = 0;

    virtual void getRow( _LAMAArray& row, const IndexType i ) const = 0;

    virtual void getDiagonal( _LAMAArray& diagonal ) const = 0;

    virtual void setDiagonal( const _LAMAArray& diagonal ) = 0;

    virtual void setDiagonal( const Scalar value ) = 0;

    /******************************************************************
    *  Scaling of elements in a matrix                                *
    ******************************************************************/
 
    virtual void scale( const Scalar value ) = 0;

    virtual void scale( const _LAMAArray& values ) = 0;

    /******************************************************************
    *  General operations on a matrix                                 *
    ******************************************************************/
 
    virtual void localize( const _MatrixStorage& global,
                           const Distribution& rowDist );

    virtual IndexType getNumValues() const;

    inline const LAMAArray<IndexType>& getRowIndexes() const;

    virtual void buildCSRSizes( LAMAArray<IndexType>& csrIA ) const = 0;

    virtual void buildCSRData( LAMAArray<IndexType>& csrIA,
                               LAMAArray<IndexType>& csrJA,
                               _LAMAArray& csrValues ) const = 0;

    virtual void setCSRData( const IndexType numRows,
                             const IndexType numColumns,
                             const IndexType numValues,
                             const LAMAArray<IndexType>& csrIA,
                             const LAMAArray<IndexType>& csrJA,
                             const _LAMAArray& csrValues ) = 0;

    virtual void assign( const _MatrixStorage& other ) = 0;

    virtual void copyTo( _MatrixStorage& other ) const = 0;

    _MatrixStorage& operator=( const _MatrixStorage& other );

    /******************************************************************
    *   Help routines (ToDo: -> LAMAArrayUtils ?? )                   *
    ******************************************************************/
 
    static void offsets2sizes( LAMAArray<IndexType>& offsets );

    static void offsets2sizes( LAMAArray<IndexType>& sizes, const LAMAArray<IndexType>& offsets );

    static IndexType sizes2offsets( LAMAArray<IndexType>& sizes );

    /******************************************************************
    *   Query routines                                                *
    ******************************************************************/
 
    size_t getMemoryUsage() const;

    virtual void check( const char* msg ) const = 0;

    virtual _MatrixStorage* create() const = 0;

    virtual _MatrixStorage* copy() const = 0;

protected:

    void swap( _MatrixStorage& other );

    virtual void _assignTranspose( const _MatrixStorage& other );

    virtual void _assign( const _MatrixStorage& other );

    virtual size_t getMemoryUsageImpl() const =0;

    IndexType mNumRows;

    IndexType mNumColumns;

    LAMAArray<IndexType> mRowIndexes; 

    float mCompressThreshold;   

    bool mDiagonalProperty;  

    LAMA_LOG_DECL_STATIC_LOGGER( logger );  

    ContextPtr mContext;        

private:

    virtual bool checkDiagonalProperty() const = 0;
};

class Distribution;

template<typename T>
class LAMA_DLL_IMPORTEXPORT MatrixStorage : public _MatrixStorage
{
public:

    typedef T ValueType;

    MatrixStorage( const IndexType numRows,
                   const IndexType numColumns);

    MatrixStorage();

    virtual ~MatrixStorage();

    virtual MatrixStorage* create() const = 0;

    virtual MatrixStorage* copy() const = 0;

    virtual Scalar::ScalarType getValueType() const;

    template<typename OtherValueType>
    void setRawDenseData( const IndexType numRows,
                          const IndexType numColumns,
                          const OtherValueType values[],
                          const ValueType eps = 0.0 );

    template<typename OtherValueType>
    void setRawCSRData( const IndexType numRows,
                        const IndexType numColumns,
                        const IndexType numValues,
                        const IndexType* const ia,
                        const IndexType* const ja,
                        const OtherValueType* const values);

    virtual void joinHalo( const _MatrixStorage& localData,
                           const _MatrixStorage& haloData,
                           const class Halo& halo, 
                           const class Distribution& colDist );

    virtual void splitHalo( MatrixStorage<ValueType>& localData,
                            MatrixStorage<ValueType>& haloData,
                            class Halo& halo,
                            const class Distribution& colDist,
                            const class Distribution* rowDist ) const;

    virtual void buildHalo( class Halo& halo,
                            const class Distribution& colDist );

    virtual void localize( const _MatrixStorage& globalData, 
                           const class Distribution& rowDist );
    
    virtual void replicate( const _MatrixStorage& localData,
                            const class Distribution& rowDist );

    virtual ValueType getValue( IndexType i, IndexType j ) const = 0;

    virtual void buildCSCData( LAMAArray<IndexType>& cscIA,
                               LAMAArray<IndexType>& cscJA,
                               LAMAArray<ValueType>& cscValues ) const;

    virtual void assign( const _MatrixStorage& other );

    virtual void copyTo( _MatrixStorage& other ) const;

    virtual void assignTranspose( const MatrixStorage<ValueType>& other );

    virtual void redistribute( const _MatrixStorage& other, const class Redistributor& redistributor );

    virtual void exchangeHalo( const class Halo& halo, const MatrixStorage<ValueType>& matrix,
                               const class Communicator& comm );

    static void convertCSR2CSC( LAMAArray<IndexType>& colIA,
                                LAMAArray<IndexType>& colJA,
                                LAMAArray<ValueType>& colValues,
                                const IndexType numColumns,
                                const LAMAArray<IndexType>& rowIA,
                                const LAMAArray<IndexType>& rowJA,
                                const LAMAArray<ValueType>& rowValues,
                                const ContextPtr loc );
    static void joinRows( LAMAArray<IndexType>& outIA,
                          LAMAArray<IndexType>& outJA,
                          LAMAArray<ValueType>& outValues,
                          const IndexType numRows,
                          const LAMAArray<IndexType>& rowIndexes,
                          const LAMAArray<IndexType>& inIA,
                          const LAMAArray<IndexType>& inJA,
                          const LAMAArray<ValueType>& inValues );

    MatrixStorage& operator=( const _MatrixStorage& other );

    /******************************************************************
    *   File I/O for MatrixStorage                                    *
    ******************************************************************/
 
    virtual void writeToFile( const std::string& fileName,
                              const File::FileType fileType = File::BINARY,
                              const File::DataType dataType = File::INTERNAL,
                              const File::IndexDataType indexDataTypeIA = File::INT, 
                              const File::IndexDataType indexDataTypeJA = File::INT ) const;

    virtual void writeToFile( const PartitionId size,
                              const PartitionId rank,
                              const std::string& fileName,
                              const File::FileType fileType = File::BINARY,
                              const File::DataType dataType = File::INTERNAL,
                              const File::IndexDataType indexDataTypeIA = File::INT, 
                              const File::IndexDataType indexDataTypeJA = File::INT ) const;

    virtual void readFromFile( const std::string& fileName );

    /******************************************************************
    *   invert                                                        *
    ******************************************************************/

    virtual void invert( const MatrixStorage<ValueType>& other );
 
    /******************************************************************
    *   Matrix * ( Vector | Matrix )                                  *
    ******************************************************************/
 
    virtual void matrixTimesVector(
        LAMAArrayView<ValueType> result,
        const ValueType alpha, const LAMAArrayConstView<ValueType> x,
        const ValueType beta, const LAMAArrayConstView<ValueType> y ) const;

    virtual void matrixTimesVectorN(
        LAMAArrayView<ValueType> result,
        const IndexType n,
        const ValueType alpha, const LAMAArrayConstView<ValueType> x,
        const ValueType beta, const LAMAArrayConstView<ValueType> y ) const;

    virtual std::auto_ptr<SyncToken> matrixTimesVectorAsync(
        LAMAArrayView<ValueType> result,
        const ValueType alpha, const LAMAArrayConstView<ValueType> x,
        const ValueType beta, const LAMAArrayConstView<ValueType> y ) const;

    virtual void matrixTimesScalar(
        const ValueType alpha, 
        const MatrixStorage<ValueType>& a );

    virtual void matrixTimesMatrix(
        const ValueType alpha, 
        const MatrixStorage<ValueType>& a,
        const MatrixStorage<ValueType>& b,
        const ValueType beta, 
        const MatrixStorage<ValueType>& c );

    virtual ValueType maxDiffNorm ( const MatrixStorage<ValueType>& other );

    /******************************************************************
    *   Solver methods (e.g. Jacobi )                                 *
    ******************************************************************/
 
    virtual void jacobiIterate(
        LAMAArrayView<ValueType> solution, const LAMAArrayConstView<ValueType> oldSolution,
        const LAMAArrayConstView<ValueType> rhs, const ValueType omega) const;

    virtual std::auto_ptr<SyncToken> jacobiIterateAsync(
        LAMAArrayView<ValueType> solution, const LAMAArrayConstView<ValueType> oldSolution,
        const LAMAArrayConstView<ValueType> rhs, const ValueType omega) const;

    virtual void jacobiIterateHalo(
        LAMAArrayView<ValueType> localSolution, 
        const MatrixStorage<ValueType>& localStorage, 
        const LAMAArrayConstView<ValueType> haloOldSolution,
        const ValueType omega ) const;
   
    using _MatrixStorage::getContext;
    using _MatrixStorage::getContextPtr;

protected:

    ValueType mEpsilon;

    void swap( MatrixStorage<ValueType>& other );
};

/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */

IndexType _MatrixStorage::getNumRows() const
{
    return mNumRows;
}

IndexType _MatrixStorage::getNumColumns() const
{
    return mNumColumns;
}

bool _MatrixStorage::hasDiagonalProperty() const
{
    return mDiagonalProperty;
}

const LAMAArray<IndexType>& _MatrixStorage::getRowIndexes() const
{
    return mRowIndexes;
}

/* ------------------------------------------------------------------------- */

template<typename ValueType>
template<typename OtherValueType>
void MatrixStorage<ValueType>::setRawCSRData( const IndexType numRows,
                                              const IndexType numColumns,
                                              const IndexType numValues,
                                              const IndexType* const ia,
                                              const IndexType* const ja,
                                              const OtherValueType* const values)
{
    // wrap the pointer data into LAMA arrays ( without copies )

    LAMAArrayRef<IndexType> csrIA( ia, numRows + 1 );
    LAMAArrayRef<IndexType> csrJA( ja, numValues );
    LAMAArrayRef<OtherValueType> csrValues( values, numValues );

    // now set the data on the context of this storage via virtual method

    setCSRData( numRows, numColumns, numValues, csrIA, csrJA, csrValues );
}

} // namespace lama

#endif // LAMA_MATRIX_STORAGE_HPP_