CSRMatrixOperationsDevice.h

Go to the documentation of this file.

#ifndef included_CSRMatrixOperationsDevice_H_
#define included_CSRMatrixOperationsDevice_H_
 
#include "AMP/matrices/data/MatrixData.h"
#include "AMP/matrices/operations/MatrixOperations.h"
#include "AMP/matrices/operations/device/CSRLocalMatrixOperationsDevice.h"
#include "AMP/matrices/operations/device/spgemm/CSRMatrixSpGEMMDevice.h"
#include "AMP/vectors/Vector.h"
 
#include <map>
 
namespace AMP::LinearAlgebra {
 
template<typename Config>
class CSRMatrixOperationsDevice : public MatrixOperations
{
public:
    static_assert( std::is_same_v<typename Config::allocator_type::value_type, void> );
 
    using config_type       = Config;
    using allocator_type    = typename Config::allocator_type;
    using matrixdata_t      = CSRMatrixData<Config>;
    using localmatrixdata_t = typename matrixdata_t::localmatrixdata_t;
 
    using localops_t = CSRLocalMatrixOperationsDevice<Config>;
 
    using gidx_t   = typename Config::gidx_t;
    using lidx_t   = typename Config::lidx_t;
    using scalar_t = typename Config::scalar_t;
 
    void mult( std::shared_ptr<const Vector> x,
               MatrixData const &A,
               std::shared_ptr<Vector> y ) override;
 
    void multTranspose( std::shared_ptr<const Vector> in,
                        MatrixData const &A,
                        std::shared_ptr<Vector> out ) override;
 
    void scale( AMP::Scalar alpha, MatrixData &A ) override;
 
    void scale( AMP::Scalar, std::shared_ptr<const Vector>, MatrixData & ) override
    {
        AMP_ERROR( "Not implemented" );
    }
 
    void scaleInv( AMP::Scalar, std::shared_ptr<const Vector>, MatrixData & ) override
    {
        AMP_ERROR( "Not implemented" );
    }
 
    void matMatMult( std::shared_ptr<MatrixData> A,
                     std::shared_ptr<MatrixData> B,
                     std::shared_ptr<MatrixData> C ) override;
 
    void axpy( AMP::Scalar alpha, const MatrixData &X, MatrixData &Y ) override;
 
    void setScalar( AMP::Scalar alpha, MatrixData &A ) override;
 
    void zero( MatrixData &A ) override;
 
    void setDiagonal( std::shared_ptr<const Vector> in, MatrixData &A ) override;
 
    void extractDiagonal( MatrixData const &A, std::shared_ptr<Vector> buf ) override;
 
    void getRowSums( MatrixData const &, std::shared_ptr<Vector> ) override
    {
        AMP_ERROR( "Not implemented" );
    }
 
    void getRowSumsAbsolute( MatrixData const &, std::shared_ptr<Vector>, const bool ) override
    {
        AMP_ERROR( "Not implemented" );
    }
 
    void setIdentity( MatrixData &A ) override;
 
    AMP::Scalar LinfNorm( const MatrixData &X ) const override;
 
    void copy( const MatrixData &X, MatrixData &Y ) override;
 
    void copyCast( const MatrixData &X, MatrixData &Y ) override;
 
    template<typename ConfigIn>
    static void
    copyCast( CSRMatrixData<typename ConfigIn::template set_alloc_t<Config::allocator>> *X,
              matrixdata_t *Y );
 
    std::string type() const override { return "CSRMatrixOperationsDevice"; }
 
    void writeRestart( int64_t fid ) const override;
 
    CSRMatrixOperationsDevice() = default;
    CSRMatrixOperationsDevice( int64_t, AMP::IO::RestartManager * ) {}
 
protected:
    std::map<std::pair<std::shared_ptr<matrixdata_t>, std::shared_ptr<matrixdata_t>>,
             CSRMatrixSpGEMMDevice<Config>>
        d_SpGEMMHelpers;
};
 
} // namespace AMP::LinearAlgebra
 
#endif