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: }