Container for dense matrices. More...

#include <cu_dense_matrix.h>

Inheritance diagram for cuDenseMatrix< DataType >:

[legend]

Collaboration diagram for cuDenseMatrix< DataType >:

[legend]

Public Member Functions
	cuDenseMatrix ()
	Default constructor.

	cuDenseMatrix (const DataType *A_, const LongIndexType num_rows_, const LongIndexType num_columns_, const FlagType A_is_row_major_, const FlagType A_is_symmetric_, const int num_gpu_devices_)
	Constructor.

virtual	~cuDenseMatrix ()
	Destructor. This function removes data from GPU devices.

virtual FlagType	is_identity_matrix () const
	Checks whether the matrix is identity.

virtual void	dot (const DataType device_vector, DataType device_product)
	Matrix vector product.

virtual void	dot_plus (const DataType device_vector, const DataType alpha, DataType device_product)
	Matrix vector product written in place.

virtual void	transpose_dot (const DataType device_vector, DataType device_product)
	Transposed-matrix vector product.

virtual void	transpose_dot_plus (const DataType device_vector, const DataType alpha, DataType device_product)
	Transposed-matrix vector product written in place.

Public Member Functions inherited from cuMatrix< DataType >
	cuMatrix ()
	Default constructor.

	cuMatrix (const FlagType A_is_symmetric_)
	Constructor.

virtual	~cuMatrix ()
	Destructor.

DataType	get_eigenvalue (const DataType known_parameters, const DataType known_eigenvalue, const DataType inquiry_parameters) const
	This virtual function is implemented from its pure virtual function of the base class. In this class, this functio has no use and was only implemented so that this class be able to be instantiated (due to the pure virtual function).

virtual void	set_symmetry (const FlagType symmetric)
	Specify whether the matrix is symmetic or non-symmetric.

Public Member Functions inherited from cuLinearOperator< DataType >
	cuLinearOperator ()
	Default constructor.

	cuLinearOperator (const int num_gpu_devices_)
	Constructor with setting `num_rows` and `num_columns`.

virtual	~cuLinearOperator ()
	Destructor.

cublasHandle_t	get_cublas_handle () const
	This function returns a reference to the `cublasHandle_t` object. The object will be created, if it is not created already.

void	set_parameters (DataType *parameters_)
	Sets the scalar parameter `this->parameters`. Parameter is initialized to `NULL`. However, before calling `dot` or `transpose_dot` functions, the parameters must be set.

Public Member Functions inherited from cLinearOperatorBase
	cLinearOperatorBase ()
	Default constructor.

	cLinearOperatorBase (const LongIndexType num_rows_, const LongIndexType num_columns_)
	Constructor with setting `num_rows` and `num_columns`.

virtual	~cLinearOperatorBase ()
	Destructor.

LongIndexType	get_num_rows () const
	Returns the number of rows of the matrix.

LongIndexType	get_num_columns () const
	Returns the number of columns of the matrix.

IndexType	get_num_parameters () const
	Returns the number of parameters of the linear operator.

FlagType	is_eigenvalue_relation_known () const
	Returns a flag that determines whether a relation between the parameters of the operator and its eigenvalue(s) is known.

Protected Member Functions
virtual void	copy_host_to_device ()
	Copies the member data from the host memory to the device memory.

Protected Member Functions inherited from cuLinearOperator< DataType >
int	query_gpu_devices () const
	Before any numerical computation, this method chechs if any gpu device is available on the machine, or notifies the user if nothing was found.

void	initialize_cublas_handle ()
	Creates a `cublasHandle_t` object, if not created already.

void	initialize_cusparse_handle ()
	Creates a `cusparseHandle_t` object, if not created already.

Protected Attributes
DataType **	device_A

const DataType *	A

const FlagType	A_is_row_major

Protected Attributes inherited from cuMatrix< DataType >
FlagType	A_is_symmetric

Protected Attributes inherited from cuLinearOperator< DataType >
int	num_gpu_devices

bool	copied_host_to_device

cublasHandle_t *	cublas_handle

cusparseHandle_t *	cusparse_handle

DataType *	parameters

Protected Attributes inherited from cLinearOperatorBase
const LongIndexType	num_rows

const LongIndexType	num_columns

FlagType	eigenvalue_relation_known

IndexType	num_parameters

Detailed Description

template<typename DataType>
class cuDenseMatrix< DataType >

Container for dense matrices.

The cuDenseMatrix holds a two-dimensional dense matrix, and can perofrom matrix-vector product and transposed matrix-vector product.

See also: cuMatrix, cuCSRMatrix, cuCSCMatrix, cuDenseAffineMatrixFunction, cDenseMatrix

Definition at line 43 of file cu_dense_matrix.h.

Constructor & Destructor Documentation

◆ cuDenseMatrix() [1/2]

template<typename DataType >

cuDenseMatrix< DataType >::cuDenseMatrix ( )

Default constructor.

Definition at line 40 of file cu_dense_matrix.cu.

                                      :
 
    // Initializer list
    A(NULL),
    device_A(NULL),
    A_is_row_major(0)
{
}

◆ cuDenseMatrix() [2/2]

template<typename DataType >

cuDenseMatrix< DataType >::cuDenseMatrix	(	const DataType *	A_,
		const LongIndexType	num_rows_,
		const LongIndexType	num_columns_,
		const FlagType	A_is_row_major_,
		const FlagType	A_is_symmetric_,
		const int	num_gpu_devices_
	)

Constructor.

Parameters

[in]	A_	1D array that represents a 2D dense array with either C (row) major ordering or Fortran (column) major ordering. The major ordering should de defined by `A_is_row_major` flag.
[in]	num_rows_	Number of rows of `A`
[in]	num_columns_	Number of columns of `A`
[in]	A_is_row_major_	Boolean, can be `0` or `1` as follows: If `A` is row major (C ordering where the last index is contiguous) this value should be `1`. If `A` is column major (Fortran ordering where the first index is contiguous), this value should be set to `0`.
[in]	A_is_symmetric_	Boolean. If `A` is symmetric, set this value to `1`, otherwise `0`.
[in]	num_gpu_devices_	Number of GPU devices to be utilized for parallelization.

Definition at line 77 of file cu_dense_matrix.cu.

                                   :
 
    // Base class constructor
    cLinearOperatorBase(num_rows_, num_columns_),
    cuLinearOperator<DataType>(num_gpu_devices_),
    cuMatrix<DataType>(A_is_row_major_),
 
    // Initializer list
    A(A_),
    device_A(NULL),
    A_is_row_major(A_is_row_major_)
{
    this->initialize_cublas_handle();
    this->copy_host_to_device();
}

References cuDenseMatrix< DataType >::copy_host_to_device(), and cuLinearOperator< DataType >::initialize_cublas_handle().

Here is the call graph for this function:

◆ ~cuDenseMatrix()

template<typename DataType >

cuDenseMatrix< DataType >::~cuDenseMatrix ( )

virtual

Destructor. This function removes data from GPU devices.

Definition at line 108 of file cu_dense_matrix.cu.

{
    // Member objects exist if the second constructor was called.
    if (this->copied_host_to_device)
    {
        // Deallocate arrays of data on gpu
        for (int device_id = 0; device_id < this->num_gpu_devices; ++device_id)
        {
            // Switch to a device
            CudaAPI<DataType>::set_device(device_id);
 
            // Deallocate
            CudaAPI<DataType>::del(this->device_A[device_id]);
        }
 
        delete[] this->device_A;
        this->device_A = NULL;
    }
}

References CudaAPI< ArrayType >::del(), and CudaAPI< ArrayType >::set_device().

Here is the call graph for this function:

Member Function Documentation

◆ copy_host_to_device()

template<typename DataType >

void cuDenseMatrix< DataType >::copy_host_to_device ( )

protectedvirtual

Copies the member data from the host memory to the device memory.

Implements cuMatrix< DataType >.

Definition at line 137 of file cu_dense_matrix.cu.

{
    if (!this->copied_host_to_device)
    {
        // Set the number of threads
        #if defined(USE_OPENMP) && (USE_OPENMP == 1)
            omp_set_num_threads(this->num_gpu_devices);
        #endif
 
        // Create array of pointers for data on each gpu device
        this->device_A = new DataType*[this->num_gpu_devices];
 
        // Size of data
        size_t A_size = static_cast<size_t>(this->num_rows) * \
                        static_cast<size_t>(this->num_columns);
 
        #if defined(USE_OPENMP) && (USE_OPENMP == 1)
        #pragma omp parallel
        #endif
        {
            // Switch to a device with the same device id as the cpu thread id
            unsigned int thread_id;
            #if defined(USE_OPENMP) && (USE_OPENMP == 1)
                thread_id = omp_get_thread_num();
            #else
                thread_id = 0;
            #endif
 
            CudaAPI<DataType>::set_device(thread_id);
 
            // Allocate device memory and copy data from host
            CudaAPI<DataType>::alloc(this->device_A[thread_id], A_size);
            CudaAPI<DataType>::copy_to_device(this->A, A_size,
                                                    this->device_A[thread_id]);
        }
 
        // Flag to prevent reinitialization
        this->copied_host_to_device = true;
    }
}

References CudaAPI< ArrayType >::alloc(), CudaAPI< ArrayType >::copy_to_device(), omp_get_thread_num(), omp_set_num_threads(), and CudaAPI< ArrayType >::set_device().

Referenced by cuDenseMatrix< DataType >::cuDenseMatrix().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dot()

template<typename DataType >

void cuDenseMatrix< DataType >::dot	(	const DataType *	device_vector,
		DataType *	device_product
	)

virtual

Matrix vector product.

Performs the matrix vector product \( \boldsymbol{y} = \mathbf{A} \boldsymbol{x} \).

Parameters

[in]	device_vector	A one-dimensional input vector \( \boldsymbol{x} \) with size the of the number of columns of the matrix \( \mathbf{A} \). This array should be on the GPU device.
[out]	device_product	A one-dimensional output vector \( \boldsymbol{y} \) with the size of the number of rows of \( \mathbf{A} \). This vector will be overwritten. This array should be on the GPU device.

See also: cuDenseMatrix::dot_plus, cuDenseMatrix::transposed_dot cuDenseMatrix::transposed_dot_plus

Implements cuLinearOperator< DataType >.

Definition at line 333 of file cu_dense_matrix.cu.

{
    assert(this->copied_host_to_device);
 
    // Get device id
    int device_id = CudaAPI<DataType>::get_device();
 
    cuMatrixOperations<DataType>::dense_matvec(
            this->cublas_handle[device_id],
            this->device_A[device_id],
            device_vector,
            this->num_rows,
            this->num_columns,
            this->A_is_row_major,
            device_product);
}

References cuMatrixOperations< DataType >::dense_matvec(), and CudaAPI< ArrayType >::get_device().

Here is the call graph for this function:

◆ dot_plus()

template<typename DataType >

void cuDenseMatrix< DataType >::dot_plus	(	const DataType *	device_vector,
		const DataType	alpha,
		DataType *	device_product
	)

virtual

Matrix vector product written in place.

Performs the matrix vector product \( \boldsymbol{y} = \boldsymbol{y} + \alpha \mathbf{A} \boldsymbol{x} \).

Parameters

[in]	device_vector	A one-dimensional input vector \( \boldsymbol{x} \) with size the of the number of columns of the matrix \( \mathbf{A} \). This array should be on GPU device.
[in]	alpha	A scalar.
[out]	device_product	A one-dimensional output vector \( \boldsymbol{y} \) with the size of the number of rows of \( \mathbf{A} \). This array should be on GPU device.

See also: cuDenseMatrix::dot, cuDenseMatrix::transposed_dot cuDenseMatrix::transposed_dot_plus

Implements cuMatrix< DataType >.

Definition at line 378 of file cu_dense_matrix.cu.

{
    assert(this->copied_host_to_device);
 
    // Get device id
    int device_id = CudaAPI<DataType>::get_device();
 
    cuMatrixOperations<DataType>::dense_matvec_plus(
            this->cublas_handle[device_id],
            this->device_A[device_id],
            device_vector,
            alpha,
            this->num_rows,
            this->num_columns,
            this->A_is_row_major,
            device_product);
}

References cuMatrixOperations< DataType >::dense_matvec_plus(), and CudaAPI< ArrayType >::get_device().

Here is the call graph for this function:

◆ is_identity_matrix()

template<typename DataType >

FlagType cuDenseMatrix< DataType >::is_identity_matrix ( ) const

virtual

Checks whether the matrix is identity.

The identity check is primarily performed in the cAffineMatrixFunction class.

Returns: Returns 1 if the input matrix is identity, and 0 otherwise.

See also: cAffineMatrixFunction

Implements cuMatrix< DataType >.

Definition at line 193 of file cu_dense_matrix.cu.

{
    FlagType matrix_is_identity = 1;
    DataType matrix_element;
    const DataType diagonal = 1.0;
    const DataType off_diagonal = 0.0;
 
    // Check matrix element-wise
    if (this->A_is_row_major)
    {
        // Row-major matrix
        LongIndexType column;
        LongIndexType num_checking_columns;
 
        #if defined(USE_OPENMP) && (USE_OPENMP == 1)
        #pragma omp parallel for \
            schedule(static) \
            if (!omp_in_parallel()) \
            default(none) \
            shared(matrix_is_identity, diagonal, off_diagonal) \
            private(column, num_checking_columns, matrix_element)
        #endif
        for (LongIndexType row=0; row < this->num_rows; ++row)
        {
            if (matrix_is_identity)
            {
                if (this->A_is_symmetric)
                {
                    // Check only half of the columns up to diagonal element
                    num_checking_columns = row + 1;
                }
                else
                {
                    num_checking_columns = this->num_columns;
                }
 
                for (column=0; column < num_checking_columns; ++column)
                {
                    // Get an element of the matrix
                    matrix_element = this->A[row * this->num_columns + column];
 
                    // Check the value of element with identity matrix
                    if (((row == column) && \
                         (!cu_arithmetics::is_equal(matrix_element,
                                                    diagonal))) || \
                        ((row != column) && \
                         (!cu_arithmetics::is_equal(matrix_element,
                                                    off_diagonal))))
                    {
                        #if defined(USE_OPENMP) && (USE_OPENMP == 1)
                        #pragma omp atomic write
                        #endif
                        matrix_is_identity = 0;
 
                        break;
                    }
                }
            }
        }
    }
    else
    {
        // Column-major matrix
        LongIndexType row;
        LongIndexType num_checking_rows;
 
        #if defined(USE_OPENMP) && (USE_OPENMP == 1)
        #pragma omp parallel for \
            schedule(static) \
            if (!omp_in_parallel()) \
            default(none) \
            shared(matrix_is_identity, diagonal, off_diagonal) \
            private(row, num_checking_rows, matrix_element)
        #endif
        for (LongIndexType column=0; column < this-> num_columns; ++column)
        {
            if (matrix_is_identity)
            {
                if (this->A_is_symmetric)
                {
                    // Check only half of the rows up to diagonal element
                    num_checking_rows = column + 1;
                }
                else
                {
                    num_checking_rows = this->num_rows;
                }
 
                for (row=0; row < num_checking_rows; ++row)
                {
                    // Get an element of the matrix
                    matrix_element = this->A[column * this->num_rows + row];
 
                    // Check the value of element with identity matrix
                    if (((row == column) && \
                         (!cu_arithmetics::is_equal(matrix_element,
                                                    diagonal))) || \
                        ((row != column) && \
                         (!cu_arithmetics::is_equal(matrix_element,
                                                    off_diagonal))))
                    {
                        #if defined(USE_OPENMP) && (USE_OPENMP == 1)
                        #pragma omp atomic write
                        #endif
                        matrix_is_identity = 0;
 
                        break;
                    }
                }
            }
        }
    }
 
    return matrix_is_identity;
}

References cu_arithmetics::is_equal().

Here is the call graph for this function:

◆ transpose_dot()

template<typename DataType >

void cuDenseMatrix< DataType >::transpose_dot	(	const DataType *	device_vector,
		DataType *	device_product
	)

virtual

Transposed-matrix vector product.

Performs the matrix vector product \( \boldsymbol{y} = \mathbf{A}^{\intercal} \boldsymbol{x} \).

Parameters

[in]	device_vector	A one-dimensional input vector \( \boldsymbol{x} \) with size the of the number of columns of the matrix \( \mathbf{A} \). This array should be in GPU device.
[out]	device_product	A one-dimensional output vector \( \boldsymbol{y} \) with the size of the number of rows of \( \mathbf{A} \). This vector will be overwritten. This array should be on GPU device.

See also: cuDenseMatrix::dot_plus, cuDenseMatrix::dot cuDenseMatrix::transposed_dot_plus

Implements cuLinearOperator< DataType >.

Definition at line 423 of file cu_dense_matrix.cu.

{
    assert(this->copied_host_to_device);
 
    // Get device id
    int device_id = CudaAPI<DataType>::get_device();
 
    cuMatrixOperations<DataType>::dense_transposed_matvec(
            this->cublas_handle[device_id],
            this->device_A[device_id],
            device_vector,
            this->num_rows,
            this->num_columns,
            this->A_is_row_major,
            device_product);
}

References cuMatrixOperations< DataType >::dense_transposed_matvec(), and CudaAPI< ArrayType >::get_device().

Here is the call graph for this function:

◆ transpose_dot_plus()

template<typename DataType >

void cuDenseMatrix< DataType >::transpose_dot_plus	(	const DataType *	device_vector,
		const DataType	alpha,
		DataType *	device_product
	)

virtual

Transposed-matrix vector product written in place.

Performs the matrix vector product \( \boldsymbol{y} = \boldsymbol{y} + \alpha \mathbf{A}^{\intercal} \boldsymbol{x} \).

Parameters

[in]	device_vector	A one-dimensional input vector \( \boldsymbol{x} \) with size the of the number of columns of the matrix \( \mathbf{A} \). This array should be on GPU device.
[in]	alpha	A scalar.
[out]	device_product	A one-dimensional output vector \( \boldsymbol{y} \) with the size of the number of rows of \( \mathbf{A} \). This array should be on GPU device.

See also: cuDenseMatrix::dot_plus, cuDenseMatrix::transposed_dot cuDenseMatrix::dot

Implements cuMatrix< DataType >.

Definition at line 469 of file cu_dense_matrix.cu.

{
    assert(this->copied_host_to_device);
 
    // Get device id
    int device_id = CudaAPI<DataType>::get_device();
 
    cuMatrixOperations<DataType>::dense_transposed_matvec_plus(
            this->cublas_handle[device_id],
            this->device_A[device_id],
            device_vector,
            alpha,
            this->num_rows,
            this->num_columns,
            this->A_is_row_major,
            device_product);
}

References cuMatrixOperations< DataType >::dense_transposed_matvec_plus(), and CudaAPI< ArrayType >::get_device().

Here is the call graph for this function:

Member Data Documentation

◆ A

template<typename DataType >

const DataType* cuDenseMatrix< DataType >::A

protected

Definition at line 87 of file cu_dense_matrix.h.

◆ A_is_row_major

template<typename DataType >

const FlagType cuDenseMatrix< DataType >::A_is_row_major

protected

Definition at line 88 of file cu_dense_matrix.h.

◆ device_A

template<typename DataType >

DataType** cuDenseMatrix< DataType >::device_A

protected

Definition at line 86 of file cu_dense_matrix.h.

The documentation for this class was generated from the following files:

/home/runner/work/imate/imate/imate/_cu_linear_operator/cu_dense_matrix.h
/home/runner/work/imate/imate/imate/_cu_linear_operator/cu_dense_matrix.cu

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ cuDenseMatrix() [1/2]

◆ cuDenseMatrix() [2/2]

◆ ~cuDenseMatrix()

Member Function Documentation

◆ copy_host_to_device()

◆ dot()

◆ dot_plus()

◆ is_identity_matrix()

◆ transpose_dot()

◆ transpose_dot_plus()

Member Data Documentation

◆ A

◆ A_is_row_major

◆ device_A