ArrayVectorData.h

Go to the documentation of this file.

#ifndef included_AMP_ArrayVectorData
#define included_AMP_ArrayVectorData
 
#include <string>
 
#include "AMP/utils/Array.h"
#include "AMP/utils/FunctionTable.h"
#include "AMP/utils/Memory.h"
#include "AMP/utils/UtilityMacros.h"
#include "AMP/vectors/data/GhostDataHelper.hpp"
#include "AMP/vectors/data/VectorData.h"
 
 
namespace AMP::LinearAlgebra {
 
template<typename T, typename FUN = FunctionTable<T>, typename Allocator = AMP::HostAllocator<void>>
class ArrayVectorData : public GhostDataHelper<T, Allocator>
{
private:
    AMP::Array<T, FUN, Allocator> d_array;
    AMP_MPI d_comm;
    size_t d_offset = 0;
    ArraySize d_blockIndex;
    ArraySize d_globalArraySize;
 
public:
    static std::shared_ptr<ArrayVectorData> create( const ArraySize &localSize );
 
    static std::shared_ptr<ArrayVectorData>
    create( const ArraySize &localSize, const ArraySize &blockIndex, AMP_MPI comm );
 
    static std::shared_ptr<ArrayVectorData>
    create( const size_t localSize, std::shared_ptr<CommunicationList> commList, T *data );
 
    ArrayVectorData() = default;
 
    virtual ~ArrayVectorData() {}
 
    ArrayVectorData( const ArrayVectorData & ) = delete;
 
    const AMP_MPI &getComm() const override { return d_comm; }
 
    void resize( const ArraySize &localDims );
 
    Array<T, FUN, Allocator> &getArray( void ) { return d_array; }
 
    const Array<T, FUN, Allocator> &getArray( void ) const { return d_array; }
 
    size_t numberOfDataBlocks() const override { return 1; }
 
    size_t sizeOfDataBlock( size_t i = 0 ) const override { return i == 0 ? d_array.length() : 0; }
 
    void putRawData( const void *buf, const typeID &id ) override;
 
    void getRawData( void *buf, const typeID &id ) const override;
 
    void setValuesByLocalID( size_t num,
                             const size_t *indices,
                             const void *vals,
                             const typeID &id ) override;
 
    void addValuesByLocalID( size_t num,
                             const size_t *indices,
                             const void *vals,
                             const typeID &id ) override;
 
    void getValuesByLocalID( size_t num,
                             const size_t *indices,
                             void *vals,
                             const typeID &id ) const override;
 
    uint64_t getDataID() const override { return reinterpret_cast<uint64_t>( d_array.data() ); }
 
    std::string VectorDataName() const override { return "ArrayVector"; }
 
protected:
    void *getRawDataBlockAsVoid( size_t i ) override
    {
        AMP_ASSERT( i == 0 );
        return d_array.data();
    }
 
    const void *getRawDataBlockAsVoid( size_t i ) const override
    {
        AMP_ASSERT( i == 0 );
        return d_array.data();
    }
 
    typeID getType( size_t ) const override { return getTypeID<T>(); }
    size_t sizeofDataBlockType( size_t ) const override { return sizeof( T ); }
    void swapData( VectorData & ) override;
    std::shared_ptr<VectorData> cloneData( const std::string &name = "" ) const override;
};
 
} // namespace AMP::LinearAlgebra
 
#include "AMP/vectors/data/ArrayVectorData.hpp"
 
#endif