Actual source code: ex70.c
1: #include <petscmat.h>
3: static char help[] = "Tests MatMat operations with MAT_REUSE_MATRIX and already allocated dense result.\n\n";
5: static PetscScalar MAGIC_NUMBER = 12345;
7: static PetscErrorCode CheckLocal(Mat A, Mat B, PetscScalar *a, PetscScalar *b)
8: {
9: PetscBool wA = PETSC_FALSE, wB = PETSC_FALSE;
10: PetscBool wAv = PETSC_FALSE, wBv = PETSC_FALSE;
11: PetscInt lda, i, j, m, n;
13: PetscFunctionBegin;
14: if (a) {
15: const PetscScalar *Aa;
16: PetscCall(MatDenseGetArrayRead(A, &Aa));
17: wA = (PetscBool)(a != Aa);
18: PetscCall(MatDenseGetLDA(A, &lda));
19: PetscCall(MatGetLocalSize(A, &m, &n));
20: for (j = 0; j < n; j++) {
21: for (i = m; i < lda; i++) {
22: if (Aa[j * lda + i] != MAGIC_NUMBER) wAv = PETSC_TRUE;
23: }
24: }
25: PetscCall(MatDenseRestoreArrayRead(A, &Aa));
26: }
27: if (b) {
28: const PetscScalar *Bb;
29: PetscCall(MatDenseGetArrayRead(B, &Bb));
30: wB = (PetscBool)(b != Bb);
31: PetscCall(MatDenseGetLDA(B, &lda));
32: PetscCall(MatGetLocalSize(B, &m, &n));
33: for (j = 0; j < n; j++) {
34: for (i = m; i < lda; i++) {
35: if (Bb[j * lda + i] != MAGIC_NUMBER) wBv = PETSC_TRUE;
36: }
37: }
38: PetscCall(MatDenseRestoreArrayRead(B, &Bb));
39: }
40: PetscCheck(!wA && !wB, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Wrong array in first Mat? %d, Wrong array in second Mat? %d", wA, wB);
41: PetscCheck(!wAv && !wBv, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Wrong data in first Mat? %d, Wrong data in second Mat? %d", wAv, wBv);
42: PetscFunctionReturn(PETSC_SUCCESS);
43: }
45: typedef struct {
46: Mat A;
47: Mat P;
48: Mat R;
49: } proj_data;
51: PetscErrorCode proj_destroy(PetscCtxRt ctx)
52: {
53: proj_data *userdata = *(proj_data **)ctx;
55: PetscFunctionBegin;
56: PetscCheck(userdata, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Missing userdata");
57: PetscCall(MatDestroy(&userdata->A));
58: PetscCall(MatDestroy(&userdata->P));
59: PetscCall(MatDestroy(&userdata->R));
60: PetscCall(PetscFree(userdata));
61: PetscFunctionReturn(PETSC_SUCCESS);
62: }
64: PetscErrorCode proj_mult(Mat S, Vec X, Vec Y)
65: {
66: Mat A, R, P;
67: Vec Ax, Ay;
68: Vec Px, Py;
69: proj_data *userdata;
71: PetscFunctionBegin;
72: PetscCall(MatShellGetContext(S, &userdata));
73: PetscCheck(userdata, PetscObjectComm((PetscObject)S), PETSC_ERR_PLIB, "Missing userdata");
74: A = userdata->A;
75: R = userdata->R;
76: P = userdata->P;
77: PetscCheck(A, PetscObjectComm((PetscObject)S), PETSC_ERR_PLIB, "Missing matrix");
78: PetscCheck(R || P, PetscObjectComm((PetscObject)S), PETSC_ERR_PLIB, "Missing projectors");
79: PetscCheck(!R || !P, PetscObjectComm((PetscObject)S), PETSC_ERR_PLIB, "Both projectors");
80: PetscCall(MatCreateVecs(A, &Ax, &Ay));
81: if (R) PetscCall(MatCreateVecs(R, &Py, &Px));
82: else PetscCall(MatCreateVecs(P, &Px, &Py));
83: PetscCall(VecCopy(X, Px));
84: if (P) PetscCall(MatMult(P, Px, Py));
85: else PetscCall(MatMultTranspose(R, Px, Py));
86: PetscCall(VecCopy(Py, Ax));
87: PetscCall(MatMult(A, Ax, Ay));
88: PetscCall(VecCopy(Ay, Py));
89: if (P) PetscCall(MatMultTranspose(P, Py, Px));
90: else PetscCall(MatMult(R, Py, Px));
91: PetscCall(VecCopy(Px, Y));
92: PetscCall(VecDestroy(&Px));
93: PetscCall(VecDestroy(&Py));
94: PetscCall(VecDestroy(&Ax));
95: PetscCall(VecDestroy(&Ay));
96: PetscFunctionReturn(PETSC_SUCCESS);
97: }
99: PetscErrorCode MyPtShellPMultSymbolic(Mat S, Mat P, Mat PtAP, void **ctx)
100: {
101: proj_data *userdata;
103: PetscFunctionBegin;
104: PetscCall(PetscNew(&userdata));
105: PetscCall(MatShellSetContext(PtAP, userdata));
106: *ctx = (void *)userdata;
107: PetscFunctionReturn(PETSC_SUCCESS);
108: }
110: PetscErrorCode MyPtShellPMultNumeric(Mat S, Mat P, Mat PtAP, PetscCtx ctx)
111: {
112: Mat A;
113: proj_data *userdata = (proj_data *)ctx;
115: PetscFunctionBegin;
116: PetscCall(MatShellGetContext(S, &A));
117: PetscCall(PetscObjectReference((PetscObject)A));
118: PetscCall(PetscObjectReference((PetscObject)P));
119: PetscCall(MatDestroy(&userdata->A));
120: PetscCall(MatDestroy(&userdata->P));
121: PetscCall(MatDestroy(&userdata->R));
122: userdata->A = A;
123: userdata->P = P;
124: PetscCall(MatShellSetOperation(PtAP, MATOP_MULT, (PetscErrorCodeFn *)proj_mult));
125: PetscCall(MatSetUp(PtAP));
126: PetscCall(MatAssemblyBegin(PtAP, MAT_FINAL_ASSEMBLY));
127: PetscCall(MatAssemblyEnd(PtAP, MAT_FINAL_ASSEMBLY));
128: PetscFunctionReturn(PETSC_SUCCESS);
129: }
131: PetscErrorCode MyRShellRtMultSymbolic(Mat S, Mat R, Mat RARt, void **ctx)
132: {
133: proj_data *userdata;
135: PetscFunctionBegin;
136: PetscCall(PetscNew(&userdata));
137: PetscCall(MatShellSetContext(RARt, userdata));
138: *ctx = (void *)userdata;
139: PetscFunctionReturn(PETSC_SUCCESS);
140: }
142: PetscErrorCode MyRShellRtMultNumeric(Mat S, Mat R, Mat RARt, PetscCtx ctx)
143: {
144: Mat A;
145: proj_data *userdata = (proj_data *)ctx;
147: PetscFunctionBegin;
148: PetscCall(MatShellGetContext(S, &A));
149: PetscCall(PetscObjectReference((PetscObject)A));
150: PetscCall(PetscObjectReference((PetscObject)R));
151: PetscCall(MatDestroy(&userdata->A));
152: PetscCall(MatDestroy(&userdata->P));
153: PetscCall(MatDestroy(&userdata->R));
154: userdata->A = A;
155: userdata->R = R;
156: PetscCall(MatShellSetOperation(RARt, MATOP_MULT, (PetscErrorCodeFn *)proj_mult));
157: PetscCall(MatSetUp(RARt));
158: PetscCall(MatAssemblyBegin(RARt, MAT_FINAL_ASSEMBLY));
159: PetscCall(MatAssemblyEnd(RARt, MAT_FINAL_ASSEMBLY));
160: PetscFunctionReturn(PETSC_SUCCESS);
161: }
163: PetscErrorCode MyMatShellMatMultNumeric(Mat S, Mat B, Mat C, PetscCtx ctx)
164: {
165: Mat A;
167: PetscFunctionBegin;
168: PetscCall(MatShellGetContext(S, &A));
169: PetscCall(MatMatMult(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &C));
170: PetscFunctionReturn(PETSC_SUCCESS);
171: }
173: PetscErrorCode MyMatTransposeShellMatMultNumeric(Mat S, Mat B, Mat C, PetscCtx ctx)
174: {
175: Mat A;
177: PetscFunctionBegin;
178: PetscCall(MatShellGetContext(S, &A));
179: PetscCall(MatTransposeMatMult(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &C));
180: PetscFunctionReturn(PETSC_SUCCESS);
181: }
183: PetscErrorCode MyMatShellMatTransposeMultNumeric(Mat S, Mat B, Mat C, PetscCtx ctx)
184: {
185: Mat A;
187: PetscFunctionBegin;
188: PetscCall(MatShellGetContext(S, &A));
189: PetscCall(MatMatTransposeMult(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &C));
190: PetscFunctionReturn(PETSC_SUCCESS);
191: }
193: int main(int argc, char **args)
194: {
195: Mat X, B, A, Bt, T, T2, PtAP = NULL, RARt = NULL, R = NULL;
196: Vec r, l, rs, ls;
197: PetscInt m, n, k, M = 10, N = 10, K = 5, ldx = 3, ldb = 5, ldr = 4;
198: char mattype[256];
199: PetscBool flg, symm = PETSC_FALSE, testtt = PETSC_TRUE, testnest = PETSC_TRUE, testtranspose = PETSC_TRUE, testcircular = PETSC_FALSE, local = PETSC_TRUE;
200: PetscBool testhtranspose = PETSC_FALSE; /* Hermitian transpose is not handled correctly and generates an error */
201: PetscBool xgpu = PETSC_FALSE, bgpu = PETSC_FALSE, testshellops = PETSC_FALSE, testproj = PETSC_TRUE, testrart = PETSC_TRUE, testmatmatt = PETSC_TRUE, testmattmat = PETSC_TRUE, formt = PETSC_FALSE, testreusemodified = PETSC_FALSE;
202: PetscScalar *dataX = NULL, *dataB = NULL, *dataR = NULL, *dataBt = NULL;
203: PetscScalar *aX, *aB, *aBt;
204: PetscReal err;
206: PetscFunctionBeginUser;
207: PetscCall(PetscInitialize(&argc, &args, NULL, help));
208: PetscCall(PetscOptionsGetInt(NULL, NULL, "-N", &N, NULL));
209: PetscCall(PetscOptionsGetInt(NULL, NULL, "-M", &M, NULL));
210: PetscCall(PetscOptionsGetInt(NULL, NULL, "-K", &K, NULL));
211: PetscCall(PetscOptionsGetBool(NULL, NULL, "-symm", &symm, NULL));
212: PetscCall(PetscOptionsGetBool(NULL, NULL, "-local", &local, NULL));
213: PetscCall(PetscOptionsGetInt(NULL, NULL, "-ldx", &ldx, NULL));
214: PetscCall(PetscOptionsGetInt(NULL, NULL, "-ldb", &ldb, NULL));
215: PetscCall(PetscOptionsGetInt(NULL, NULL, "-ldr", &ldr, NULL));
216: PetscCall(PetscOptionsGetBool(NULL, NULL, "-testtranspose", &testtranspose, NULL));
217: PetscCall(PetscOptionsGetBool(NULL, NULL, "-testnest", &testnest, NULL));
218: PetscCall(PetscOptionsGetBool(NULL, NULL, "-testtt", &testtt, NULL));
219: PetscCall(PetscOptionsGetBool(NULL, NULL, "-testcircular", &testcircular, NULL));
220: PetscCall(PetscOptionsGetBool(NULL, NULL, "-testshellops", &testshellops, NULL));
221: PetscCall(PetscOptionsGetBool(NULL, NULL, "-testproj", &testproj, NULL));
222: PetscCall(PetscOptionsGetBool(NULL, NULL, "-testrart", &testrart, NULL));
223: PetscCall(PetscOptionsGetBool(NULL, NULL, "-testmatmatt", &testmatmatt, NULL));
224: PetscCall(PetscOptionsGetBool(NULL, NULL, "-testmattmat", &testmattmat, NULL));
225: PetscCall(PetscOptionsGetBool(NULL, NULL, "-xgpu", &xgpu, NULL));
226: PetscCall(PetscOptionsGetBool(NULL, NULL, "-bgpu", &bgpu, NULL));
227: PetscCall(PetscOptionsGetBool(NULL, NULL, "-A_form_explicit_transpose", &formt, NULL));
228: PetscCall(PetscOptionsGetBool(NULL, NULL, "-testreusemodified", &testreusemodified, NULL));
229: PetscCall(PetscOptionsGetScalar(NULL, NULL, "-magic_number", &MAGIC_NUMBER, NULL));
230: if (M != N) testproj = PETSC_FALSE;
232: PetscCall(MatCreate(PETSC_COMM_WORLD, &A));
233: PetscCall(MatSetSizes(A, PETSC_DECIDE, PETSC_DECIDE, M, N));
234: PetscCall(MatSetType(A, MATAIJ));
235: PetscCall(MatSeqAIJSetPreallocation(A, PETSC_DEFAULT, NULL));
236: PetscCall(MatMPIAIJSetPreallocation(A, PETSC_DEFAULT, NULL, PETSC_DEFAULT, NULL));
237: PetscCall(MatSetUp(A));
238: PetscCall(MatSetRandom(A, NULL));
239: if (M == N && symm) {
240: Mat AT;
242: PetscCall(MatTranspose(A, MAT_INITIAL_MATRIX, &AT));
243: PetscCall(MatAXPY(A, 1.0, AT, DIFFERENT_NONZERO_PATTERN));
244: PetscCall(MatDestroy(&AT));
245: PetscCall(MatSetOption(A, MAT_SYMMETRIC, PETSC_TRUE));
246: }
247: PetscCall(MatViewFromOptions(A, NULL, "-A_init_view"));
248: PetscOptionsBegin(PETSC_COMM_WORLD, "", "", "");
249: PetscCall(PetscOptionsFList("-A_mat_type", "Matrix type", "MatSetType", MatList, MATAIJ, mattype, sizeof(mattype), &flg));
250: PetscOptionsEnd();
251: if (flg) {
252: Mat A2;
254: PetscCall(MatDuplicate(A, MAT_COPY_VALUES, &A2));
255: PetscCall(MatConvert(A, mattype, MAT_INPLACE_MATRIX, &A));
256: PetscCall(MatMultEqual(A, A2, 10, &flg));
257: if (!flg) {
258: Mat AE, A2E;
260: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with convert\n"));
261: PetscCall(MatComputeOperator(A, MATDENSE, &AE));
262: PetscCall(MatComputeOperator(A2, MATDENSE, &A2E));
263: PetscCall(MatView(AE, NULL));
264: PetscCall(MatView(A2E, NULL));
265: PetscCall(MatAXPY(A2E, -1.0, A, SAME_NONZERO_PATTERN));
266: PetscCall(MatView(A2E, NULL));
267: PetscCall(MatDestroy(&A2E));
268: PetscCall(MatDestroy(&AE));
269: }
270: PetscCall(MatDestroy(&A2));
271: }
272: if (formt) PetscCall(MatSetOption(A, MAT_FORM_EXPLICIT_TRANSPOSE, PETSC_TRUE));
273: PetscCall(MatViewFromOptions(A, NULL, "-A_view"));
275: PetscCall(MatGetLocalSize(A, &m, &n));
276: if (local) {
277: PetscCall(PetscMalloc1((m + ldx) * K, &dataX));
278: PetscCall(PetscMalloc1((n + ldb) * K, &dataB));
279: for (PetscInt i = 0; i < (m + ldx) * K; i++) dataX[i] = MAGIC_NUMBER;
280: for (PetscInt i = 0; i < (n + ldb) * K; i++) dataB[i] = MAGIC_NUMBER;
281: }
282: PetscCall(MatCreateDense(PETSC_COMM_WORLD, n, PETSC_DECIDE, N, K, dataB, &B));
283: PetscCall(MatCreateDense(PETSC_COMM_WORLD, m, PETSC_DECIDE, M, K, dataX, &X));
284: if (local) {
285: PetscCall(MatDenseSetLDA(X, m + ldx));
286: PetscCall(MatDenseSetLDA(B, n + ldb));
287: }
288: PetscCall(MatGetLocalSize(B, NULL, &k));
289: if (local) {
290: PetscCall(PetscMalloc1((k + ldr) * N, &dataBt));
291: for (PetscInt i = 0; i < (k + ldr) * N; i++) dataBt[i] = MAGIC_NUMBER;
292: }
293: PetscCall(MatCreateDense(PETSC_COMM_WORLD, k, n, K, N, dataBt, &Bt));
294: if (local) PetscCall(MatDenseSetLDA(Bt, k + ldr));
296: /* store pointer to dense data for testing */
297: PetscCall(MatDenseGetArrayRead(B, (const PetscScalar **)&dataB));
298: PetscCall(MatDenseGetArrayRead(X, (const PetscScalar **)&dataX));
299: PetscCall(MatDenseGetArrayRead(Bt, (const PetscScalar **)&dataBt));
300: aX = dataX;
301: aB = dataB;
302: aBt = dataBt;
303: PetscCall(MatDenseRestoreArrayRead(Bt, (const PetscScalar **)&dataBt));
304: PetscCall(MatDenseRestoreArrayRead(B, (const PetscScalar **)&dataB));
305: PetscCall(MatDenseRestoreArrayRead(X, (const PetscScalar **)&dataX));
306: if (local) {
307: dataX = aX;
308: dataB = aB;
309: dataBt = aBt;
310: }
312: PetscCall(MatSetRandom(X, NULL));
313: PetscCall(MatSetRandom(B, NULL));
314: PetscCall(MatSetRandom(Bt, NULL));
315: PetscCall(CheckLocal(X, NULL, aX, NULL));
316: PetscCall(CheckLocal(Bt, B, aBt, aB));
318: /* convert to CUDA if needed */
319: if (bgpu) {
320: PetscCall(MatConvert(B, MATDENSECUDA, MAT_INPLACE_MATRIX, &B));
321: PetscCall(MatConvert(Bt, MATDENSECUDA, MAT_INPLACE_MATRIX, &Bt));
322: }
323: if (xgpu) PetscCall(MatConvert(X, MATDENSECUDA, MAT_INPLACE_MATRIX, &X));
324: PetscCall(CheckLocal(B, X, aB, aX));
326: /* Test MatDenseGetSubMatrix */
327: {
328: Mat B2, T3, T4;
330: PetscCall(MatDuplicate(B, MAT_COPY_VALUES, &B2));
331: PetscCall(MatDuplicate(B, MAT_DO_NOT_COPY_VALUES, &T4));
332: PetscCall(MatSetRandom(T4, NULL));
333: PetscCall(MatAXPY(B2, 1.0, T4, SAME_NONZERO_PATTERN));
334: PetscCall(MatDenseGetSubMatrix(B, PETSC_DECIDE, PETSC_DECIDE, PetscMin(1, K - 1), PetscMin(2, K), &T));
335: PetscCall(MatDenseGetSubMatrix(T4, PETSC_DECIDE, PETSC_DECIDE, PetscMin(1, K - 1), PetscMin(2, K), &T2));
336: PetscCall(MatDenseGetSubMatrix(B2, PETSC_DECIDE, PETSC_DECIDE, PetscMin(1, K - 1), PetscMin(2, K), &T3));
337: PetscCall(MatAXPY(T, 1.0, T2, SAME_NONZERO_PATTERN));
338: PetscCall(MatAXPY(T3, -1.0, T, SAME_NONZERO_PATTERN));
339: PetscCall(MatNorm(T3, NORM_FROBENIUS, &err));
340: if (err > PETSC_SMALL) {
341: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MatDenseGetSubMatrix\n"));
342: PetscCall(MatView(T3, NULL));
343: }
344: PetscCall(MatDenseRestoreSubMatrix(B, &T));
345: PetscCall(MatDenseRestoreSubMatrix(T4, &T2));
346: PetscCall(MatDenseRestoreSubMatrix(B2, &T3));
347: PetscCall(CheckLocal(B, NULL, aB, NULL));
348: PetscCall(MatDestroy(&B2));
349: PetscCall(MatDestroy(&T4));
350: if (N >= 2) {
351: PetscCall(MatDuplicate(B, MAT_COPY_VALUES, &B2));
352: PetscCall(MatDuplicate(B, MAT_DO_NOT_COPY_VALUES, &T4));
353: PetscCall(MatSetRandom(T4, NULL));
354: PetscCall(MatAXPY(B2, 1.0, T4, SAME_NONZERO_PATTERN));
355: PetscCall(MatDenseGetSubMatrix(B, N - 2, PETSC_DECIDE, PetscMin(1, K - 1), PetscMin(2, K), &T));
356: PetscCall(MatDenseGetSubMatrix(T4, N - 2, PETSC_DECIDE, PetscMin(1, K - 1), PetscMin(2, K), &T2));
357: PetscCall(MatDenseGetSubMatrix(B2, N - 2, PETSC_DECIDE, PetscMin(1, K - 1), PetscMin(2, K), &T3));
358: PetscCall(MatAXPY(T, 1.0, T2, SAME_NONZERO_PATTERN));
359: PetscCall(MatAXPY(T3, -1.0, T, SAME_NONZERO_PATTERN));
360: PetscCall(MatNorm(T3, NORM_FROBENIUS, &err));
361: if (err > PETSC_SMALL) {
362: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MatDenseGetSubMatrix\n"));
363: PetscCall(MatView(T3, NULL));
364: }
365: PetscCall(MatDenseRestoreSubMatrix(B, &T));
366: PetscCall(MatDenseRestoreSubMatrix(T4, &T2));
367: PetscCall(MatDenseRestoreSubMatrix(B2, &T3));
368: PetscCall(CheckLocal(B, NULL, aB, NULL));
369: PetscCall(MatDestroy(&B2));
370: PetscCall(MatDestroy(&T4));
371: PetscCall(MatDuplicate(B, MAT_COPY_VALUES, &B2));
372: PetscCall(MatDuplicate(B, MAT_DO_NOT_COPY_VALUES, &T4));
373: PetscCall(MatSetRandom(T4, NULL));
374: PetscCall(MatAXPY(B2, 1.0, T4, SAME_NONZERO_PATTERN));
375: PetscCall(MatDenseGetSubMatrix(B, PETSC_DECIDE, 2, PetscMin(1, K - 1), PetscMin(2, K), &T));
376: PetscCall(MatDenseGetSubMatrix(T4, PETSC_DECIDE, 2, PetscMin(1, K - 1), PetscMin(2, K), &T2));
377: PetscCall(MatDenseGetSubMatrix(B2, PETSC_DECIDE, 2, PetscMin(1, K - 1), PetscMin(2, K), &T3));
378: PetscCall(MatAXPY(T, 1.0, T2, SAME_NONZERO_PATTERN));
379: PetscCall(MatAXPY(T3, -1.0, T, SAME_NONZERO_PATTERN));
380: PetscCall(MatNorm(T3, NORM_FROBENIUS, &err));
381: if (err > PETSC_SMALL) {
382: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MatDenseGetSubMatrix\n"));
383: PetscCall(MatView(T3, NULL));
384: }
385: PetscCall(MatDenseRestoreSubMatrix(B, &T));
386: PetscCall(MatDenseRestoreSubMatrix(T4, &T2));
387: PetscCall(MatDenseRestoreSubMatrix(B2, &T3));
388: PetscCall(CheckLocal(B, NULL, aB, NULL));
389: PetscCall(MatDestroy(&B2));
390: PetscCall(MatDestroy(&T4));
391: }
392: }
394: /* Test reusing a previously allocated dense buffer */
395: PetscCall(MatMatMult(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
396: PetscCall(CheckLocal(B, X, aB, aX));
397: PetscCall(MatMatMultEqual(A, B, X, 10, &flg));
398: if (!flg) {
399: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage\n"));
400: PetscCall(MatMatMult(A, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
401: PetscCall(MatAXPY(T, -1.0, X, SAME_NONZERO_PATTERN));
402: PetscCall(MatView(T, NULL));
403: PetscCall(MatDestroy(&T));
404: }
406: /* Test MatTransposeMat and MatMatTranspose */
407: if (testmattmat) {
408: PetscCall(MatTransposeMatMult(A, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &B));
409: PetscCall(CheckLocal(B, X, aB, aX));
410: PetscCall(MatTransposeMatMultEqual(A, X, B, 10, &flg));
411: if (!flg) {
412: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage (MatTransposeMat)\n"));
413: PetscCall(MatTransposeMatMult(A, X, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &B));
414: PetscCall(MatAXPY(T, -1.0, B, SAME_NONZERO_PATTERN));
415: PetscCall(MatView(T, NULL));
416: PetscCall(MatDestroy(&T));
417: }
418: }
419: if (testmatmatt) {
420: PetscCall(MatMatTransposeMult(A, Bt, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
421: PetscCall(CheckLocal(Bt, X, aBt, aX));
422: PetscCall(MatMatTransposeMultEqual(A, Bt, X, 10, &flg));
423: if (!flg) {
424: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage (MatMatTranspose)\n"));
425: PetscCall(MatMatTransposeMult(A, Bt, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
426: PetscCall(MatAXPY(T, -1.0, X, SAME_NONZERO_PATTERN));
427: PetscCall(MatView(T, NULL));
428: PetscCall(MatDestroy(&T));
429: }
430: }
432: /* Test that MAT_REUSE_MATRIX uses the current values of A after they change, and uses another matrix A2 when given one */
433: if (testreusemodified) {
434: Mat E, A2;
436: PetscCall(MatTransposeMatMult(A, X, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &E));
437: PetscCall(MatScale(A, 2.0));
438: PetscCall(MatTransposeMatMult(A, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &E));
439: PetscCall(MatTransposeMatMultEqual(A, X, E, 10, &flg));
440: if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage after MatScale() (MatTransposeMat)\n"));
441: PetscCall(MatScale(A, 0.5));
442: PetscCall(MatDuplicate(A, MAT_COPY_VALUES, &A2));
443: PetscCall(MatScale(A2, 3.0));
444: PetscCall(MatTransposeMatMult(A2, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &E));
445: PetscCall(MatTransposeMatMultEqual(A2, X, E, 10, &flg));
446: if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage with another A (MatTransposeMat)\n"));
447: PetscCall(MatDestroy(&E));
448: if (testmatmatt) {
449: PetscCall(MatMatTransposeMult(A, Bt, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &E));
450: PetscCall(MatMatTransposeMult(A2, Bt, MAT_REUSE_MATRIX, PETSC_DETERMINE, &E));
451: PetscCall(MatMatTransposeMultEqual(A2, Bt, E, 10, &flg));
452: if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage with another A (MatMatTranspose)\n"));
453: PetscCall(MatDestroy(&E));
454: }
455: PetscCall(MatDestroy(&A2));
456: }
458: /* Test projection operations (PtAP and RARt) */
459: if (testproj) {
460: PetscCall(MatPtAP(A, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &PtAP));
461: PetscCall(MatPtAPMultEqual(A, B, PtAP, 10, &flg));
462: if (!flg) {
463: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with PtAP\n"));
464: PetscCall(MatMatMult(A, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
465: PetscCall(MatTransposeMatMult(B, T, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T2));
466: PetscCall(MatAXPY(T2, -1.0, PtAP, SAME_NONZERO_PATTERN));
467: PetscCall(MatView(T2, NULL));
468: PetscCall(MatDestroy(&T2));
469: PetscCall(MatDestroy(&T));
470: }
471: PetscCall(PetscMalloc1((k + ldr) * M, &dataR));
472: PetscCall(MatCreateDense(PETSC_COMM_WORLD, PETSC_DECIDE, m, K, M, dataR, &R));
473: PetscCall(MatDenseSetLDA(R, k + ldr));
474: PetscCall(MatSetRandom(R, NULL));
475: if (testrart) { /* fails for AIJCUSPARSE because RA operation is not defined */
476: PetscCall(MatRARt(A, R, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &RARt));
477: PetscCall(MatRARtMultEqual(A, R, RARt, 10, &flg));
478: if (!flg) {
479: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with RARt\n"));
480: PetscCall(MatMatTransposeMult(A, R, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
481: PetscCall(MatMatMult(R, T, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T2));
482: PetscCall(MatAXPY(T2, -1.0, RARt, SAME_NONZERO_PATTERN));
483: PetscCall(MatView(T2, NULL));
484: PetscCall(MatDestroy(&T2));
485: PetscCall(MatDestroy(&T));
486: }
487: }
488: }
490: /* Test MatDenseGetColumnVec and friends */
491: PetscCall(MatMatMult(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
492: PetscCall(MatMatMult(A, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
493: PetscCall(MatDuplicate(T, MAT_DO_NOT_COPY_VALUES, &T2));
494: for (k = 0; k < K; k++) {
495: Vec Xv, Tv, T2v;
497: PetscCall(MatDenseGetColumnVecRead(X, k, &Xv));
498: PetscCall(MatDenseGetColumnVec(T, k, &Tv));
499: PetscCall(MatDenseGetColumnVecWrite(T2, k, &T2v));
500: PetscCall(VecCopy(Xv, T2v));
501: PetscCall(VecAXPY(Tv, -1., Xv));
502: PetscCall(MatDenseRestoreColumnVecRead(X, k, &Xv));
503: PetscCall(MatDenseRestoreColumnVec(T, k, &Tv));
504: PetscCall(MatDenseRestoreColumnVecWrite(T2, k, &T2v));
505: }
506: PetscCall(MatNorm(T, NORM_FROBENIUS, &err));
507: if (err > PETSC_SMALL) {
508: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MatDenseGetColumnVec\n"));
509: PetscCall(MatView(T, NULL));
510: }
511: PetscCall(MatAXPY(T2, -1., X, SAME_NONZERO_PATTERN));
512: PetscCall(MatNorm(T2, NORM_FROBENIUS, &err));
513: if (err > PETSC_SMALL) {
514: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MatDenseGetColumnVecWrite\n"));
515: PetscCall(MatView(T2, NULL));
516: }
517: PetscCall(MatDestroy(&T));
518: PetscCall(MatDestroy(&T2));
520: /* Test with MatShell */
521: PetscCall(MatDuplicate(A, MAT_COPY_VALUES, &T));
522: PetscCall(MatConvert(T, MATSHELL, MAT_INITIAL_MATRIX, &T2));
523: PetscCall(MatDestroy(&T));
525: /* scale matrix */
526: PetscCall(MatScale(A, 2.0));
527: PetscCall(MatScale(T2, 2.0));
528: PetscCall(MatCreateVecs(A, &r, &l));
529: PetscCall(VecSetRandom(r, NULL));
530: PetscCall(VecSetRandom(l, NULL));
531: PetscCall(MatCreateVecs(T2, &rs, &ls));
532: PetscCall(VecCopy(r, rs));
533: PetscCall(VecCopy(l, ls));
534: if (testproj) {
535: PetscCall(MatDiagonalScale(A, r, r));
536: PetscCall(MatDiagonalScale(T2, rs, rs));
537: } else {
538: PetscCall(MatDiagonalScale(A, l, r));
539: PetscCall(MatDiagonalScale(T2, ls, rs));
540: }
541: PetscCall(MatDuplicate(A, MAT_COPY_VALUES, &T));
542: PetscCall(MatAXPY(A, 4.5, T, SAME_NONZERO_PATTERN));
543: PetscCall(MatAXPY(T2, 4.5, T, DIFFERENT_NONZERO_PATTERN));
544: PetscCall(MatMultEqual(T2, A, 10, &flg));
545: if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MATSHELL (MatMult)\n"));
546: PetscCall(MatMultTransposeEqual(T2, A, 10, &flg));
547: if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MATSHELL (MatMultTranspose)\n"));
548: PetscCall(MatDestroy(&T));
549: PetscCall(VecDestroy(&ls));
550: PetscCall(VecDestroy(&rs));
551: PetscCall(VecDestroy(&l));
552: PetscCall(VecDestroy(&r));
554: /* recompute projections, test reusage */
555: if (PtAP) PetscCall(MatPtAP(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &PtAP));
556: if (RARt) PetscCall(MatRARt(A, R, MAT_REUSE_MATRIX, PETSC_DETERMINE, &RARt));
557: if (testshellops) { /* test callbacks for user defined MatProducts */
558: PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_AB, NULL, MyMatShellMatMultNumeric, NULL, MATDENSE, MATDENSE));
559: PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_AB, NULL, MyMatShellMatMultNumeric, NULL, MATDENSECUDA, MATDENSECUDA));
560: PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_AtB, NULL, MyMatTransposeShellMatMultNumeric, NULL, MATDENSE, MATDENSE));
561: PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_AtB, NULL, MyMatTransposeShellMatMultNumeric, NULL, MATDENSECUDA, MATDENSECUDA));
562: PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_ABt, NULL, MyMatShellMatTransposeMultNumeric, NULL, MATDENSE, MATDENSE));
563: PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_ABt, NULL, MyMatShellMatTransposeMultNumeric, NULL, MATDENSECUDA, MATDENSECUDA));
564: if (testproj) {
565: PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_PtAP, MyPtShellPMultSymbolic, MyPtShellPMultNumeric, proj_destroy, MATDENSE, MATSHELL));
566: PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_PtAP, MyPtShellPMultSymbolic, MyPtShellPMultNumeric, proj_destroy, MATDENSECUDA, MATSHELL));
567: PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_RARt, MyRShellRtMultSymbolic, MyRShellRtMultNumeric, proj_destroy, MATDENSE, MATSHELL));
568: PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_RARt, MyRShellRtMultSymbolic, MyRShellRtMultNumeric, proj_destroy, MATDENSECUDA, MATSHELL));
569: }
570: }
571: PetscCall(CheckLocal(B, X, aB, aX));
572: /* we either use the shell operations or the loop over columns code, applying the operator */
573: PetscCall(MatMatMult(T2, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
574: PetscCall(CheckLocal(B, X, aB, aX));
575: PetscCall(MatMatMultEqual(T2, B, X, 10, &flg));
576: if (!flg) {
577: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage (MATSHELL)\n"));
578: PetscCall(MatMatMult(A, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
579: PetscCall(MatAXPY(T, -1.0, X, SAME_NONZERO_PATTERN));
580: PetscCall(MatView(T, NULL));
581: PetscCall(MatDestroy(&T));
582: }
583: if (testproj) {
584: PetscCall(MatPtAPMultEqual(T2, B, PtAP, 10, &flg));
585: if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with PtAP (MATSHELL)\n"));
586: if (testshellops) { /* projections fail if the product operations are not specified */
587: PetscCall(MatPtAP(T2, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
588: PetscCall(MatPtAP(T2, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &T));
589: PetscCall(MatPtAPMultEqual(T2, B, T, 10, &flg));
590: if (!flg) {
591: Mat TE;
593: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with PtAP (MATSHELL user defined)\n"));
594: PetscCall(MatComputeOperator(T, MATDENSE, &TE));
595: PetscCall(MatView(TE, NULL));
596: PetscCall(MatView(PtAP, NULL));
597: PetscCall(MatAXPY(TE, -1.0, PtAP, SAME_NONZERO_PATTERN));
598: PetscCall(MatView(TE, NULL));
599: PetscCall(MatDestroy(&TE));
600: }
601: PetscCall(MatDestroy(&T));
602: }
603: if (RARt) {
604: PetscCall(MatRARtMultEqual(T2, R, RARt, 10, &flg));
605: if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with RARt (MATSHELL)\n"));
606: }
607: if (testshellops) {
608: PetscCall(MatRARt(T2, R, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
609: PetscCall(MatRARt(T2, R, MAT_REUSE_MATRIX, PETSC_DETERMINE, &T));
610: PetscCall(MatRARtMultEqual(T2, R, T, 10, &flg));
611: if (!flg) {
612: Mat TE;
614: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with RARt (MATSHELL user defined)\n"));
615: PetscCall(MatComputeOperator(T, MATDENSE, &TE));
616: PetscCall(MatView(TE, NULL));
617: if (RARt) {
618: PetscCall(MatView(RARt, NULL));
619: PetscCall(MatAXPY(TE, -1.0, RARt, SAME_NONZERO_PATTERN));
620: PetscCall(MatView(TE, NULL));
621: }
622: PetscCall(MatDestroy(&TE));
623: }
624: PetscCall(MatDestroy(&T));
625: }
626: }
628: if (testmattmat) { /* we either use the shell operations or the loop over columns code applying the transposed operator */
629: PetscCall(MatTransposeMatMult(T2, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &B));
630: PetscCall(CheckLocal(B, X, aB, aX));
631: PetscCall(MatTransposeMatMultEqual(T2, X, B, 10, &flg));
632: if (!flg) {
633: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage (MatTranspose, MATSHELL)\n"));
634: PetscCall(MatTransposeMatMult(A, X, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
635: PetscCall(MatAXPY(T, -1.0, B, SAME_NONZERO_PATTERN));
636: PetscCall(MatView(T, NULL));
637: PetscCall(MatDestroy(&T));
638: }
639: }
640: if (testmatmatt && testshellops) { /* only when shell operations are set */
641: PetscCall(MatMatTransposeMult(T2, Bt, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
642: PetscCall(CheckLocal(Bt, X, aBt, aX));
643: PetscCall(MatMatTransposeMultEqual(T2, Bt, X, 10, &flg));
644: if (!flg) {
645: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage (MatMatTranspose, MATSHELL)\n"));
646: PetscCall(MatMatTransposeMult(A, Bt, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
647: PetscCall(MatAXPY(T, -1.0, X, SAME_NONZERO_PATTERN));
648: PetscCall(MatView(T, NULL));
649: PetscCall(MatDestroy(&T));
650: }
651: }
652: PetscCall(MatDestroy(&T2));
654: if (testnest) { /* test with MatNest */
655: Mat NA;
657: PetscCall(MatCreateNest(PETSC_COMM_WORLD, 1, NULL, 1, NULL, &A, &NA));
658: PetscCall(MatViewFromOptions(NA, NULL, "-NA_view"));
659: PetscCall(MatMatMult(NA, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
660: PetscCall(CheckLocal(B, X, aB, aX));
661: PetscCall(MatMatMultEqual(NA, B, X, 10, &flg));
662: if (!flg) {
663: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with Nest\n"));
664: PetscCall(MatMatMult(NA, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
665: PetscCall(MatAXPY(T, -1.0, X, SAME_NONZERO_PATTERN));
666: PetscCall(MatView(T, NULL));
667: PetscCall(MatDestroy(&T));
668: }
669: PetscCall(MatDestroy(&NA));
670: }
672: if (testtranspose) { /* test with Transpose */
673: Mat TA;
675: PetscCall(MatCreateTranspose(A, &TA));
676: PetscCall(MatMatMult(TA, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &B));
677: PetscCall(CheckLocal(B, X, aB, aX));
678: PetscCall(MatMatMultEqual(TA, X, B, 10, &flg));
679: if (!flg) {
680: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with Transpose\n"));
681: PetscCall(MatMatMult(TA, X, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
682: PetscCall(MatAXPY(T, -1.0, B, SAME_NONZERO_PATTERN));
683: PetscCall(MatView(T, NULL));
684: PetscCall(MatDestroy(&T));
685: }
686: PetscCall(MatDestroy(&TA));
687: }
689: if (testhtranspose) { /* test with Hermitian Transpose */
690: Mat TA;
692: PetscCall(MatCreateHermitianTranspose(A, &TA));
693: PetscCall(MatMatMult(TA, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &B));
694: PetscCall(CheckLocal(B, X, aB, aX));
695: PetscCall(MatMatMultEqual(TA, X, B, 10, &flg));
696: if (!flg) {
697: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with Transpose\n"));
698: PetscCall(MatMatMult(TA, X, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
699: PetscCall(MatAXPY(T, -1.0, B, SAME_NONZERO_PATTERN));
700: PetscCall(MatView(T, NULL));
701: PetscCall(MatDestroy(&T));
702: }
703: PetscCall(MatDestroy(&TA));
704: }
706: if (testtt) { /* test with Transpose(Transpose) */
707: Mat TA, TTA;
709: PetscCall(MatCreateTranspose(A, &TA));
710: PetscCall(MatCreateTranspose(TA, &TTA));
711: PetscCall(MatMatMult(TTA, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
712: PetscCall(CheckLocal(B, X, aB, aX));
713: PetscCall(MatMatMultEqual(TTA, B, X, 10, &flg));
714: if (!flg) {
715: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with Transpose(Transpose)\n"));
716: PetscCall(MatMatMult(TTA, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
717: PetscCall(MatAXPY(T, -1.0, X, SAME_NONZERO_PATTERN));
718: PetscCall(MatView(T, NULL));
719: PetscCall(MatDestroy(&T));
720: }
721: PetscCall(MatDestroy(&TA));
722: PetscCall(MatDestroy(&TTA));
723: }
725: if (testcircular) { /* test circular */
726: Mat AB;
728: PetscCall(MatMatMult(A, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &AB));
729: PetscCall(MatMatMult(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
730: PetscCall(CheckLocal(B, X, aB, aX));
731: if (M == N && N == K) PetscCall(MatMatMult(A, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &B));
732: else PetscCall(MatTransposeMatMult(A, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &B));
733: PetscCall(CheckLocal(B, X, aB, aX));
734: PetscCall(MatDestroy(&AB));
735: }
737: /* Test by Pierre Jolivet */
738: {
739: Mat C, D, D2, AtA;
740: PetscCall(MatCreateNormal(A, &AtA));
741: PetscCall(MatDuplicate(X, MAT_DO_NOT_COPY_VALUES, &C));
742: PetscCall(MatDuplicate(B, MAT_DO_NOT_COPY_VALUES, &D));
743: PetscCall(MatDuplicate(B, MAT_DO_NOT_COPY_VALUES, &D2));
744: PetscCall(MatSetRandom(B, NULL));
745: PetscCall(MatSetRandom(C, NULL));
746: PetscCall(MatSetRandom(D, NULL));
747: PetscCall(MatSetRandom(D2, NULL));
748: PetscCall(MatProductCreateWithMat(A, B, NULL, C));
749: PetscCall(MatProductSetType(C, MATPRODUCT_AB));
750: PetscCall(MatProductSetFromOptions(C));
751: PetscCall(MatProductSymbolic(C));
752: PetscCall(MatProductCreateWithMat(A, C, NULL, D));
753: PetscCall(MatProductSetType(D, MATPRODUCT_AtB));
754: PetscCall(MatProductSetFromOptions(D));
755: PetscCall(MatProductSymbolic(D));
756: PetscCall(MatProductNumeric(C));
757: PetscCall(MatMatMultEqual(A, B, C, 10, &flg));
758: if (!flg) {
759: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with Normal (AB != C)\n"));
760: PetscCall(MatView(A, NULL));
761: PetscCall(MatView(B, NULL));
762: PetscCall(MatView(C, NULL));
763: }
764: PetscCall(MatProductNumeric(D));
765: PetscCall(MatMatMultEqual(AtA, B, D, 10, &flg));
766: if (!flg) {
767: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with Normal (2)\n"));
768: PetscCall(MatMatMult(AtA, C, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
769: PetscCall(MatView(D, NULL));
770: PetscCall(MatView(T, NULL));
771: PetscCall(MatAXPY(T, -1.0, D, SAME_NONZERO_PATTERN));
772: PetscCall(MatView(T, NULL));
773: PetscCall(MatDestroy(&T));
774: }
775: PetscCall(MatDestroy(&C));
776: PetscCall(MatDestroy(&D));
777: PetscCall(MatDestroy(&D2));
778: PetscCall(MatDestroy(&AtA));
779: }
781: PetscCall(MatDestroy(&X));
782: PetscCall(MatDestroy(&Bt));
783: PetscCall(MatDestroy(&B));
784: PetscCall(MatDestroy(&A));
785: PetscCall(MatDestroy(&R));
786: PetscCall(MatDestroy(&PtAP));
787: PetscCall(MatDestroy(&RARt));
788: PetscCall(PetscFree(dataX));
789: PetscCall(PetscFree(dataB));
790: PetscCall(PetscFree(dataR));
791: PetscCall(PetscFree(dataBt));
792: PetscCall(PetscFinalize());
793: return 0;
794: }
796: /*TEST
798: test:
799: output_file: output/empty.out
800: suffix: 1
801: args: -local {{0 1}} -testshellops
803: test:
804: output_file: output/empty.out
805: requires: cuda
806: suffix: 1_cuda
807: args: -local {{0 1}} -xgpu {{0 1}} -bgpu {{0 1}} -A_mat_type {{seqaijcusparse seqaij}} -testshellops {{0 1}}
809: # RARt is skipped for aijkokkos because the R*A products with a dense R it needs are not defined
810: # -xgpu and -bgpu are not used with aijkokkos because the checks in MatMatMultEqual() and friends cannot
811: # copy between the VECCUDA of a MATDENSECUDA operand and the VECKOKKOS of an aijkokkos matrix
812: test:
813: output_file: output/empty.out
814: requires: kokkos_kernels
815: suffix: 1_kokkos
816: args: -local {{0 1}} -A_mat_type aijkokkos -testrart 0 -A_form_explicit_transpose {{0 1}}
818: test:
819: output_file: output/empty.out
820: nsize: 2
821: suffix: 1_par
822: args: -local {{0 1}} -testmatmatt 0
824: test:
825: output_file: output/empty.out
826: nsize: 2
827: requires: kokkos_kernels
828: suffix: 1_par_kokkos
829: args: -local {{0 1}} -testmatmatt 0 -A_mat_type aijkokkos -testrart 0
831: test:
832: output_file: output/empty.out
833: suffix: 1_reuse
834: args: -testreusemodified
836: test:
837: output_file: output/empty.out
838: nsize: 2
839: suffix: 1_par_reuse
840: args: -testmatmatt 0 -testreusemodified
842: test:
843: output_file: output/empty.out
844: nsize: 2
845: requires: kokkos_kernels
846: suffix: 1_par_kokkos_reuse
847: args: -testmatmatt 0 -A_mat_type aijkokkos -testrart 0 -testreusemodified
849: test:
850: output_file: output/empty.out
851: nsize: 2
852: requires: cuda
853: suffix: 1_par_cuda_reuse
854: args: -testnest 0 -testmatmatt 0 -matproduct_batch_size 3 -A_mat_type mpiaijcusparse -testreusemodified
856: test:
857: output_file: output/empty.out
858: requires: cuda
859: nsize: 2
860: suffix: 1_par_cuda
861: args: -local {{0 1}} -xgpu {{0 1}} -bgpu {{0 1}} -A_mat_type {{mpiaijcusparse mpiaij}} -testnest 0 -testmatmatt 0 -matproduct_batch_size 3
863: test:
864: output_file: output/empty.out
865: suffix: 2
866: nsize: 1
867: args: -M {{7 11}} -N {{12 9}} -K {{1 3}} -local {{0 1}}
869: testset:
870: requires: cuda
871: output_file: output/empty.out
872: nsize: 1
873: args: -M 7 -N 9 -K 2 -local {{0 1}} -testnest 0 -A_mat_type {{seqdensecuda seqdense}} -xgpu {{0 1}} -bgpu {{0 1}}
874: test:
875: requires: !complex
876: suffix: 2_cuda_real
877: test:
878: # complex+single gives a little bigger error in the MatDenseGetColumnVec test
879: requires: complex !single
880: suffix: 2_cuda_complex
882: test:
883: output_file: output/empty.out
884: suffix: 2_par
885: nsize: 2
886: args: -M {{7 11}} -N {{12 9}} -K {{1 3}} -local {{0 1}} -testcircular -testmatmatt 0
888: test:
889: requires: cuda
890: output_file: output/empty.out
891: suffix: 2_par_cuda
892: nsize: 2
893: args: -M 11 -N 9 -K 1 -local {{0 1}} -testcircular 0 -A_mat_type mpiaijcusparse -xgpu -bgpu -testnest 0 -testmatmatt 0
895: test:
896: output_file: output/empty.out
897: suffix: 3
898: nsize: {{1 3}}
899: args: -M 13 -N 13 -K {{1 3}} -local {{0 1}} -A_mat_type sbaij -symm -testproj 0 -testmatmatt 0
901: test:
902: output_file: output/empty.out
903: suffix: 4
904: nsize: 1
905: args: -M 3 -N 3 -K 3 -local {{0 1}} -testcircular
907: test:
908: output_file: output/empty.out
909: suffix: 5
910: nsize: {{2 4}}
911: args: -M 3 -N 3 -K 3 -local {{0 1}} -testcircular -testmatmatt 0
913: test:
914: output_file: output/empty.out
915: suffix: 6
916: nsize: 1
917: args: -M {{1 3}} -N {{2 5}} -K {{1 2}} -local {{0 1}} -testcircular
919: test:
920: output_file: output/empty.out
921: suffix: 7
922: nsize: 1
923: args: -M 13 -N 13 -K {{1 3}} -local {{0 1}} -A_mat_type dense -testnest -testcircular
925: TEST*/