nlesc-jcer / eigencuda Goto Github PK

When invoking the right_matrix_tensor and triple_tensor_product the tensor is sent completely to GPU. But if the whole Tensor does not find in memory, the application obviously crashed with an out of memory

Implement Tensor-Matrix multplication using:

• gemmbatched
• gemmstridedbatched

There is an issue when invoking the method triple_tensor_product on rectangular matrices

Register the host memory to improve bandwidth utilization

Currently, all IO and Kernel operations happen in a single stream. The performance would be significantly increase if we interleave multiple streams.

The Cublas gemm subroutine only needs the pointers to the arrays. Then passing the arrays stored in the main memory is unnecessary, instead pass the shapes of the arrays.

See unified memory

the dot and the triplet_tensor_product must release all the GPU resources once the computation is done

Currently, when copying back the matrix From the GPU to the main memory the stream is not synchronized and it could generate invalid results

Replace the call to cuBLAS by cuTensor

The following actions are required:

• the scalar constants to call ?gemm shouldn't be class members
• the ids for the allocated pointers should be int instead of unsigned
• fun_alloc and fun_free should be renamed gpu_alloc and gpu_free respectively

Given a 3D tensor represented as a vector of matrices, create an operation that performs the following multiplication in a GPU

std::vector<MatrixXd> rs;
MatrixXd mtx;
for (matrixXd &x: tensor) {
   rs.push_back( x * mtx);
}

Should use self-hosted runner with GPU.

When iterating the 3-D tensor in the call to triple_tensor_product the matrix elements of the tensor are never copy to the device producing always a matrix of zeros

Use the cuda-api-wrappers to improve the communication with cuda.

• Data transfer
• Overlap data transfer

The following methods should take const to reference:

• initialize_matrix (private)
• dot (public)
• triple_tensor_product (public)

Due to the transfer overhead it would be better to transfer to the GPU the two matrices at the same time instead of separately.