Actual source code: ex62.c


  2: static char help[] = "Test Matrix products for AIJ matrices\n\
  3: Input arguments are:\n\
  4:   -fA <input_file> -fB <input_file> -fC <input_file>: file to load\n\n";
  5: /* Example of usage:
  6:    ./ex62 -fA <A_binary> -fB <B_binary>
  7:    mpiexec -n 3 ./ex62 -fA medium -fB medium
  8: */

 10: #include <petscmat.h>

 12: /*
 13:      B = A - B
 14:      norm = norm(B)
 15: */
 16: PetscErrorCode MatNormDifference(Mat A, Mat B, PetscReal *norm)
 17: {
 18:   MatAXPY(B, -1.0, A, DIFFERENT_NONZERO_PATTERN);
 19:   MatNorm(B, NORM_FROBENIUS, norm);
 20:   return 0;
 21: }

 23: int main(int argc, char **args)
 24: {
 25:   Mat          A, A_save, B, C, P, C1, R;
 26:   PetscViewer  viewer;
 27:   PetscMPIInt  size, rank;
 28:   PetscInt     i, j, *idxn, PM, PN = PETSC_DECIDE, rstart, rend;
 29:   PetscReal    norm;
 30:   PetscRandom  rdm;
 31:   char         file[2][PETSC_MAX_PATH_LEN] = {"", ""};
 32:   PetscScalar *a, rval, alpha;
 33:   PetscBool    Test_MatMatMult = PETSC_TRUE, Test_MatTrMat = PETSC_TRUE, Test_MatMatTr = PETSC_TRUE;
 34:   PetscBool    Test_MatPtAP = PETSC_TRUE, Test_MatRARt = PETSC_TRUE, flg, seqaij, flgA, flgB;
 35:   MatInfo      info;
 36:   PetscInt     nzp = 5; /* num of nonzeros in each row of P */
 37:   MatType      mattype;
 38:   const char  *deft = MATAIJ;
 39:   char         A_mattype[256], B_mattype[256];
 40:   PetscInt     mcheck = 10;

 43:   PetscInitialize(&argc, &args, (char *)0, help);
 44:   MPI_Comm_size(PETSC_COMM_WORLD, &size);
 45:   MPI_Comm_rank(PETSC_COMM_WORLD, &rank);

 47:   /*  Load the matrices A_save and B */
 48:   PetscOptionsBegin(PETSC_COMM_WORLD, "", "", "");
 49:   PetscOptionsBool("-test_rart", "Test MatRARt", "", Test_MatRARt, &Test_MatRARt, NULL);
 50:   PetscOptionsInt("-PN", "Number of columns of P", "", PN, &PN, NULL);
 51:   PetscOptionsInt("-mcheck", "Number of matmult checks", "", mcheck, &mcheck, NULL);
 52:   PetscOptionsString("-fA", "Path for matrix A", "", file[0], file[0], sizeof(file[0]), &flg);
 54:   PetscOptionsString("-fB", "Path for matrix B", "", file[1], file[1], sizeof(file[1]), &flg);
 55:   PetscOptionsFList("-A_mat_type", "Matrix type", "MatSetType", MatList, deft, A_mattype, 256, &flgA);
 56:   PetscOptionsFList("-B_mat_type", "Matrix type", "MatSetType", MatList, deft, B_mattype, 256, &flgB);
 57:   PetscOptionsEnd();

 59:   PetscViewerBinaryOpen(PETSC_COMM_WORLD, file[0], FILE_MODE_READ, &viewer);
 60:   MatCreate(PETSC_COMM_WORLD, &A_save);
 61:   MatLoad(A_save, viewer);
 62:   PetscViewerDestroy(&viewer);

 64:   if (flg) {
 65:     PetscViewerBinaryOpen(PETSC_COMM_WORLD, file[1], FILE_MODE_READ, &viewer);
 66:     MatCreate(PETSC_COMM_WORLD, &B);
 67:     MatLoad(B, viewer);
 68:     PetscViewerDestroy(&viewer);
 69:   } else {
 70:     PetscObjectReference((PetscObject)A_save);
 71:     B = A_save;
 72:   }

 74:   if (flgA) MatConvert(A_save, A_mattype, MAT_INPLACE_MATRIX, &A_save);
 75:   if (flgB) MatConvert(B, B_mattype, MAT_INPLACE_MATRIX, &B);
 76:   MatSetFromOptions(A_save);
 77:   MatSetFromOptions(B);

 79:   MatGetType(B, &mattype);

 81:   PetscMalloc(nzp * (sizeof(PetscInt) + sizeof(PetscScalar)), &idxn);
 82:   a = (PetscScalar *)(idxn + nzp);

 84:   PetscRandomCreate(PETSC_COMM_WORLD, &rdm);
 85:   PetscRandomSetFromOptions(rdm);

 87:   /* 1) MatMatMult() */
 88:   /* ----------------*/
 89:   if (Test_MatMatMult) {
 90:     MatDuplicate(A_save, MAT_COPY_VALUES, &A);

 92:     /* (1.1) Test developer API */
 93:     MatProductCreate(A, B, NULL, &C);
 94:     MatSetOptionsPrefix(C, "AB_");
 95:     MatProductSetType(C, MATPRODUCT_AB);
 96:     MatProductSetAlgorithm(C, MATPRODUCTALGORITHMDEFAULT);
 97:     MatProductSetFill(C, PETSC_DEFAULT);
 98:     MatProductSetFromOptions(C);
 99:     /* we can inquire about MATOP_PRODUCTSYMBOLIC even if the destination matrix type has not been set yet */
100:     MatHasOperation(C, MATOP_PRODUCTSYMBOLIC, &flg);
101:     MatProductSymbolic(C);
102:     MatProductNumeric(C);
103:     MatMatMultEqual(A, B, C, mcheck, &flg);

106:     /* Test reuse symbolic C */
107:     alpha = 0.9;
108:     MatScale(A, alpha);
109:     MatProductNumeric(C);

111:     MatMatMultEqual(A, B, C, mcheck, &flg);
113:     MatDestroy(&C);

115:     /* (1.2) Test user driver */
116:     MatMatMult(A, B, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &C);

118:     /* Test MAT_REUSE_MATRIX - reuse symbolic C */
119:     alpha = 1.0;
120:     for (i = 0; i < 2; i++) {
121:       alpha -= 0.1;
122:       MatScale(A, alpha);
123:       MatMatMult(A, B, MAT_REUSE_MATRIX, PETSC_DEFAULT, &C);
124:     }
125:     MatMatMultEqual(A, B, C, mcheck, &flg);
127:     MatDestroy(&A);

129:     /* Test MatProductClear() */
130:     MatProductClear(C);
131:     MatDestroy(&C);

133:     /* Test MatMatMult() for dense and aij matrices */
134:     PetscObjectTypeCompareAny((PetscObject)A, &flg, MATSEQAIJ, MATMPIAIJ, "");
135:     if (flg) {
136:       MatConvert(A_save, MATDENSE, MAT_INITIAL_MATRIX, &A);
137:       MatMatMult(A, B, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &C);
138:       MatDestroy(&C);
139:       MatDestroy(&A);
140:     }
141:   }

143:   /* Create P and R = P^T  */
144:   /* --------------------- */
145:   MatGetSize(B, &PM, NULL);
146:   if (PN < 0) PN = PM / 2;
147:   MatCreate(PETSC_COMM_WORLD, &P);
148:   MatSetSizes(P, PETSC_DECIDE, PETSC_DECIDE, PM, PN);
149:   MatSetType(P, MATAIJ);
150:   MatSeqAIJSetPreallocation(P, nzp, NULL);
151:   MatMPIAIJSetPreallocation(P, nzp, NULL, nzp, NULL);
152:   MatGetOwnershipRange(P, &rstart, &rend);
153:   for (i = 0; i < nzp; i++) PetscRandomGetValue(rdm, &a[i]);
154:   for (i = rstart; i < rend; i++) {
155:     for (j = 0; j < nzp; j++) {
156:       PetscRandomGetValue(rdm, &rval);
157:       idxn[j] = (PetscInt)(PetscRealPart(rval) * PN);
158:     }
159:     MatSetValues(P, 1, &i, nzp, idxn, a, ADD_VALUES);
160:   }
161:   MatAssemblyBegin(P, MAT_FINAL_ASSEMBLY);
162:   MatAssemblyEnd(P, MAT_FINAL_ASSEMBLY);

164:   MatTranspose(P, MAT_INITIAL_MATRIX, &R);
165:   MatConvert(P, mattype, MAT_INPLACE_MATRIX, &P);
166:   MatConvert(R, mattype, MAT_INPLACE_MATRIX, &R);
167:   MatSetFromOptions(P);
168:   MatSetFromOptions(R);

170:   /* 2) MatTransposeMatMult() */
171:   /* ------------------------ */
172:   if (Test_MatTrMat) {
173:     /* (2.1) Test developer driver C = P^T*B */
174:     MatProductCreate(P, B, NULL, &C);
175:     MatSetOptionsPrefix(C, "AtB_");
176:     MatProductSetType(C, MATPRODUCT_AtB);
177:     MatProductSetAlgorithm(C, MATPRODUCTALGORITHMDEFAULT);
178:     MatProductSetFill(C, PETSC_DEFAULT);
179:     MatProductSetFromOptions(C);
180:     MatHasOperation(C, MATOP_PRODUCTSYMBOLIC, &flg);
181:     if (flg) {                                                 /* run tests if supported */
182:       MatProductSymbolic(C);                        /* equivalent to MatSetUp() */
183:       MatSetOption(C, MAT_USE_INODES, PETSC_FALSE); /* illustrate how to call MatSetOption() */
184:       MatProductNumeric(C);
185:       MatProductNumeric(C); /* test reuse symbolic C */

187:       MatTransposeMatMultEqual(P, B, C, mcheck, &flg);
189:       MatDestroy(&C);

191:       /* (2.2) Test user driver C = P^T*B */
192:       MatTransposeMatMult(P, B, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &C);
193:       MatTransposeMatMult(P, B, MAT_REUSE_MATRIX, PETSC_DEFAULT, &C);
194:       MatGetInfo(C, MAT_GLOBAL_SUM, &info);
195:       MatProductClear(C);

197:       /* Compare P^T*B and R*B */
198:       MatMatMult(R, B, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &C1);
199:       MatNormDifference(C, C1, &norm);
201:       MatDestroy(&C1);

203:       /* Test MatDuplicate() of C=P^T*B */
204:       MatDuplicate(C, MAT_COPY_VALUES, &C1);
205:       MatDestroy(&C1);
206:     } else {
207:       PetscPrintf(PETSC_COMM_WORLD, "MatTransposeMatMult not supported\n");
208:     }
209:     MatDestroy(&C);
210:   }

212:   /* 3) MatMatTransposeMult() */
213:   /* ------------------------ */
214:   if (Test_MatMatTr) {
215:     /* C = B*R^T */
216:     PetscObjectBaseTypeCompare((PetscObject)B, MATSEQAIJ, &seqaij);
217:     if (seqaij) {
218:       MatMatTransposeMult(B, R, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &C);
219:       MatSetOptionsPrefix(C, "ABt_"); /* enable '-ABt_' for matrix C */
220:       MatGetInfo(C, MAT_GLOBAL_SUM, &info);

222:       /* Test MAT_REUSE_MATRIX - reuse symbolic C */
223:       MatMatTransposeMult(B, R, MAT_REUSE_MATRIX, PETSC_DEFAULT, &C);

225:       /* Check */
226:       MatMatMult(B, P, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &C1);
227:       MatNormDifference(C, C1, &norm);
229:       MatDestroy(&C1);
230:       MatDestroy(&C);
231:     }
232:   }

234:   /* 4) Test MatPtAP() */
235:   /*-------------------*/
236:   if (Test_MatPtAP) {
237:     MatDuplicate(A_save, MAT_COPY_VALUES, &A);

239:     /* (4.1) Test developer API */
240:     MatProductCreate(A, P, NULL, &C);
241:     MatSetOptionsPrefix(C, "PtAP_");
242:     MatProductSetType(C, MATPRODUCT_PtAP);
243:     MatProductSetAlgorithm(C, MATPRODUCTALGORITHMDEFAULT);
244:     MatProductSetFill(C, PETSC_DEFAULT);
245:     MatProductSetFromOptions(C);
246:     MatProductSymbolic(C);
247:     MatProductNumeric(C);
248:     MatPtAPMultEqual(A, P, C, mcheck, &flg);
250:     MatProductNumeric(C); /* reuse symbolic C */

252:     MatPtAPMultEqual(A, P, C, mcheck, &flg);
254:     MatDestroy(&C);

256:     /* (4.2) Test user driver */
257:     MatPtAP(A, P, MAT_INITIAL_MATRIX, PETSC_DEFAULT, &C);

259:     /* Test MAT_REUSE_MATRIX - reuse symbolic C */
260:     alpha = 1.0;
261:     for (i = 0; i < 2; i++) {
262:       alpha -= 0.1;
263:       MatScale(A, alpha);
264:       MatPtAP(A, P, MAT_REUSE_MATRIX, PETSC_DEFAULT, &C);
265:     }
266:     MatPtAPMultEqual(A, P, C, mcheck, &flg);

269:     /* 5) Test MatRARt() */
270:     /* ----------------- */
271:     if (Test_MatRARt) {
272:       Mat RARt;

274:       /* (5.1) Test developer driver RARt = R*A*Rt */
275:       MatProductCreate(A, R, NULL, &RARt);
276:       MatSetOptionsPrefix(RARt, "RARt_");
277:       MatProductSetType(RARt, MATPRODUCT_RARt);
278:       MatProductSetAlgorithm(RARt, MATPRODUCTALGORITHMDEFAULT);
279:       MatProductSetFill(RARt, PETSC_DEFAULT);
280:       MatProductSetFromOptions(RARt);
281:       MatHasOperation(RARt, MATOP_PRODUCTSYMBOLIC, &flg);
282:       if (flg) {
283:         MatProductSymbolic(RARt);                        /* equivalent to MatSetUp() */
284:         MatSetOption(RARt, MAT_USE_INODES, PETSC_FALSE); /* illustrate how to call MatSetOption() */
285:         MatProductNumeric(RARt);
286:         MatProductNumeric(RARt); /* test reuse symbolic RARt */
287:         MatDestroy(&RARt);

289:         /* (2.2) Test user driver RARt = R*A*Rt */
290:         MatRARt(A, R, MAT_INITIAL_MATRIX, 2.0, &RARt);
291:         MatRARt(A, R, MAT_REUSE_MATRIX, 2.0, &RARt);

293:         MatNormDifference(C, RARt, &norm);
295:       } else {
296:         PetscPrintf(PETSC_COMM_WORLD, "MatRARt not supported\n");
297:       }
298:       MatDestroy(&RARt);
299:     }

301:     MatDestroy(&A);
302:     MatDestroy(&C);
303:   }

305:   /* Destroy objects */
306:   PetscRandomDestroy(&rdm);
307:   PetscFree(idxn);

309:   MatDestroy(&A_save);
310:   MatDestroy(&B);
311:   MatDestroy(&P);
312:   MatDestroy(&R);

314:   PetscFinalize();
315:   return 0;
316: }

318: /*TEST
319:    test:
320:      suffix: 1
321:      requires: datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
322:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium
323:      output_file: output/ex62_1.out

325:    test:
326:      suffix: 2_ab_scalable
327:      requires: datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
328:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium -AB_mat_product_algorithm scalable -matmatmult_via scalable -AtB_mat_product_algorithm outerproduct -mattransposematmult_via outerproduct
329:      output_file: output/ex62_1.out

331:    test:
332:      suffix: 3_ab_scalable_fast
333:      requires: datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
334:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium -AB_mat_product_algorithm scalable_fast -matmatmult_via scalable_fast -matmattransmult_via color
335:      output_file: output/ex62_1.out

337:    test:
338:      suffix: 4_ab_heap
339:      requires: datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
340:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium -AB_mat_product_algorithm heap -matmatmult_via heap -PtAP_mat_product_algorithm rap -matptap_via rap
341:      output_file: output/ex62_1.out

343:    test:
344:      suffix: 5_ab_btheap
345:      requires: datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
346:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium -AB_mat_product_algorithm btheap -matmatmult_via btheap -matrart_via r*art
347:      output_file: output/ex62_1.out

349:    test:
350:      suffix: 6_ab_llcondensed
351:      requires: datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
352:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium -AB_mat_product_algorithm llcondensed -matmatmult_via llcondensed -matrart_via coloring_rart
353:      output_file: output/ex62_1.out

355:    test:
356:      suffix: 7_ab_rowmerge
357:      requires: datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
358:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium -AB_mat_product_algorithm rowmerge -matmatmult_via rowmerge
359:      output_file: output/ex62_1.out

361:    test:
362:      suffix: 8_ab_hypre
363:      requires: hypre datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
364:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium -AB_mat_product_algorithm hypre -matmatmult_via hypre -PtAP_mat_product_algorithm hypre -matptap_via hypre
365:      output_file: output/ex62_1.out

367:    test:
368:      suffix: hypre_medium
369:      nsize: {{1 3}}
370:      requires: hypre datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
371:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium -A_mat_type hypre -B_mat_type hypre -test_rart 0
372:      output_file: output/ex62_hypre.out

374:    test:
375:      suffix: hypre_tiny
376:      nsize: {{1 3}}
377:      requires: hypre !complex double !defined(PETSC_USE_64BIT_INDICES)
378:      args: -fA ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system -fB ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system -A_mat_type hypre -B_mat_type hypre -test_rart 0
379:      output_file: output/ex62_hypre.out

381:    test:
382:      suffix: 9_mkl
383:      TODO: broken MatScale?
384:      requires: mkl_sparse datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
385:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium -A_mat_type aijmkl -B_mat_type aijmkl
386:      output_file: output/ex62_1.out

388:    test:
389:      suffix: 10
390:      requires: datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
391:      nsize: 3
392:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium
393:      output_file: output/ex62_1.out

395:    test:
396:      suffix: 10_backend
397:      requires: datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
398:      nsize: 3
399:      args: -fA ${DATAFILESPATH}/matrices/medium -AB_mat_product_algorithm backend -matmatmult_via backend -AtB_mat_product_algorithm backend -mattransposematmult_via backend -PtAP_mat_product_algorithm backend -matptap_via backend
400:      output_file: output/ex62_1.out

402:    test:
403:      suffix: 11_ab_scalable
404:      requires: datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
405:      nsize: 3
406:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium -AB_mat_product_algorithm scalable -matmatmult_via scalable -AtB_mat_product_algorithm scalable -mattransposematmult_via scalable
407:      output_file: output/ex62_1.out

409:    test:
410:      suffix: 12_ab_seqmpi
411:      requires: datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
412:      nsize: 3
413:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium -AB_mat_product_algorithm seqmpi -matmatmult_via seqmpi -AtB_mat_product_algorithm at*b -mattransposematmult_via at*b
414:      output_file: output/ex62_1.out

416:    test:
417:      suffix: 13_ab_hypre
418:      requires: hypre datafilespath !complex double !defined(PETSC_USE_64BIT_INDICES)
419:      nsize: 3
420:      args: -fA ${DATAFILESPATH}/matrices/medium -fB ${DATAFILESPATH}/matrices/medium -AB_mat_product_algorithm hypre -matmatmult_via hypre -PtAP_mat_product_algorithm hypre -matptap_via hypre
421:      output_file: output/ex62_1.out

423:    test:
424:      suffix: 14_seqaij
425:      requires: !complex double !defined(PETSC_USE_64BIT_INDICES)
426:      args: -fA ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system -fB ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system
427:      output_file: output/ex62_1.out

429:    test:
430:      suffix: 14_seqaijcusparse
431:      requires: cuda !complex double !defined(PETSC_USE_64BIT_INDICES)
432:      args: -A_mat_type aijcusparse -B_mat_type aijcusparse -mat_form_explicit_transpose -fA ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system -fB ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system
433:      output_file: output/ex62_1.out

435:    test:
436:      suffix: 14_seqaijcusparse_cpu
437:      requires: cuda !complex double !defined(PETSC_USE_64BIT_INDICES)
438:      args: -A_mat_type aijcusparse -B_mat_type aijcusparse -mat_form_explicit_transpose -fA ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system -fB ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system -AB_mat_product_algorithm_backend_cpu -matmatmult_backend_cpu -PtAP_mat_product_algorithm_backend_cpu -matptap_backend_cpu -RARt_mat_product_algorithm_backend_cpu -matrart_backend_cpu
439:      output_file: output/ex62_1.out

441:    test:
442:      suffix: 14_mpiaijcusparse_seq
443:      nsize: 1
444:      requires: cuda !complex double !defined(PETSC_USE_64BIT_INDICES)
445:      args: -A_mat_type mpiaijcusparse -B_mat_type mpiaijcusparse -mat_form_explicit_transpose -fA ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system -fB ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system
446:      output_file: output/ex62_1.out

448:    test:
449:      suffix: 14_mpiaijcusparse_seq_cpu
450:      nsize: 1
451:      requires: cuda !complex double !defined(PETSC_USE_64BIT_INDICES)
452:      args: -A_mat_type mpiaijcusparse -B_mat_type mpiaijcusparse -mat_form_explicit_transpose -fA ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system -fB ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system -AB_mat_product_algorithm_backend_cpu -matmatmult_backend_cpu -PtAP_mat_product_algorithm_backend_cpu -matptap_backend_cpu -test_rart 0
453:      output_file: output/ex62_1.out

455:    test:
456:      suffix: 14_mpiaijcusparse
457:      nsize: 3
458:      requires: cuda !complex double !defined(PETSC_USE_64BIT_INDICES)
459:      args: -A_mat_type mpiaijcusparse -B_mat_type mpiaijcusparse -mat_form_explicit_transpose -fA ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system -fB ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system
460:      output_file: output/ex62_1.out

462:    test:
463:      suffix: 14_mpiaijcusparse_cpu
464:      nsize: 3
465:      requires: cuda !complex double !defined(PETSC_USE_64BIT_INDICES)
466:      args: -A_mat_type mpiaijcusparse -B_mat_type mpiaijcusparse -mat_form_explicit_transpose -fA ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system -fB ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system -AB_mat_product_algorithm_backend_cpu -matmatmult_backend_cpu -PtAP_mat_product_algorithm_backend_cpu -matptap_backend_cpu -test_rart 0
467:      output_file: output/ex62_1.out

469:    test:
470:      nsize: {{1 3}}
471:      suffix: 14_aijkokkos
472:      requires: kokkos_kernels !complex double !defined(PETSC_USE_64BIT_INDICES)
473:      args: -A_mat_type aijkokkos -B_mat_type aijkokkos -fA ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system -fB ${wPETSC_DIR}/share/petsc/datafiles/matrices/tiny_system
474:      output_file: output/ex62_1.out

476:    # these tests use matrices with many zero rows
477:    test:
478:      suffix: 15_seqaijcusparse
479:      requires: cuda !complex double !defined(PETSC_USE_64BIT_INDICES) datafilespath
480:      args: -A_mat_type aijcusparse -mat_form_explicit_transpose -fA ${DATAFILESPATH}/matrices/matmatmult/A4.BGriffith
481:      output_file: output/ex62_1.out

483:    test:
484:      suffix: 15_mpiaijcusparse_seq
485:      nsize: 1
486:      requires: cuda !complex double !defined(PETSC_USE_64BIT_INDICES) datafilespath
487:      args: -A_mat_type mpiaijcusparse -mat_form_explicit_transpose -fA ${DATAFILESPATH}/matrices/matmatmult/A4.BGriffith
488:      output_file: output/ex62_1.out

490:    test:
491:      nsize: 3
492:      suffix: 15_mpiaijcusparse
493:      requires: cuda !complex double !defined(PETSC_USE_64BIT_INDICES) datafilespath
494:      args: -A_mat_type mpiaijcusparse -mat_form_explicit_transpose -fA ${DATAFILESPATH}/matrices/matmatmult/A4.BGriffith
495:      output_file: output/ex62_1.out

497: TEST*/