Actual source code: matmpidensehip.hip.cpp

      1: #include "../matmpidensecupm.hpp"

      3: using namespace Petsc::mat::cupm;
      4: using Petsc::device::cupm::DeviceType;

      6: static constexpr impl::MatDense_MPI_CUPM<DeviceType::HIP> mat_cupm{};

      8: /*MC
      9:   MATDENSEHIP - "densehip" - A matrix type to be used for dense matrices on GPUs.

     11:   This matrix type is identical to `MATSEQDENSEHIP` when constructed with a single process
     12:   communicator, and `MATMPIDENSEHIP` otherwise.

     14:   Options Database Key:
     15: . -mat_type densehip - sets the matrix type to `MATDENSEHIP` during a call to
     16:                         `MatSetFromOptions()`

     18:   Level: beginner

     20: .seealso: [](ch_matrices), `Mat`, `MATSEQDENSEHIP`, `MATMPIDENSEHIP`, `MATSEQDENSECUDA`,
     21: `MATMPIDENSECUDA`, `MATDENSE`
     22: M*/

     24: /*MC
     25:   MATMPIDENSEHIP - "mpidensehip" - A matrix type to be used for distributed dense matrices on
     26:   GPUs.

     28:   Options Database Key:
     29: . -mat_type mpidensehip - sets the matrix type to `MATMPIDENSEHIP` during a call to
     30:                            `MatSetFromOptions()`

     32:   Level: beginner

     34: .seealso: [](ch_matrices), `Mat`, `MATDENSEHIP`, `MATMPIDENSE`, `MATSEQDENSE`,
     35: `MATSEQDENSEHIP`, `MATSEQDENSECUDA`
     36: M*/
     37: PETSC_INTERN PetscErrorCode MatCreate_MPIDenseHIP(Mat A)
     38: {
     39:   PetscFunctionBegin;
     40:   PetscCall(mat_cupm.Create(A));
     41:   PetscFunctionReturn(PETSC_SUCCESS);
     42: }

     44: PetscErrorCode MatConvert_MPIDense_MPIDenseHIP(Mat A, MatType type, MatReuse reuse, Mat *ret)
     45: {
     46:   PetscFunctionBegin;
     47:   PetscCall(mat_cupm.Convert_MPIDense_MPIDenseCUPM(A, type, reuse, ret));
     48:   PetscFunctionReturn(PETSC_SUCCESS);
     49: }

     51: /*@C
     52:   MatCreateDenseHIP - Creates a matrix in `MATDENSEHIP` format using HIP.

     54:   Collective

     56:   Input Parameters:
     57: + comm - MPI communicator
     58: . m    - number of local rows (or `PETSC_DECIDE` to have calculated if `M` is given)
     59: . n    - number of local columns (or `PETSC_DECIDE` to have calculated if `N` is given)
     60: . M    - number of global rows (or `PETSC_DECIDE` to have calculated if `m` is given)
     61: . N    - number of global columns (or `PETSC_DECIDE` to have calculated if `n` is given)
     62: - data - optional location of GPU matrix data. Pass `NULL` to have PETSc to control matrix
     63:          memory allocation.

     65:   Output Parameter:
     66: . A - the matrix

     68:   Level: intermediate

     70: .seealso: `MATDENSEHIP`, `MatCreate()`, `MatCreateDense()`
     71: @*/
     72: PetscErrorCode MatCreateDenseHIP(MPI_Comm comm, PetscInt m, PetscInt n, PetscInt M, PetscInt N, PetscScalar *data, Mat *A)
     73: {
     74:   PetscFunctionBegin;
     75:   PetscCall(MatCreateDenseCUPM<DeviceType::HIP>(comm, m, n, M, N, data, A));
     76:   PetscFunctionReturn(PETSC_SUCCESS);
     77: }

     79: /*@C
     80:   MatDenseHIPPlaceArray - Allows one to replace the GPU array in a `MATDENSEHIP` matrix with an
     81:   array provided by the user. This is useful to avoid copying an array into a matrix.

     83:   Not Collective

     85:   Input Parameters:
     86: + mat   - the matrix
     87: - array - the array in column major order

     89:   Level: developer

     91:   Note:
     92:   Adding `const` to `array` was an oversight, see notes in `VecPlaceArray()`.

     94:   You can return to the original array with a call to `MatDenseHIPResetArray()`. The user is
     95:   responsible for freeing this array; it will not be freed when the matrix is destroyed. The
     96:   array must have been allocated with `hipMalloc()`.

     98: .seealso: `MATDENSEHIP`, `MatDenseHIPGetArray()`, `MatDenseHIPResetArray()`,
     99: `MatDenseHIPReplaceArray()`
    100: @*/
    101: PetscErrorCode MatDenseHIPPlaceArray(Mat mat, const PetscScalar *array)
    102: {
    103:   PetscFunctionBegin;
    104:   PetscCall(MatDenseCUPMPlaceArray<DeviceType::HIP>(mat, array));
    105:   PetscFunctionReturn(PETSC_SUCCESS);
    106: }

    108: /*@C
    109:   MatDenseHIPResetArray - Resets the matrix array to that it previously had before the call to
    110:   `MatDenseHIPPlaceArray()`

    112:   Not Collective

    114:   Input Parameter:
    115: . mat - the matrix

    117:   Level: developer

    119:   Note:
    120:   You can only call this after a call to `MatDenseHIPPlaceArray()`

    122: .seealso: `MATDENSEHIP`, `MatDenseHIPGetArray()`, `MatDenseHIPPlaceArray()`
    123: @*/
    124: PetscErrorCode MatDenseHIPResetArray(Mat mat)
    125: {
    126:   PetscFunctionBegin;
    127:   PetscCall(MatDenseCUPMResetArray<DeviceType::HIP>(mat));
    128:   PetscFunctionReturn(PETSC_SUCCESS);
    129: }

    131: /*@C
    132:   MatDenseHIPReplaceArray - Allows one to replace the GPU array in a `MATDENSEHIP` matrix
    133:   with an array provided by the user. This is useful to avoid copying an array into a matrix.

    135:   Not Collective

    137:   Input Parameters:
    138: + mat   - the matrix
    139: - array - the array in column major order

    141:   Level: developer

    143:   Note:
    144:   Adding `const` to `array` was an oversight, see notes in `VecPlaceArray()`.

    146:   This permanently replaces the GPU array and frees the memory associated with the old GPU
    147:   array. The memory passed in CANNOT be freed by the user. It will be freed when the matrix is
    148:   destroyed. The array should respect the matrix leading dimension.

    150: .seealso: `MatDenseHIPGetArray()`, `MatDenseHIPPlaceArray()`, `MatDenseHIPResetArray()`
    151: @*/
    152: PetscErrorCode MatDenseHIPReplaceArray(Mat mat, const PetscScalar *array)
    153: {
    154:   PetscFunctionBegin;
    155:   PetscCall(MatDenseCUPMReplaceArray<DeviceType::HIP>(mat, array));
    156:   PetscFunctionReturn(PETSC_SUCCESS);
    157: }

    159: /*@C
    160:   MatDenseHIPGetArrayWrite - Provides write access to the HIP buffer inside a `MATDENSEHIP`
    161:   matrix.

    163:   Not Collective

    165:   Input Parameter:
    166: . A - the matrix

    168:   Output Parameter:
    169: . a - the GPU array in column major order

    171:   Level: developer

    173:   Notes:
    174:   The data on the GPU may not be updated due to operations done on the CPU. If you need updated
    175:   data, use `MatDenseHIPGetArray()`.

    177:   The array must be restored with `MatDenseHIPRestoreArrayWrite()` when no longer needed.

    179: .seealso: `MATDENSEHIP`, `MatDenseHIPGetArray()`, `MatDenseHIPRestoreArray()`,
    180: `MatDenseHIPRestoreArrayWrite()`, `MatDenseHIPGetArrayRead()`,
    181: `MatDenseHIPRestoreArrayRead()`
    182: @*/
    183: PetscErrorCode MatDenseHIPGetArrayWrite(Mat A, PetscScalar **a)
    184: {
    185:   PetscFunctionBegin;
    186:   PetscCall(MatDenseCUPMGetArrayWrite<DeviceType::HIP>(A, a));
    187:   PetscFunctionReturn(PETSC_SUCCESS);
    188: }

    190: /*@C
    191:   MatDenseHIPRestoreArrayWrite - Restore write access to the HIP buffer inside a
    192:   `MATDENSEHIP` matrix previously obtained with `MatDenseHIPGetArrayWrite()`.

    194:   Not Collective

    196:   Input Parameters:
    197: + A - the matrix
    198: - a - the GPU array in column major order

    200:   Level: developer

    202: .seealso: `MATDENSEHIP`, `MatDenseHIPGetArray()`, `MatDenseHIPRestoreArray()`,
    203: `MatDenseHIPGetArrayWrite()`, `MatDenseHIPRestoreArrayRead()`, `MatDenseHIPGetArrayRead()`
    204: @*/
    205: PetscErrorCode MatDenseHIPRestoreArrayWrite(Mat A, PetscScalar **a)
    206: {
    207:   PetscFunctionBegin;
    208:   PetscCall(MatDenseCUPMRestoreArrayWrite<DeviceType::HIP>(A, a));
    209:   PetscFunctionReturn(PETSC_SUCCESS);
    210: }

    212: /*@C
    213:   MatDenseHIPGetArrayRead - Provides read-only access to the HIP buffer inside a
    214:   `MATDENSEHIP` matrix. The array must be restored with `MatDenseHIPRestoreArrayRead()` when
    215:   no longer needed.

    217:   Not Collective

    219:   Input Parameter:
    220: . A - the matrix

    222:   Output Parameter:
    223: . a - the GPU array in column major order

    225:   Level: developer

    227:   Note:
    228:   Data may be copied to the GPU due to operations done on the CPU. If you need write only
    229:   access, use `MatDenseHIPGetArrayWrite()`.

    231: .seealso: `MATDENSEHIP`, `MatDenseHIPGetArray()`, `MatDenseHIPRestoreArray()`,
    232: `MatDenseHIPRestoreArrayWrite()`, `MatDenseHIPGetArrayWrite()`,
    233: `MatDenseHIPRestoreArrayRead()`
    234: @*/
    235: PetscErrorCode MatDenseHIPGetArrayRead(Mat A, const PetscScalar **a)
    236: {
    237:   PetscFunctionBegin;
    238:   PetscCall(MatDenseCUPMGetArrayRead<DeviceType::HIP>(A, a));
    239:   PetscFunctionReturn(PETSC_SUCCESS);
    240: }

    242: /*@C
    243:   MatDenseHIPRestoreArrayRead - Restore read-only access to the HIP buffer inside a
    244:   `MATDENSEHIP` matrix previously obtained with a call to `MatDenseHIPGetArrayRead()`.

    246:   Not Collective

    248:   Input Parameters:
    249: + A - the matrix
    250: - a - the GPU array in column major order

    252:   Level: developer

    254:   Note:
    255:   Data can be copied to the GPU due to operations done on the CPU. If you need write only
    256:   access, use `MatDenseHIPGetArrayWrite()`.

    258: .seealso: `MATDENSEHIP`, `MatDenseHIPGetArray()`, `MatDenseHIPRestoreArray()`,
    259: `MatDenseHIPRestoreArrayWrite()`, `MatDenseHIPGetArrayWrite()`, `MatDenseHIPGetArrayRead()`
    260: @*/
    261: PetscErrorCode MatDenseHIPRestoreArrayRead(Mat A, const PetscScalar **a)
    262: {
    263:   PetscFunctionBegin;
    264:   PetscCall(MatDenseCUPMRestoreArrayRead<DeviceType::HIP>(A, a));
    265:   PetscFunctionReturn(PETSC_SUCCESS);
    266: }

    268: /*@C
    269:   MatDenseHIPGetArray - Provides access to the HIP buffer inside a `MATDENSEHIP` matrix. The
    270:   array must be restored with `MatDenseHIPRestoreArray()` when no longer needed.

    272:   Not Collective

    274:   Input Parameter:
    275: . A - the matrix

    277:   Output Parameter:
    278: . a - the GPU array in column major order

    280:   Level: developer

    282:   Note:
    283:   Data can be copied to the GPU due to operations done on the CPU. If you need write only
    284:   access, use `MatDenseHIPGetArrayWrite()`. For read-only access, use
    285:   `MatDenseHIPGetArrayRead()`.

    287: .seealso: `MATDENSEHIP`, `MatDenseHIPGetArrayRead()`, `MatDenseHIPRestoreArray()`,
    288: `MatDenseHIPRestoreArrayWrite()`, `MatDenseHIPGetArrayWrite()`,
    289: `MatDenseHIPRestoreArrayRead()`
    290: @*/
    291: PetscErrorCode MatDenseHIPGetArray(Mat A, PetscScalar **a)
    292: {
    293:   PetscFunctionBegin;
    294:   PetscCall(MatDenseCUPMGetArray<DeviceType::HIP>(A, a));
    295:   PetscFunctionReturn(PETSC_SUCCESS);
    296: }

    298: /*@C
    299:   MatDenseHIPRestoreArray - Restore access to the HIP buffer inside a `MATDENSEHIP` matrix
    300:   previously obtained with `MatDenseHIPGetArray()`.

    302:   Not Collective

    304:   Level: developer

    306:   Input Parameters:
    307: + A - the matrix
    308: - a - the GPU array in column major order

    310: .seealso: `MATDENSEHIP`, `MatDenseHIPGetArray()`, `MatDenseHIPRestoreArrayWrite()`,
    311: `MatDenseHIPGetArrayWrite()`, `MatDenseHIPRestoreArrayRead()`, `MatDenseHIPGetArrayRead()`
    312: @*/
    313: PetscErrorCode MatDenseHIPRestoreArray(Mat A, PetscScalar **a)
    314: {
    315:   PetscFunctionBegin;
    316:   PetscCall(MatDenseCUPMRestoreArray<DeviceType::HIP>(A, a));
    317:   PetscFunctionReturn(PETSC_SUCCESS);
    318: }

    320: /*@C
    321:   MatDenseHIPSetPreallocation - Set the device array used for storing the matrix elements of a
    322:   `MATDENSEHIP` matrix

    324:   Collective

    326:   Input Parameters:
    327: + A            - the matrix
    328: - device_array - the array (or `NULL`)

    330:   Level: intermediate

    332: .seealso: [](ch_matrices), `Mat`, `MATDENSEHIP`, `MatCreate()`, `MatCreateDenseHIP()`,
    333: `MatSetValues()`, `MatDenseSetLDA()`
    334: @*/
    335: PetscErrorCode MatDenseHIPSetPreallocation(Mat A, PetscScalar *device_array)
    336: {
    337:   PetscFunctionBegin;
    338:   PetscCall(MatDenseCUPMSetPreallocation<DeviceType::HIP>(A, device_array));
    339:   PetscFunctionReturn(PETSC_SUCCESS);
    340: }