/home/brandes/workspace/LAMA/src/lama/DenseVector.hpp

Go to the documentation of this file.

#ifndef LAMA_DENSE_VECTOR_HPP_
#define LAMA_DENSE_VECTOR_HPP_

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

// base classes
#include <lama/Vector.hpp>

// others
#include <lama/HostWriteAccess.hpp>
#include <lama/HostReadAccess.hpp>
#include <lama/LAMAArray.hpp>
#include <lama/SyncToken.hpp>
#include <lama/TypeTraits.hpp>

#include <lama/distribution/Distribution.hpp>
#include <lama/distribution/Halo.hpp>
#include <lama/distribution/HaloBuilder.hpp>

#include <lama/exception/Exception.hpp>

#include <lama/io/mmio.hpp>
#include <lama/io/FileType.hpp>
#include <lama/io/XDRFileStream.hpp>

#include <fstream>

namespace lama
{

template<typename T>
class LAMA_DLL_IMPORTEXPORT DenseVector : public Vector
{
public:

    typedef T ValueType;

    DenseVector();

    DenseVector( DistributionPtr distribution);

    DenseVector( const IndexType size, const ValueType value );

    DenseVector( DistributionPtr distribution, const ValueType value );

    template<typename OtherValueType>
    DenseVector(const IndexType size,
        const OtherValueType* values);

    DenseVector( const DenseVector<ValueType>& other );

    DenseVector( const Vector& other );

    DenseVector( const Vector& other, DistributionPtr distribution );

    DenseVector( const _LAMAArray& localValues, DistributionPtr distribution );

    DenseVector( const std::string& filename );

    DenseVector(const Expression<Scalar,Vector,Times>& expression);

    DenseVector(const Expression<Expression<Scalar,Vector,Times>, Expression<Scalar,Vector,Times>, Plus>& expression);

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

    DenseVector(const Expression<Expression<Scalar, Expression<Matrix, Vector, Times>, Times>, 
                                 Expression<Scalar, Vector,Times>, 
                                 Plus>& expression);
    DenseVector(const Expression<Scalar,Expression<Matrix, Vector, Times>, Times>& expression);

    DenseVector(const Expression<Matrix, Vector, Times>& expression);

    virtual ~DenseVector();

    void allocate( DistributionPtr distribution );

    DenseVector& operator=( const DenseVector<T>& other );

    DenseVector& operator=( const Scalar );

    virtual Scalar::ScalarType getValueType() const;

    virtual void buildValues( _LAMAArray& values ) const;

    virtual void setValues( const _LAMAArray& values );

    virtual std::auto_ptr<Vector> create() const;

    virtual std::auto_ptr<Vector> create( DistributionPtr distribution ) const;

    //TODO: We either need a none const getLocalValues()
    // or an operator[] with local sematics or both
    // i guess both is the most intuitive because a user that does not request
    // a parallel environment expects the operator[] to exists
    // and for users of a distributed DenseVector the usage of
    // getLocalValues and getHaloValues is more explicite and there for
    // better understandable and less errorprone.
    // Maybe an access proxy would be a nice solution, because with a proxy we
    // can avoid to change the size and other attributes of the LAMAArray
    // mLocalValues.
    LAMAArray<T>& getLocalValues() { return mLocalValues; }

    const LAMAArray<T>& getLocalValues() const { return mLocalValues; }

    LAMAArray<T>& getHaloValues() const { return mHaloValues; }

    void updateHalo( const Halo& halo ) const;

    std::auto_ptr<SyncToken> updateHaloAsync( const Halo& halo ) const;

    virtual Scalar getValue(IndexType globalIndex) const;

    virtual Scalar min() const;

    virtual Scalar max() const;

    virtual Scalar l1Norm() const;

    virtual Scalar l2Norm() const;

    virtual Scalar maxNorm() const;

    static void vectorPlusVector( ContextPtr context, LAMAArrayView<T> result,
                                    const T alpha, const LAMAArrayConstView<T> x,
                                    const T beta, const LAMAArrayConstView<T> y );

    virtual void swap(Vector& other);

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

    virtual void assign( const Expression<Expression<Scalar,Vector,Times>,
                                          Expression<Scalar,Vector,Times>,
                                          Plus >& expression );

    virtual void assign( const Scalar value );

    virtual void assign( const Vector& other );

    virtual void assign( const _LAMAArray& localValues, DistributionPtr dist );

    virtual void buildLocalValues( _LAMAArray& localValues ) const;

    virtual Scalar dotProduct( const Vector& other ) const;

    virtual void prefetch( const ContextPtr location ) const;

    virtual void wait() const;

    virtual void invert();

    virtual size_t getMemoryUsage() const;

    virtual void redistribute( DistributionPtr distribution );

    void writeToFile( const std::string& fileBaseName,
                      const File::FileType fileType = File::XDR,
                      const File::DataType dataType = File::DOUBLE ) const;

protected:

    virtual void resizeImpl();

    using Vector::mContext;

    LAMA_LOG_DECL_STATIC_LOGGER(logger);

private:

    long getDataTypeSize( const File::DataType dataType) const;

    void writeVectorToFormattedFile(const std::string& fileName) const;

    void writeVectorToBinaryFile(
        const std::string& fileName,
        const long outputDataTypeSize ) const;

    void writeVectorToXDRFile(
        const std::string& fileName,
        const long outputDataTypeSize ) const;

    void writeVectorDataToBinaryFile(
        std::fstream& outFile,
        const long dataTypeSize ) const;

    void readVectorHeader( const std::string& filename, File::FileType& fileType, long& dataTypeSize );

    void writeVectorHeader(
        const std::string& fileName,
        const File::FileType& fileType,
        const long dataTypeSize ) const;

    void writeVectorToMMFile(
        const std::string& filename,
        const File::DataType& dataType ) const;

    void readVectorFromFormattedFile( const std::string& fileName );

    void readVectorFromBinaryFile(
            const std::string& fileName,
            const long dataTypeSize );

    void readVectorFromXDRFile(
            const std::string& fileName,
            const long dataTypeSizeHeader );

    void readVectorDataFromBinaryFile(
            std::fstream &inFile,
            const long dataTypeSize );

    LAMAArray<T> mLocalValues; 

    mutable LAMAArray<T> mHaloValues;  
};

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

template<typename T>
template<typename OtherValueType>
DenseVector<T>::DenseVector(const IndexType size, const OtherValueType* values)
    : Vector(size)
{
    HostWriteOnlyAccess<T> writeAccess( mLocalValues, size );

#pragma omp parallel for schedule(LAMA_OMP_SCHEDULE)
    for ( IndexType i = 0; i < size; i++ )
    {
        writeAccess[i] = values[i];
    }

    // Halo is not used yet
}

template<typename T>
DenseVector<T>::DenseVector( const DenseVector<ValueType>& other )

   : Vector( other )

{
    // implementation here can be simpler as DenseVector( const Vector& other ) 

    LAMA_LOG_INFO( logger, "Copy of vector of global size " << size()
                      << ", local size " << getDistribution().getLocalSize() );

    mLocalValues = other.getLocalValues();
}

}

#endif // LAMA_DENSE_VECTOR_HPP_