NVIDIA cuSOLVERMp

https://docs.nvidia.com/cuda/cusolvermp/
Admin
NVIDIA cuSOLVERMp is a high-performance, distributed-memory, GPU-accelerated library for solving...
Tokens:50,649
Snippets:296
Trust Score:10
Update:5 months ago
Show doc for...
Tokens:
Raw
### Initialize MPI and get rank information

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/initialization/nccl.html

This code initializes MPI and retrieves the size and rank of the current process within the MPI world. Ensure MPI is set up before proceeding.

```c
MPI_Init(nullptr, nullptr);

int rank, nranks;
MPI_Comm_size(MPI_COMM_WORLD, &nranks);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
```

--------------------------------

### NCCL Initialization

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/initialization/cal_to_nccl.html

Initializes an NCCL communicator. This involves getting a unique ID, broadcasting it, and then initializing the communicator for each rank.

```c
ncclUniqueId id;

if (rank == 0)
{
 NCCL_CHECK(ncclGetUniqueId(&id));
}

MPI_CHECK(MPI_Bcast(&id, sizeof(id), MPI_BYTE, 0, MPI_COMM_WORLD));

ncclComm_t nccl_comm;
NCCL_CHECK(ncclCommInitRank(&nccl_comm, nranks, id, rank));
```

--------------------------------

### Set up local CUDA device and initialize context

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/initialization/nccl.html

This code configures the local CUDA device and initializes the CUDA context. It uses a helper function `getLocalDevice()` which is assumed to be defined elsewhere.

```c
const int local_device = getLocalDevice();
CUDA_CHECK(cudaSetDevice(local_device));
CUDA_CHECK(cudaFree(nullptr)); // Initialize CUDA context
```

--------------------------------

### CAL cusolverMpCreateDeviceGrid Call

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/initialization/cal_to_nccl.html

Example of calling cusolverMpCreateDeviceGrid with a CAL communicator.

```c
CUSOLVER_CHECK(cusolverMpCreateDeviceGrid(handle, &grid, cal_comm, nprow, npcol, CUSOLVERMP_GRID_MAPPING_COL_MAJOR));
```

--------------------------------

### NCCL cusolverMpCreateDeviceGrid Call

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/initialization/cal_to_nccl.html

Example of calling cusolverMpCreateDeviceGrid with an NCCL communicator. This replaces the CAL communicator in the call.

```c
CUSOLVER_CHECK(cusolverMpCreateDeviceGrid(handle, &grid, nccl_comm, nprow, npcol, CUSOLVERMP_GRID_MAPPING_COL_MAJOR));
```

--------------------------------

### cusolverMpCreateDeviceGrid

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Initializes the grid opaque data structure, mapping the given resources (communicator, grid dimensions and grid layout) to a grid object. All processes defined to be in this grid must enter this function.

```APIDOC
## cusolverMpCreateDeviceGrid

### Description
Initializes the [grid](https://docs.nvidia.com/cuda/cusolvermp/usage/types.html.md#cusolvermpgrid-t-label) opaque data structure. It maps the given resources (communicator, grid dimensions and grid layout) to a grid object.

All the processes defined to be in this grid must enter this function.

### Signature
cusolverStatus_t cusolverMpCreateDeviceGrid(cusolverMpHandle_t handle, cusolverMpGrid_t *grid, ncclComm_t comm, int32_t numRowDevices, int32_t numColDevices, cusolverMpGridMapping_t mapping)

### Parameters
#### In
- **handle** (cusolverMpHandle_t) - cuSOLVERMp library handle.
- **comm** (ncclComm_t) - Communicator that will be associated with the grid.
- **numRowDevices** (int32_t) - How many process rows the grid will contain.
- **numColDevices** (int32_t) - How many process columns the grid will contain.
- **mapping** (cusolverMpGridMapping_t) - How to map processes to the grid. Currently, only `CUSOLVERMP_GRID_MAPPING_COL_MAJOR` is supported.
#### Out
- **grid** (cusolverMpGrid_t *) - Grid object to be initialized.
```

--------------------------------

### NCCL Synchronization

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/initialization/cal_to_nccl.html

Shows how to synchronize with NCCL, which relies on standard CUDA stream synchronization.

```c
CUDA_CHECK(cudaStreamSynchronize(stream));
```

--------------------------------

### cusolverMpGetEmulationStrategy

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Retrieves the current emulation strategy from the cuSOLVERMp library handle.

```APIDOC
## cusolverMpGetEmulationStrategy

### Description
Retrieves the current emulation strategy from the cuSOLVERMp library handle.

### Signature
cusolverStatus_t cusolverMpGetEmulationStrategy(cusolverMpHandle_t handle, cudaEmulationStrategy_t *strategy)

### Parameters
#### In
- **handle** (cusolverMpHandle_t) - cuSOLVERMp library handle.
#### Out
- **strategy** (cudaEmulationStrategy_t *) - Current emulation strategy of the handle.
```

--------------------------------

### cusolverMpLoggerOpenFile

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Opens a logging output file at the specified path for cuSOLVERMP. This is an experimental feature.

```APIDOC
## cusolverMpLoggerOpenFile

### Description
Opens a logging output file in the given path.

### Signature
cusolverStatus_t cusolverMpLoggerOpenFile(const char* logFile)

### Parameters
#### Path Parameters
- **logFile** (const char*) - In - Path of the logging output file.

### Warning
This is an experimental feature.
```

--------------------------------

### Create cuSOLVERMp process grid

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/initialization/nccl.html

This code creates a cuSOLVERMp process grid, which is used to organize ranks for distributed computations. It requires the cuSOLVERMp handle, an NCCL communicator, and grid dimensions (nprow, npcol).

```c
cusolverMpGrid_t grid = nullptr;

CUSOLVER_CHECK(cusolverMpCreateDeviceGrid(handle, &grid, comm, nprow, npcol, CUSOLVERMP_GRID_MAPPING_COL_MAJOR));
```

--------------------------------

### CAL Initialization with MPI

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/initialization/cal_to_nccl.html

Initializes a CAL communicator using MPI. This is used when CAL is compiled with MPI support.

```c
#ifdef USE_CAL_MPI
 CAL_CHECK(cal_comm_create_mpi(MPI_COMM_WORLD, rank, nranks, local_device, &cal_comm));
#else
```

--------------------------------

### Create Communicator Handle with MPI

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/initialization/cal.html

This function demonstrates how to create a cuSOLVERMP communicator handle using an existing MPI communicator. It requires MPI initialization and provides helper functions for communication operations.

```c
#include "cal.h"
#include "cusolverMp.h"
#include "mpi.h"

calError_t allgather(void* src_buf, void* recv_buf, size_t size, void* data, void** request)
{
 MPI_Request req;
 int err = MPI_Iallgather(src_buf, size, MPI_BYTE, recv_buf, size, MPI_BYTE, (MPI_Comm)data, &req);
 if (err != MPI_SUCCESS)
 {
 return CAL_ERROR;
 }
 *request = (void*)req;
 return CAL_OK;
}

calError_t request_test(void* request)
{
 MPI_Request req = (MPI_Request)request;
 int completed;
 int err = MPI_Test(&req, &completed, MPI_STATUS_IGNORE);
 if (err != MPI_SUCCESS)
 {
 return CAL_ERROR;
 }
 return completed ? CAL_OK : CAL_ERROR_INPROGRESS;
}

calError_t request_free(void* request)
{
 return CAL_OK;
}

calError_t cal_comm_create_mpi(MPI_Comm mpi_comm, int rank, int nranks, int local_device, cal_comm_t* comm)
{
 cal_comm_create_params_t params;
 params.allgather = allgather;
 params.req_test = request_test;
 params.req_free = request_free;
 params.data = (void*)mpi_comm;
 params.rank = rank;
 params.nranks = nranks;
 params.local_device = local_device;
 return cal_comm_create(params, comm);
}

void main()
{
 // Initialize MPI
 MPI_Init(...);
 int rank, size;
 MPI_Comm mpi_comm = MPI_COMM_WORLD;
 MPI_Comm_rank(mpi_comm, &rank);
 MPI_Comm_size(mpi_comm, &size);

 cal_comm_t cal_comm;

 // creating communicator handle with MPI communicator
 cal_comm_create_mpi(mpi_comm, rank, size, &cal_comm);

 // using cuSOLVERMp with cal_comm handle
 cusolverMpCreateDeviceGrid(..., cal_comm, ...);

 // destroying communicator handle
 cal_comm_destroy(cal_comm);

 MPI_Finalize();
}
```

--------------------------------

### cusolverMpSetEmulationStrategy

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Sets the emulation strategy for the cuSOLVERMp library handle. This strategy will be propagated to the internal cuBLAS and cuSOLVER handles.

```APIDOC
## cusolverMpSetEmulationStrategy

### Description
Sets the emulation strategy for the cuSOLVERMp library handle. It will be propagated to the internal cuBLAS and cuSOLVER handles.

### Signature
cusolverStatus_t cusolverMpSetEmulationStrategy(cusolverMpHandle_t handle, cudaEmulationStrategy_t strategy)

### Parameters
#### In
- **handle** (cusolverMpHandle_t) - cuSOLVERMp library handle.
- **strategy** (cudaEmulationStrategy_t) - Emulation strategy to be set for the handle. Available options are `CUDA_EMULATION_STRATEGY_DEFAULT`, `CUDA_EMULATION_STRATEGY_PERFORMANT`, and `CUDA_EMULATION_STRATEGY_EAGER`.

### Notes
The emulation strategy only has an effect if the math mode is set to `CUSOLVER_FP32_EMULATED_BF16X9_MATH`.
```

--------------------------------

### CAL Initialization with Custom Parameters

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/initialization/cal_to_nccl.html

Initializes a CAL communicator with custom parameters, including gather, request test, and request free functions. This is used when CAL is not compiled with MPI support.

```c
cal_comm_create_params_t params;
 params.allgather = allgather;
 params.req_test = request_test;
 params.req_free = request_free;
 params.data = (void*)(MPI_COMM_WORLD);
 params.rank = rank;
 params.nranks = nranks;
 params.local_device = local_device;
 CAL_CHECK(cal_comm_create(params, &cal_comm));
#endif
```

--------------------------------

### cusolverMpGetrs

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Solves a system of linear equations using the LU factorization obtained from `cusolverMpGetrf`.

```APIDOC
## cusolverMpGetrs

### Description
Solves a system of linear equations Ax = B using the LU factorization of A computed by `cusolverMpGetrf`.

### Function Signature
```c
cusolverStatus_t cusolverMpGetrs<T>(
    cusolverMpHandle_t handle,
    cusolverOperation_t trans,
    int n,
    int nrhs,
    const T* A,
    int lda,
    const int* ipiv,
    T* B,
    int ldb,
    int* info
);
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (0)
- `cusolverStatus_t` (int) - Returns `0` on success.
- `B` (T*) - Solution matrix x.
- `info` (int*) - Pointer to an integer. If `info` is non-zero, it contains the row and column of the first non-positive pivot element.

#### Response Example
None
```

--------------------------------

### cusolverMpLoggerSetFile

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Sets the logging output file for cuSOLVERMP. The provided file handle must remain open unless switched to a different file. This is an experimental feature.

```APIDOC
## cusolverMpLoggerSetFile

### Description
Sets the logging output file.

### Signature
cusolverStatus_t cusolverMpLoggerSetFile(FILE *file)

### Parameters
#### Path Parameters
- **file** (FILE *) - In - Pointer to an open file. File should have write permission.

### Warning
This is an experimental feature.
```

--------------------------------

### Create MPI Communicator Handle for CAL

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/cal.html

This function demonstrates how to create a CAL communicator handle using an existing MPI communicator. It sets up the necessary callbacks for communication operations like allgather and request testing.

```c
#include "cal.h"
#include "cusolverMp.h"
#include "mpi.h"

calError_t allgather(void* src_buf, void* recv_buf, size_t size, void* data, void** request)
{
 MPI_Request req;
 int err = MPI_Iallgather(src_buf, size, MPI_BYTE, recv_buf, size, MPI_BYTE, (MPI_Comm)data, &req);
 if (err != MPI_SUCCESS)
 {
 return CAL_ERROR;
 }
 *request = (void*)req;
 return CAL_OK;
}

calError_t request_test(void* request)
{
 MPI_Request req = (MPI_Request)request;
 int completed;
 int err = MPI_Test(&req, &completed, MPI_STATUS_IGNORE);
 if (err != MPI_SUCCESS)
 {
 return CAL_ERROR;
 }
 return completed ? CAL_OK : CAL_ERROR_INPROGRESS;
}

calError_t request_free(void* request)
{
 return CAL_OK;
}

calError_t cal_comm_create_mpi(MPI_Comm mpi_comm, int rank, int nranks, int local_device, cal_comm_t* comm)
{
 cal_comm_create_params_t params;
 params.allgather = allgather;
 params.req_test = request_test;
 params.req_free = request_free;
 params.data = (void*)mpi_comm;
 params.rank = rank;
 params.nranks = nranks;
 params.local_device = local_device;
 return cal_comm_create(params, comm);
}
```

```c
void main()
{
 // Initialize MPI
 MPI_Init(...);
 int rank, size;
 MPI_Comm mpi_comm = MPI_COMM_WORLD;
 MPI_Comm_rank(mpi_comm, &rank);
 MPI_Comm_size(mpi_comm, &size);

 cal_comm_t cal_comm;

 // creating communicator handle with MPI communicator
 cal_comm_create_mpi(mpi_comm, rank, size, &cal_comm);

 // using cuSOLVERMp with cal_comm handle
 cusolverMpCreateDeviceGrid(..., cal_comm, ...);

 // destroying communicator handle
 cal_comm_destroy(cal_comm);

 MPI_Finalize();
}
```

--------------------------------

### cusolverMpSytrd_bufferSize

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Calculates the buffer size required for the `cusolverMpSytrd` function.

```APIDOC
## cusolverMpSytrd_bufferSize

### Description
Calculates the buffer size required for the `cusolverMpSytrd` function, which reduces a real symmetric matrix to tridiagonal form.

### Function Signature
```c
cusolverStatus_t cusolverMpSytrd_bufferSize<T>(
    cusolverMpHandle_t handle,
    cusolverMgpuDesc_t mgpu_desc,
    int n,
    const T* A,
    int lda,
    int* lwork
);
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (0)
- `cusolverStatus_t` (int) - Returns `0` on success.
- `lwork` (int*) - Pointer to an integer where the required buffer size will be stored.

#### Response Example
None
```

--------------------------------

### cusolverMpGetMathMode

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Retrieves the current math mode from the cuSOLVERMp library handle.

```APIDOC
## cusolverMpGetMathMode

### Description
Retrieves the current math mode from the cuSOLVERMp library handle.

### Signature
cusolverStatus_t cusolverMpGetMathMode(cusolverMpHandle_t handle, cusolverMathMode_t *mode)

### Parameters
#### In
- **handle** (cusolverMpHandle_t) - cuSOLVERMp library handle.
#### Out
- **mode** (cusolverMathMode_t *) - Current math mode of the handle.
```

--------------------------------

### Create cuSOLVERMp handle

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/initialization/nccl.html

This code creates a cuSOLVERMp handle, which is required for all subsequent cuSOLVERMp API calls. It requires the local device ID and the CUDA stream.

```c
cusolverMpHandle_t handle = nullptr;
CUSOLVER_CHECK(cusolverMpCreate(&handle, local_device, stream));
```

--------------------------------

### cusolverMpPotrf_bufferSize

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Computes the size in bytes of the host and device working buffers required by cusolverMpPotrf(). This is essential for allocating the correct amount of memory before performing the matrix factorization.

```APIDOC
## cusolverMpPotrf_bufferSize

### Description
Computes the size in bytes of the host and device working buffers required by [cusolverMpPotrf()].

### Signature
```c
cusolverStatus_t cusolverMpPotrf_bufferSize(
 cusolverMpHandle_t handle,
 cublasFillMode_t uplo,
 int64_t N,
 const void *d_A,
 int64_t IA,
 int64_t JA,
 cusolverMpMatrixDescriptor_t descrA,
 cudaDataType_t computeType,
 size_t* workspaceInBytesOnDevice,
 size_t* workspaceInBytesOnHost)
```

### Parameters
#### Host Parameters
- **handle** (cusolverMpHandle_t) - In - cuSOLVERMp library handle.
- **uplo** (cublasFillMode_t) - In - Specifies if A is upper (`CUBLAS_FILL_MODE_UPPER`) or lower triangular matrix (`CUBLAS_FILL_MODE_LOWER`).
- **N** (int64_t) - In - Number of rows and columns of sub(A).
- **IA** (int64_t) - In - Row index of the first row of the sub(A).
- **JA** (int64_t) - In - Column index of the first column of the sub(A).
- **descrA** (cusolverMpMatrixDescriptor_t) - In - Matrix descriptor associated to the global matrix A.
- **computeType** (cudaDataType_t) - In - Data type used for computations.
- **workspaceInBytesOnDevice** (size_t*) - Out - On output, contains the size in bytes of the local device workspace needed by [cusolverMpPotrf()].
- **workspaceInBytesOnHost** (size_t*) - Out - On output, contains the size in bytes of the local host workspace needed by [cusolverMpPotrf()].

#### Device Parameters
- **d_A** (const void*) - In - Pointer into the local memory to an array of dimension `(LLD_A, LOCc(JA+N-1))`. On entry, this array contains the local pieces of the N-by-N distributed matrix sub(A). On output, this array contains the L or U factors of A, depending on the value of `uplo`.

### Supported Compute Types
| Data Type of A | computeType | Output Data Type |
| --- | --- | --- |
| CUDA_R_32F | CUDA_R_32F | CUDA_R_32F |
| CUDA_R_64F | CUDA_R_64F | CUDA_R_64F |
| CUDA_C_32F | CUDA_C_32F | CUDA_C_32F |
| CUDA_C_64F | CUDA_C_64F | CUDA_C_64F |
```

--------------------------------

### cusolverMpPotrs_bufferSize

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Calculates the buffer size required for the `cusolverMpPotrs` function.

```APIDOC
## cusolverMpPotrs_bufferSize

### Description
Calculates the buffer size required for the `cusolverMpPotrs` function, which solves a system of linear equations using Cholesky factorization.

### Function Signature
```c
cusolverStatus_t cusolverMpPotrs_bufferSize<T>(
    cusolverMpHandle_t handle,
    cusolverMgpuDesc_t mgpu_desc,
    int n,
    int nrhs,
    const T* A,
    int lda,
    int* lwork
);
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (0)
- `cusolverStatus_t` (int) - Returns `0` on success.
- `lwork` (int*) - Pointer to an integer where the required buffer size will be stored.

#### Response Example
None
```

--------------------------------

### cusolverMpPotrs

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Solves a system of linear equations using the Cholesky factorization obtained from `cusolverMpPotrf`.

```APIDOC
## cusolverMpPotrs

### Description
Solves a system of linear equations Ax = B using the Cholesky factorization of A computed by `cusolverMpPotrf`.

### Function Signature
```c
cusolverStatus_t cusolverMpPotrs<T>(
    cusolverMpHandle_t handle,
    cusolverFillMode_t uplo,
    int n,
    int nrhs,
    const T* A,
    int lda,
    T* B,
    int ldb,
    int* info
);
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (0)
- `cusolverStatus_t` (int) - Returns `0` on success.
- `B` (T*) - Solution matrix x.
- `info` (int*) - Pointer to an integer. If `info` is non-zero, it contains the row and column of the first non-positive diagonal minor.

#### Response Example
None
```

--------------------------------

### cusolverMpGetrf_bufferSize

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Computes the size in bytes of the host and device working buffers required by cusolverMpGetrf(). The user can set d_ipiv=NULL so cusolverMpGetrf() will compute the LU factorization of the input matrix A without pivoting.

```APIDOC
## cusolverMpGetrf_bufferSize

### Description
Computes the size in bytes of the host and device working buffers required by `cusolverMpGetrf()`.

### Function Signature
```c
cusolverStatus_t cusolverMpGetrf_bufferSize(
 cusolverMpHandle_t handle,
 int64_t M,
 int64_t N,
 void *d_A,
 int64_t IA,
 int64_t JA,
 cusolverMpMatrixDescriptor_t descrA,
 int64_t *d_ipiv,
 cudaDataType_t computeType,
 size_t *workspaceInBytesOnDevice,
 size_t *workspaceInBytesOnHost
)
```

### Parameters
#### Host Parameters
- **handle** (cusolverMpHandle_t) - In - cuSOLVERMp library handle.
- **M** (int64_t) - In - Number of rows of sub(A).
- **N** (int64_t) - In - Number of columns of sub(A).
- **IA** (int64_t) - In - Row index of the first row of the sub(A). This function does not make any assumptions on the alignment of `IA`.
- **JA** (int64_t) - In - Column index of the first column of the sub(A). This function does not make any assumptions on the alignment of `JA`.
- **descrA** (cusolverMpMatrixDescriptor_t) - In - Matrix descriptor associated to the global matrix A.
- **computeType** (cudaDataType_t) - In - Data type used for computations. See table below for supported combinations.
- **workspaceInBytesOnDevice** (size_t *) - Out - On output, contains the size in bytes of the local device workspace needed by `cusolverMpGetrf()`.
- **workspaceInBytesOnHost** (size_t *) - Out - On output, contains the size in bytes of the local host workspace needed by `cusolverMpGetrf()`.

#### Device Parameters
- **d_A** (void *) - In - Pointer to the first entry of the local portion of the global matrix A.
- **d_ipiv** (int64_t *) - In - Indicates a pointer to a distributed integer array. When it is not `null`, workspace for pivoting is accounted.

### Supported Compute Types
| Data Type of A | computeType | Output Data Type |
| --- | --- | --- |
| CUDA_R_32F | CUDA_R_32F | CUDA_R_32F |
| CUDA_R_64F | CUDA_R_64F | CUDA_R_64F |
| CUDA_C_32F | CUDA_C_32F | CUDA_C_32F |
| CUDA_C_64F | CUDA_C_64F | CUDA_C_64F |
```

--------------------------------

### cusolverMpPotrf_bufferSize

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Calculates the buffer size required for the `cusolverMpPotrf` function.

```APIDOC
## cusolverMpPotrf_bufferSize

### Description
Calculates the buffer size required for the `cusolverMpPotrf` function, which computes the Cholesky factorization of a symmetric positive-definite matrix.

### Function Signature
```c
cusolverStatus_t cusolverMpPotrf_bufferSize<T>(
    cusolverMpHandle_t handle,
    cusolverMgpuDesc_t mgpu_desc,
    int n,
    const T* A,
    int lda,
    int* lwork
);
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (0)
- `cusolverStatus_t` (int) - Returns `0` on success.
- `lwork` (int*) - Pointer to an integer where the required buffer size will be stored.

#### Response Example
None
```

--------------------------------

### cusolverMpOrmqr_bufferSize

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Calculates the buffer size required for the `cusolverMpOrmqr` function.

```APIDOC
## cusolverMpOrmqr_bufferSize

### Description
Calculates the buffer size required for the `cusolverMpOrmqr` function, which applies an orthogonal matrix transformation to a matrix using the QR factorization.

### Function Signature
```c
cusolverStatus_t cusolverMpOrmqr_bufferSize<T>(
    cusolverMpHandle_t handle,
    cusolverMgpuDesc_t mgpu_desc,
    cusolverSideMode_t side,
    cusolverOperation_t trans,
    int m,
    int n,
    int k,
    const T* A,
    int lda,
    const T* tau,
    int* lwork
);
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (0)
- `cusolverStatus_t` (int) - Returns `0` on success.
- `lwork` (int*) - Pointer to an integer where the required buffer size will be stored.

#### Response Example
None
```

--------------------------------

### CAL Synchronization Calls

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/initialization/cal_to_nccl.html

Demonstrates CAL-specific synchronization functions for streams and communicators.

```c
CAL_CHECK(cal_stream_sync(cal_comm, stream));
CAL_CHECK(cal_comm_barrier(cal_comm, stream));
```

--------------------------------

### cusolverMpGeqrf

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Computes the QR factorization of a general matrix.

```APIDOC
## cusolverMpGeqrf

### Description
Computes the QR factorization of a real or complex matrix.

### Function Signature
```c
cusolverStatus_t cusolverMpGeqrf<T>(
    cusolverMpHandle_t handle,
    cusolverMgpuDesc_t mgpu_desc,
    int m,
    int n,
    T* A,
    int lda,
    T* tau,
    int* info
);
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (0)
- `cusolverStatus_t` (int) - Returns `0` on success.
- `A` (T*) - Matrix A, overwritten by the upper triangular matrix R.
- `tau` (T*) - Vector of scalars which will be used to form the triangular factor U.
- `info` (int*) - Pointer to an integer. If `info` is non-zero, it contains the row and column of the first non-positive diagonal minor.

#### Response Example
None
```

--------------------------------

### cusolverMpGetrf

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Computes an LU factorization of a general M-by-N distributed matrix sub(A) using partial pivoting. Pivoting can be disabled by setting d_ipiv to NULL. The factorization is of the form PA = LU.

```APIDOC
## cusolverMpGetrf

### Description
Computes an LU factorization of a general M-by-N distributed matrix sub(A) using partial pivoting. The user can also disable pivoting by setting `d_ipiv=NULL`.

The factorization has the form:
PA = LU

where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if M < N), and U is upper triangular (upper trapezoidal if M > N). L and U are stored in sub(A).

The user can combine [cusolverMpGetrf()](https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html.md#cusolvermpgetrf-label) and [cusolverMpGetrs()](https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html.md#cusolvermpgetrs-label) to solve a system of linear equations.

### Parameters
#### Device/Host Parameters
- **handle** (cusolverMpHandle_t) - Host - In - cuSOLVERMp library handle.
- **M** (int64_t) - Host - In - Number of rows of sub(A).
- **N** (int64_t) - Host - In - Number of columns of sub(A).
- **d_A** (void *) - Device - In/Out - Pointer to the first entry of the local portion of the global matrix A. On output, the sub(A) is overwritten with the L and U factors.
- **IA** (int64_t) - Host - In - Row index of the first row of the sub(A). This function does not make any assumptions on the alignment of `IA`.
- **JA** (int64_t) - Host - In - Column index of the first column of the sub(A). This function does not make any assumptions on the alignment of `JA`.
- **descrA** (cusolverMpMatrixDescriptor_t) - Host - In - Matrix descriptor associated to the global matrix A.
- **d_ipiv** (int64_t *) - Device - Out - Local array of dimension `(LOCr(M_A)+MB_A)`. If the user set `d_ipiv != NULL`, on output, this array contains the pivoting information. `d_ipiv[i]` indicates the global row local row i was swapped with. This array is tied to the distributed matrix A.
- **computeType** (cudaDataType_t) - Host - In - Data type used for computations. See table below for supported combinations.
- **d_work** (void *) - Device - Out - Device workspace of size `workspaceInBytesOnDevice`.
- **workspaceInBytesOnDevice** (size_t) - Host - In - The size in bytes of the local device workspace needed by the routine as provided by [cusolverMpGetrf_bufferSize()](https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html.md#cusolvermpgetrf-buffersize-label).
- **h_work** (void *) - Host - Out - Host workspace of size `workspaceInBytesOnHost`.
- **workspaceInBytesOnHost** (size_t) - Host - In - The size in bytes of the local host workspace needed by the routine as provided by [cusolverMpGetrf_bufferSize()](https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html.md#cusolvermpgetrf-buffersize-label).
- **info** (int *) - Device - Out - `info < 0` indicates an incorrect value of the i-th argument of the function. `info > 0` indicates the index of the leading minor in the case of a singular matrix.

### Supported Data Types
| Data Type of A | computeType | Output Data Type |
| --- | --- | --- |
| CUDA_R_32F | CUDA_R_32F | CUDA_R_32F |
| CUDA_R_64F | CUDA_R_64F | CUDA_R_64F |
| CUDA_C_32F | CUDA_C_32F | CUDA_C_32F |
| CUDA_C_64F | CUDA_C_64F | CUDA_C_64F |
```

--------------------------------

### cusolverMpGels_bufferSize

Source: https://docs.nvidia.com/cuda/cusolvermp/usage/functions.html

Computes the size in bytes of the host and device working buffers required by cusolverMpGels().

```APIDOC
## cusolverMpGels_bufferSize

### Description
Computes the size in bytes of the host and device working buffers required by cusolverMpGels().

### Signature
```c
cusolverStatus_t cusolverMpGels_bufferSize(
 cusolverMpHandle_t handle,
 cublasOperation_t trans,
 int64_t M,
 int64_t N,
 int64_t NRHS,
 void *d_A,
 int64_t IA,
 int64_t JA,
 const cusolverMpMatrixDescriptor_t descrA,
 void *d_B,
 int64_t IB,
 int64_t JB,
 const cusolverMpMatrixDescriptor_t descrB,
 cudaDataType_t computeType,
 size_t* workspaceInBytesOnDevice,
 size_t* workspaceInBytesOnHost)
```

### Parameters
#### Host Parameters
- **handle** (cusolverMpHandle_t) - Input - cuSOLVERMp library handle.
- **trans** (cublasOperation_t) - Input - Indicate that the linear system of sub(A) involves with no-transpose or (conj)transpose.
- **M** (int64_t) - Input - Number of rows of sub(A).
- **N** (int64_t) - Input - Number of columns of sub(A).
- **NRHS** (int64_t) - Input - Number of right hand side vectors i.e., number of columns of sub(B) and X.
- **IA** (int64_t) - Input - Row index of the first row of the sub(A). `IA` must be a multiple of the row blocking dimension `MB_A`.
- **JA** (int64_t) - Input - Column index of the first column of the sub(A). `JA` must be a multiple of the column blocking dimension `NB_A`.
- **descrA** (const cusolverMpMatrixDescriptor_t) - Input - Matrix descriptor associated to the global matrix A.
- **IB** (int64_t) - Input - Row index of the first row of the sub(B). `IB` must be a multiple of the row blocking dimension `MB_B`.
- **JB** (int64_t) - Input - Column index of the first column of the sub(B). `JB` must be a multiple of the column blocking dimension `NB_B`.
- **descrB** (const cusolverMpMatrixDescriptor_t) - Input - Matrix descriptor associated to the global matrix B.
- **computeType** (cudaDataType_t) - Input - Data type used for computations. See table below for supported combinations.
- **workspaceInBytesOnDevice** (size_t*) - Output - The size in bytes of the local device workspace needed by cusolverMpGels().
- **workspaceInBytesOnHost** (size_t*) - Output - The size in bytes of the local host workspace needed by cusolverMpGels().

#### Device Parameters
- **d_A** (void*) - Input - Pointer into the local memory to an array of dimension `(LLD_A, LOCc(JA+N-1))`.
- **d_B** (void*) - Input - Pointer into the local memory to an array of dimension `(LLD_B, LOCc(JB+NRHS-1))`.

### Supported Data Types
| Data Type of A | computeType | Output Data Type |
| --- | --- | --- |
| CUDA_R_32F | CUDA_R_32F | CUDA_R_32F |
| CUDA_R_64F | CUDA_R_64F | CUDA_R_64F |
| CUDA_C_32F | CUDA_C_32F | CUDA_C_32F |
| CUDA_C_64F | CUDA_C_64F | CUDA_C_64F |
```
Tokens:
Raw