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

Go to the documentation of this file.

#ifndef LAMA_CSRSTORAGE_HPP_
#define LAMA_CSRSTORAGE_HPP_

// for dll_import
#include <lama/config.hpp>

// base classes
#include <lama/storage/CRTPMatrixStorage.hpp>

namespace lama
{

template<typename T>
class LAMA_DLL_IMPORTEXPORT CSRStorage: public CRTPMatrixStorage<CSRStorage<T>, T>
{
public:

    typedef T ValueType;    

    static const char* typeName();

    CSRStorage();

    CSRStorage(const IndexType numRows, const IndexType numColumns);

    CSRStorage( const IndexType numRows,
                const IndexType numColumns,
                const IndexType numValues,
                const LAMAArray<IndexType>& ia,
                const LAMAArray<IndexType>& ja,
                const LAMAArray<ValueType>& values  );

    explicit CSRStorage( const _MatrixStorage& other ) {  assign( other ); }

    CSRStorage( const _MatrixStorage& other, const ContextPtr context )
    {  _MatrixStorage::setContext(context); assign( other ); }
    
    CSRStorage<ValueType>& operator=( const _MatrixStorage& other)
    {  assign( other );  return *this; }

    virtual void clear();

    virtual void purge();

    virtual CSRStorage* copy() const;

    virtual CSRStorage* create() const;

    virtual ~CSRStorage();

    void check( const char* msg ) const;

    virtual MatrixStorageFormat getFormat() const;

    virtual void setIdentity(const IndexType size);

    template<typename OtherValueType>
    void setCSRDataImpl( const IndexType numRows,
                         const IndexType numColumns,
                         const IndexType numValues,
                         const LAMAArray<IndexType>& ia,
                         const LAMAArray<IndexType>& ja,
                         const LAMAArray<OtherValueType>& values,
                         const ContextPtr loc );

    template<typename OtherValueType>
    void setCSRDataSwap( const IndexType numRows,
                         const IndexType numColumns,
                         const IndexType numValues,
                               LAMAArray<IndexType>& ia,
                               LAMAArray<IndexType>& ja,
                               LAMAArray<OtherValueType>& values,
                         const ContextPtr loc );
                        

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

    LAMAArray<IndexType>& getIA();

    LAMAArray<IndexType>& getJA();

    LAMAArray<ValueType>& getValues();

    const LAMAArray<IndexType>& getIA() const;

    const LAMAArray<IndexType>& getJA() const;

    const LAMAArray<ValueType>& getValues() const;

    IndexType getNumValues() const;

    template<typename OtherType>
    void getRowImpl( LAMAArray<OtherType>& row, const IndexType i ) const;

    template<typename OtherValueType>
    void getDiagonalImpl( LAMAArray<OtherValueType>& diagonal ) const;

    template<typename OtherValueType>
    void setDiagonalImpl( const LAMAArray<OtherValueType>& diagonal );

    void setDiagonalImpl( const Scalar scalar );

    /******************************************************************
    *  Scaling of elements in a matrix                                *
    ******************************************************************/

    template<typename OtherType>
    void scaleImpl( const LAMAArray<OtherType>& values );

    void scaleImpl( const Scalar value );

    T getValue(IndexType i, IndexType j) const;

    virtual void prefetch( const ContextPtr location ) const;

    void wait() const;

    using MatrixStorage<ValueType>::mDiagonalProperty;
    using MatrixStorage<ValueType>::mRowIndexes;
    using MatrixStorage<ValueType>::mCompressThreshold;

    using MatrixStorage<ValueType>::prefetch;
    using MatrixStorage<ValueType>::getContext;
    using MatrixStorage<ValueType>::getContextPtr;

    IndexType mNumValues; 

    LAMAArray<IndexType> mIa; 
    LAMAArray<IndexType> mJa; 
    LAMAArray<ValueType> mValues; 

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

    void compress( const ValueType eps = 0.0 );

    void swap( CSRStorage<ValueType>& other );

    void swap( LAMAArray<IndexType>& ia, LAMAArray<IndexType>& ja, LAMAArray<ValueType>& values );

    virtual size_t getMemoryUsageImpl() const;

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

    virtual void assign( const _MatrixStorage& other );

    virtual void copyTo( _MatrixStorage& other ) const;

    template<typename OtherValueType>
    void buildCSR( LAMAArray<IndexType>& ia,
                   LAMAArray<IndexType>* ja,
                   LAMAArray<OtherValueType>* values,
                   const ContextPtr /* loc */ ) const;

    virtual void buildCSCData( LAMAArray<IndexType>& colIA,
                               LAMAArray<IndexType>& colJA,
                               LAMAArray<ValueType>& cscValues ) const;

    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 matrixTimesMatrix(
        const ValueType alpha, 
        const MatrixStorage<ValueType>& a,
        const MatrixStorage<ValueType>& b,
        const ValueType beta, 
        const MatrixStorage<ValueType>& c );

    virtual void jacobiIterate(
        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;

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

    virtual ValueType maxDiffNormImpl ( const CSRStorage<ValueType>& other );

    void print() const;

protected:

    using MatrixStorage<ValueType>::mNumRows;
    using MatrixStorage<ValueType>::mNumColumns;

private:

    bool mSortedRows;  

    virtual bool checkDiagonalProperty() const;

    void buildRowIndexes( );

    LAMA_LOG_DECL_STATIC_LOGGER( logger ); 

    void matrixAddMatrixCSR( const ValueType alpha, 
                             const CSRStorage<ValueType>& a,
                             const ValueType beta,
                             const CSRStorage<ValueType>& b );

    void matrixTimesMatrixCSR( const ValueType alpha, 
                               const CSRStorage<ValueType>& a,
                               const CSRStorage<ValueType>& b );
};

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

}
#endif // LAMA_CSRSTORAGE_HPP_