cuLinearOperator< DataType > Class Template Reference

Base class for linear operators. This class serves as interface for all derived classes. More...

#include <cu_linear_operator.h>

Inheritance diagram for cuLinearOperator< DataType >:

Collaboration diagram for cuLinearOperator< DataType >:

Public Member Functions
	cuLinearOperator ()
	cuLinearOperator (int num_gpu_devices_)
	Constructor with setting num_rows and num_columns. More...
virtual	~cuLinearOperator ()
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. More...
Public Member Functions inherited from cLinearOperator< DataType >
	cLinearOperator ()
	Default constructor. More...
	cLinearOperator (const LongIndexType num_rows_, const LongIndexType num_columns_)
	Constructor with setting num_rows and num_columns. More...
virtual	~cLinearOperator ()
LongIndexType	get_num_rows () const
LongIndexType	get_num_columns () const
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. More...
IndexType	get_num_parameters () const
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. More...
virtual DataType	get_eigenvalue (const DataType *known_parameters, const DataType known_eigenvalue, const DataType *inquiry_parameters) const =0
virtual void	dot (const DataType *vector, DataType *product)=0
virtual void	transpose_dot (const DataType *vector, DataType *product)=0

Protected Member Functions
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. More...
void	initialize_cublas_handle ()
	Creates a cublasHandle_t object, if not created already. More...
void	initialize_cusparse_handle ()
	Creates a cusparseHandle_t object, if not created already. More...

Protected Attributes
int	num_gpu_devices
bool	copied_host_to_device
cublasHandle_t *	cublas_handle
cusparseHandle_t *	cusparse_handle
Protected Attributes inherited from cLinearOperator< DataType >
const LongIndexType	num_rows
const LongIndexType	num_columns
FlagType	eigenvalue_relation_known
DataType *	parameters
IndexType	num_parameters

Detailed Description

template<typename DataType>
class cuLinearOperator< DataType >

Base class for linear operators. This class serves as interface for all derived classes.

The prefix c in this class's name (and its derivatves), stands for the cpp code, intrast to the cu prefix, which stands for the cuda code. Most derived classes have a cuda counterpart.

See also

cuMatrix, cuAffineMatrixFunction, cLinearOperator

Definition at line 43 of file cu_linear_operator.h.

Constructor & Destructor Documentation

cuLinearOperator() [1/2]

template<typename DataType >

cuLinearOperator< DataType >::cuLinearOperator

Definition at line 30 of file cu_linear_operator.cu.

                                            :
 
    // Initializer list
    num_gpu_devices(0),
    copied_host_to_device(false),
    cublas_handle(NULL),
    cusparse_handle(NULL)
{
    // Check any gpu device exists
    this->num_gpu_devices = this->query_gpu_devices();
 
    // Regardless of using dense (cublas) or sparse (cusparse) matrices, the
    // cublas handle should be initialized, since it is needed for the methods
    // in cuVectorOperations
    this->initialize_cublas_handle();
}

References cuLinearOperator< DataType >::initialize_cublas_handle(), cuLinearOperator< DataType >::num_gpu_devices, and cuLinearOperator< DataType >::query_gpu_devices().

Here is the call graph for this function:

cuLinearOperator() [2/2]

template<typename DataType >

cuLinearOperator< DataType >::cuLinearOperator ( int  num_gpu_devices_ )

explicit

Constructor with setting num_rows and num_columns.

Note

For the classed that are virtually derived (virtual inheritance) from this class, this constructor will never be called. Rather, the default constructor is called by the most derived class. Thus, set the member data directly instead of below.

Definition at line 60 of file cu_linear_operator.cu.

                                         :
 
    // Initializer list
    num_gpu_devices(0),
    copied_host_to_device(false),
    cublas_handle(NULL),
    cusparse_handle(NULL)
{
    // Check any gpu device exists
    int device_count = this->query_gpu_devices();
 
    // Set number of gpu devices
    if (num_gpu_devices_ == 0)
    {
        this->num_gpu_devices = device_count;
    }
    else if (num_gpu_devices_ > device_count)
    {
        std::cerr << "ERROR: Number of requested gpu devices exceeds the " \
                  << "number of available gpu devices. Nummber of detected " \
                  << "devices are " << device_count << " while the " \
                  << "requested number of devices are " << num_gpu_devices_ \
                  << "." << std::endl;
        abort();
    }
    else
    {
        this->num_gpu_devices = num_gpu_devices_;
    }
 
    // Regardless of using dense (cublas) or sparse (cusparse) matrices, the
    // cublas handle should be initialized, since it is needed for the methods
    // in cuVectorOperations
    this->initialize_cublas_handle();
}

References cuLinearOperator< DataType >::initialize_cublas_handle(), cuLinearOperator< DataType >::num_gpu_devices, and cuLinearOperator< DataType >::query_gpu_devices().

Here is the call graph for this function:

~cuLinearOperator()

template<typename DataType >

cuLinearOperator< DataType >::~cuLinearOperator

virtual

Definition at line 103 of file cu_linear_operator.cu.

{
    // cublas handle
    if (this->cublas_handle != NULL)
    {
        // Set the number of threads
        omp_set_num_threads(this->num_gpu_devices);
 
        #pragma omp parallel
        {
            // Switch to a device with the same device id as the cpu thread id
            unsigned int thread_id = omp_get_thread_num();
            CudaInterface<DataType>::set_device(thread_id);
 
            cublasStatus_t status = cublasDestroy(
                    this->cublas_handle[thread_id]);
            assert(status == CUBLAS_STATUS_SUCCESS);
        }
 
        // Deallocate arrays of pointers on cpu
        delete[] this->cublas_handle;
        this->cublas_handle = NULL;
    }
 
    // cusparse handle
    if (this->cusparse_handle != NULL)
    {
        // Set the number of threads
        omp_set_num_threads(this->num_gpu_devices);
 
        #pragma omp parallel
        {
            // Switch to a device with the same device id as the cpu thread id
            unsigned int thread_id = omp_get_thread_num();
            CudaInterface<DataType>::set_device(thread_id);
 
            cusparseStatus_t status = cusparseDestroy(
                    this->cusparse_handle[thread_id]);
            assert(status == CUSPARSE_STATUS_SUCCESS);
        }
 
        // Deallocate arrays of pointers on cpu
        delete[] this->cusparse_handle;
        this->cusparse_handle = NULL;
    }
}

References cusparseDestroy(), and CudaInterface< ArrayType >::set_device().

Here is the call graph for this function:

Member Function Documentation

get_cublas_handle()

template<typename DataType >

cublasHandle_t cuLinearOperator< DataType >::get_cublas_handle

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

The cublasHandle is needed for the client code (slq method) for vector operations on GPU. However, in this class, the cublasHandle_t might not be needed by it self if the derived class is a sparse matrix, becase the sparse matrix needs only cusparseHandle_t. In case if the cublasHandle_t is not created, it will be created for the purpose of the client codes.

Returns

A void pointer to the cublasHandle_t instance.

Definition at line 168 of file cu_linear_operator.cu.

{
    // Get device id
    int device_id = CudaInterface<DataType>::get_device();
 
    return this->cublas_handle[device_id];
}

References CudaInterface< ArrayType >::get_device().

Referenced by cu_golub_kahn_bidiagonalization(), and cu_lanczos_tridiagonalization().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_cublas_handle()

template<typename DataType >

void cuLinearOperator< DataType >::initialize_cublas_handle

protected

Creates a cublasHandle_t object, if not created already.

Definition at line 185 of file cu_linear_operator.cu.

{
    if (this->cublas_handle == NULL)
    {
        // Allocate pointers for each gpu device
        this->cublas_handle = new cublasHandle_t[this->num_gpu_devices];
 
        // Set the number of threads
        omp_set_num_threads(this->num_gpu_devices);
 
        #pragma omp parallel
        {
            // Switch to a device with the same device id as the cpu thread id
            unsigned int thread_id = omp_get_thread_num();
            CudaInterface<DataType>::set_device(thread_id);
 
            cublasStatus_t status = cublasCreate(
                    &this->cublas_handle[thread_id]);
            assert(status == CUBLAS_STATUS_SUCCESS);
        }
    }
}

References CudaInterface< ArrayType >::set_device().

Referenced by cuDenseAffineMatrixFunction< DataType >::cuDenseAffineMatrixFunction(), cuDenseMatrix< DataType >::cuDenseMatrix(), and cuLinearOperator< DataType >::cuLinearOperator().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_cusparse_handle()

template<typename DataType >

void cuLinearOperator< DataType >::initialize_cusparse_handle

protected

Creates a cusparseHandle_t object, if not created already.

Definition at line 217 of file cu_linear_operator.cu.

{
    if (this->cusparse_handle == NULL)
    {
        // Allocate pointers for each gpu device
        this->cusparse_handle = new cusparseHandle_t[this->num_gpu_devices];
 
        // Set the number of threads
        omp_set_num_threads(this->num_gpu_devices);
 
        #pragma omp parallel
        {
            // Switch to a device with the same device id as the cpu thread id
            unsigned int thread_id = omp_get_thread_num();
            CudaInterface<DataType>::set_device(thread_id);
 
            cusparseStatus_t status = cusparseCreate(
                    &this->cusparse_handle[thread_id]);
            assert(status == CUSPARSE_STATUS_SUCCESS);
        }
    }
}

References cusparseCreate(), and CudaInterface< ArrayType >::set_device().

Referenced by cuCSCAffineMatrixFunction< DataType >::cuCSCAffineMatrixFunction(), cuCSCMatrix< DataType >::cuCSCMatrix(), cuCSRAffineMatrixFunction< DataType >::cuCSRAffineMatrixFunction(), and cuCSRMatrix< DataType >::cuCSRMatrix().

Here is the call graph for this function:

Here is the caller graph for this function:

query_gpu_devices()

template<typename DataType >

int cuLinearOperator< DataType >::query_gpu_devices

protected

Before any numerical computation, this method chechs if any gpu device is available on the machine, or notifies the user if nothing was found.

Returns

Number of gpu available devices.

Definition at line 252 of file cu_linear_operator.cu.

{
    int device_count = 0;
    cudaError_t error = cudaGetDeviceCount(&device_count);
 
    // Error code 38 means no cuda-capable device was detected.
    if ((error != cudaSuccess) || (device_count < 1))
    {
        std::cerr << "ERROR: No cuda-capable GPU device was detected on " \
                  << "this machine. If a cuda-capable GPU device exists, " \
                  << "install its cuda driver. Alternatively, set " \
                  << "'gpu=False' to use cpu instead." \
                  << std::endl;
 
        abort();
    }
 
    return device_count;
}

References cudaGetDeviceCount().

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

copied_host_to_device

template<typename DataType >

bool cuLinearOperator< DataType >::copied_host_to_device

protected

Definition at line 64 of file cu_linear_operator.h.

cublas_handle

template<typename DataType >

cublasHandle_t* cuLinearOperator< DataType >::cublas_handle

protected

Definition at line 65 of file cu_linear_operator.h.

cusparse_handle

template<typename DataType >

cusparseHandle_t* cuLinearOperator< DataType >::cusparse_handle

protected

Definition at line 66 of file cu_linear_operator.h.

num_gpu_devices

template<typename DataType >

int cuLinearOperator< DataType >::num_gpu_devices

protected

Definition at line 63 of file cu_linear_operator.h.

Referenced by cuCSCMatrix< DataType >::cuCSCMatrix(), cuCSRMatrix< DataType >::cuCSRMatrix(), and cuLinearOperator< DataType >::cuLinearOperator().

---

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

• /home/runner/work/imate/imate/imate/_cu_linear_operator/cu_linear_operator.h
• /home/runner/work/imate/imate/imate/_cu_linear_operator/cu_linear_operator.cu