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

Go to the documentation of this file.

#ifndef LAMA_DIASTORAGE_HPP_
#define LAMA_DIASTORAGE_HPP_

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

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

namespace lama
{

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

    typedef T ValueType;  

    static const char* typeName();

    DIAStorage( const IndexType numRows, const IndexType numColumns );

    DIAStorage();

    DIAStorage( const IndexType numRows, 
                const IndexType numColumns,
                const IndexType numDiagonals,
                const LAMAArray<IndexType>& offsets, 
                const LAMAArray<ValueType>& values  );

    DIAStorage( const DIAStorage<ValueType>& other );

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

    DIAStorage( const _MatrixStorage& other, const ContextPtr context )
    {  setContext(context); assign( other ); }

    DIAStorage<ValueType>& operator=( const DIAStorage<ValueType>& other)
    {  assign( other );  return *this; }

    DIAStorage<ValueType>& operator=( const _MatrixStorage& other)
    {  assign( other );  return *this; }

    virtual DIAStorage* copy() const;

    virtual DIAStorage* create() const;

    virtual void clear();

    virtual ~DIAStorage();

    void check( const char* msg ) const;

    virtual MatrixStorageFormat getFormat() const;

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

    virtual void purge();

//    /** Switches on/off the diagonal property of the DIA matrix. If on
//     *  the first column index for each row is the row (diagonal element).
//     *
//     *  If matrix data is already available, the main diagonal elements will
//     *  be shifted correspondingly.
//     */
//    void setDiagonalProperty( bool flag );

    virtual void setIdentity( const IndexType size );

    template<typename OtherValueType>
    void getSparseData(
        IndexType* ia,
        IndexType* ja,
        OtherValueType* values,
        const IndexType* permutation = NULL ) const;

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

    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 );

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

    virtual void jacobiIterate(
        LAMAArrayView<ValueType> solution, const LAMAArrayConstView<ValueType> oldSolution,
        const LAMAArrayConstView<ValueType> rhs, const ValueType omega) const;

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

    const LAMAArray<IndexType>& getOffsets() const;

    const LAMAArray<ValueType>& getValues() const;
    
    IndexType getNumDiagonals() const;

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

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

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

    void setDiagonalImpl( const Scalar scalar );

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

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

    virtual void scaleImpl( const Scalar value );

    ValueType getValue( IndexType i, IndexType j ) const;

    void prefetch( const ContextPtr location ) const;

    void wait() const;

    void swap( DIAStorage<ValueType>& other );

    virtual size_t getMemoryUsageImpl() const;

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

    using MatrixStorage<ValueType>::prefetch;
    using MatrixStorage<ValueType>::getContextPtr;
    using MatrixStorage<ValueType>::assign;
    using MatrixStorage<ValueType>::setContext;

    IndexType mNumDiagonals;         

    LAMAArray<IndexType> mOffset;    
    LAMAArray<ValueType> mValues;    

    void print() const;

private:

    virtual bool checkDiagonalProperty() const;

    // values might be stored row-wise or diagonal-wise

    // take this one for row-major order (fits best for cache architecture)

    // inline IndexType index(IndexType irow, IndexType idiag) const { return irow * mNumDiagonals + idiag; }

    // take this one for diag-major order (fits best for GPUs)

    inline IndexType index(IndexType irow, IndexType idiag) const { return idiag * mNumRows + irow; }

    // Help routine to set offset from used diagonals

    void setOffsets( const IndexType maxNumDiagonals, const bool upperDiagonalUsed[], const bool lowerDiagonalUsed[] );

    static void setUsedDiagonal(bool upperDiagonalUsed[], bool lowerDiagonalUsed[],IndexType i, IndexType j);

    LAMA_LOG_DECL_STATIC_LOGGER( logger );  
};

}  // namespace lama

#endif // LAMA_DIASTORAGE_HPP_