Actual source code: ex66.c
1: static char help[] = "Tests MATH2OPUS\n\n";
3: #include <petscmat.h>
4: #include <petscsf.h>
6: static PetscScalar GenEntry_Symm(PetscInt sdim, PetscReal x[], PetscReal y[], void *ctx)
7: {
8: PetscInt d;
9: PetscReal clength = sdim == 3 ? 0.2 : 0.1;
10: PetscReal dist, diff = 0.0;
12: for (d = 0; d < sdim; d++) diff += (x[d] - y[d]) * (x[d] - y[d]);
13: dist = PetscSqrtReal(diff);
14: return PetscExpReal(-dist / clength);
15: }
17: static PetscScalar GenEntry_Unsymm(PetscInt sdim, PetscReal x[], PetscReal y[], void *ctx)
18: {
19: PetscInt d;
20: PetscReal clength = sdim == 3 ? 0.2 : 0.1;
21: PetscReal dist, diff = 0.0, nx = 0.0, ny = 0.0;
23: for (d = 0; d < sdim; d++) nx += x[d] * x[d];
24: for (d = 0; d < sdim; d++) ny += y[d] * y[d];
25: for (d = 0; d < sdim; d++) diff += (x[d] - y[d]) * (x[d] - y[d]);
26: dist = PetscSqrtReal(diff);
27: return nx > ny ? PetscExpReal(-dist / clength) : PetscExpReal(-dist / clength) + 1.;
28: }
30: int main(int argc, char **argv)
31: {
32: Mat A, B, C, D;
33: Vec v, x, y, Ax, Ay, Bx, By;
34: PetscRandom r;
35: PetscLayout map;
36: PetscScalar *Adata = NULL, *Cdata = NULL, scale = 1.0;
37: PetscReal *coords, nA, nD, nB, err, nX, norms[3];
38: PetscInt N, n = 64, dim = 1, i, j, nrhs = 11, lda = 0, ldc = 0, ldu = 0, nlr = 7, nt, ntrials = 2;
39: PetscMPIInt size, rank;
40: PetscBool testlayout = PETSC_FALSE, flg, symm = PETSC_FALSE, Asymm = PETSC_TRUE, kernel = PETSC_TRUE;
41: PetscBool checkexpl = PETSC_FALSE, agpu = PETSC_FALSE, bgpu = PETSC_FALSE, cgpu = PETSC_FALSE, flgglob;
42: PetscBool testtrans, testnorm, randommat = PETSC_TRUE, testorthog, testcompress, testhlru;
43: void (*approxnormfunc)(void);
44: void (*Anormfunc)(void);
46: #if defined(PETSC_HAVE_MPI_INIT_THREAD)
47: PETSC_MPI_THREAD_REQUIRED = MPI_THREAD_MULTIPLE;
48: #endif
49: PetscFunctionBeginUser;
50: PetscCall(PetscInitialize(&argc, &argv, (char *)0, help));
51: PetscCall(PetscOptionsGetInt(NULL, NULL, "-ng", &N, &flgglob));
52: PetscCall(PetscOptionsGetInt(NULL, NULL, "-n", &n, NULL));
53: PetscCall(PetscOptionsGetInt(NULL, NULL, "-nrhs", &nrhs, NULL));
54: PetscCall(PetscOptionsGetInt(NULL, NULL, "-dim", &dim, NULL));
55: PetscCall(PetscOptionsGetInt(NULL, NULL, "-lda", &lda, NULL));
56: PetscCall(PetscOptionsGetInt(NULL, NULL, "-ldc", &ldc, NULL));
57: PetscCall(PetscOptionsGetInt(NULL, NULL, "-nlr", &nlr, NULL));
58: PetscCall(PetscOptionsGetInt(NULL, NULL, "-ldu", &ldu, NULL));
59: PetscCall(PetscOptionsGetInt(NULL, NULL, "-matmattrials", &ntrials, NULL));
60: PetscCall(PetscOptionsGetBool(NULL, NULL, "-randommat", &randommat, NULL));
61: if (!flgglob) PetscCall(PetscOptionsGetBool(NULL, NULL, "-testlayout", &testlayout, NULL));
62: PetscCall(PetscOptionsGetBool(NULL, NULL, "-Asymm", &Asymm, NULL));
63: PetscCall(PetscOptionsGetBool(NULL, NULL, "-symm", &symm, NULL));
64: PetscCall(PetscOptionsGetBool(NULL, NULL, "-kernel", &kernel, NULL));
65: PetscCall(PetscOptionsGetBool(NULL, NULL, "-checkexpl", &checkexpl, NULL));
66: PetscCall(PetscOptionsGetBool(NULL, NULL, "-agpu", &agpu, NULL));
67: PetscCall(PetscOptionsGetBool(NULL, NULL, "-bgpu", &bgpu, NULL));
68: PetscCall(PetscOptionsGetBool(NULL, NULL, "-cgpu", &cgpu, NULL));
69: PetscCall(PetscOptionsGetScalar(NULL, NULL, "-scale", &scale, NULL));
70: if (!Asymm) symm = PETSC_FALSE;
72: PetscCallMPI(MPI_Comm_size(PETSC_COMM_WORLD, &size));
74: /* Disable tests for unimplemented variants */
75: testtrans = (PetscBool)(size == 1 || symm);
76: testnorm = (PetscBool)(size == 1 || symm);
77: testorthog = (PetscBool)(size == 1 || symm);
78: testcompress = (PetscBool)(size == 1 || symm);
79: testhlru = (PetscBool)(size == 1);
81: PetscCallMPI(MPI_Comm_rank(PETSC_COMM_WORLD, &rank));
82: PetscCall(PetscLayoutCreate(PETSC_COMM_WORLD, &map));
83: if (testlayout) {
84: if (rank % 2) n = PetscMax(2 * n - 5 * rank, 0);
85: else n = 2 * n + rank;
86: }
87: if (!flgglob) {
88: PetscCall(PetscLayoutSetLocalSize(map, n));
89: PetscCall(PetscLayoutSetUp(map));
90: PetscCall(PetscLayoutGetSize(map, &N));
91: } else {
92: PetscCall(PetscLayoutSetSize(map, N));
93: PetscCall(PetscLayoutSetUp(map));
94: PetscCall(PetscLayoutGetLocalSize(map, &n));
95: }
96: PetscCall(PetscLayoutDestroy(&map));
98: if (lda) PetscCall(PetscMalloc1(N * (n + lda), &Adata));
99: PetscCall(MatCreateDense(PETSC_COMM_WORLD, n, n, N, N, Adata, &A));
100: PetscCall(MatDenseSetLDA(A, n + lda));
102: /* Create random points; these are replicated in order to populate a dense matrix and to compare sequential and dense runs
103: The constructor for MATH2OPUS can take as input the distributed coordinates and replicates them internally in case
104: a kernel construction is requested */
105: PetscCall(PetscRandomCreate(PETSC_COMM_WORLD, &r));
106: PetscCall(PetscRandomSetFromOptions(r));
107: PetscCall(PetscRandomSetSeed(r, 123456));
108: PetscCall(PetscRandomSeed(r));
109: PetscCall(PetscMalloc1(N * dim, &coords));
110: PetscCall(PetscRandomGetValuesReal(r, N * dim, coords));
111: PetscCall(PetscRandomDestroy(&r));
113: if (kernel || !randommat) {
114: MatH2OpusKernel k = Asymm ? GenEntry_Symm : GenEntry_Unsymm;
115: PetscInt ist, ien;
117: PetscCall(MatGetOwnershipRange(A, &ist, &ien));
118: for (i = ist; i < ien; i++) {
119: for (j = 0; j < N; j++) PetscCall(MatSetValue(A, i, j, (*k)(dim, coords + i * dim, coords + j * dim, NULL), INSERT_VALUES));
120: }
121: PetscCall(MatAssemblyBegin(A, MAT_FINAL_ASSEMBLY));
122: PetscCall(MatAssemblyEnd(A, MAT_FINAL_ASSEMBLY));
123: if (kernel) {
124: PetscCall(MatCreateH2OpusFromKernel(PETSC_COMM_WORLD, n, n, N, N, dim, coords + ist * dim, PETSC_TRUE, k, NULL, PETSC_DECIDE, PETSC_DECIDE, PETSC_DECIDE, &B));
125: } else {
126: PetscCall(MatCreateH2OpusFromMat(A, dim, coords + ist * dim, PETSC_TRUE, PETSC_DECIDE, PETSC_DECIDE, PETSC_DECIDE, PETSC_DECIDE, PETSC_DECIDE, &B));
127: }
128: } else {
129: PetscInt ist;
131: PetscCall(MatGetOwnershipRange(A, &ist, NULL));
132: PetscCall(MatSetRandom(A, NULL));
133: if (Asymm) {
134: PetscCall(MatTranspose(A, MAT_INITIAL_MATRIX, &B));
135: PetscCall(MatAXPY(A, 1.0, B, SAME_NONZERO_PATTERN));
136: PetscCall(MatDestroy(&B));
137: PetscCall(MatSetOption(A, MAT_SYMMETRIC, PETSC_TRUE));
138: }
139: PetscCall(MatCreateH2OpusFromMat(A, dim, coords + ist * dim, PETSC_TRUE, PETSC_DECIDE, PETSC_DECIDE, PETSC_DECIDE, PETSC_DECIDE, PETSC_DECIDE, &B));
140: }
141: PetscCall(PetscFree(coords));
142: if (agpu) PetscCall(MatConvert(A, MATDENSECUDA, MAT_INPLACE_MATRIX, &A));
143: PetscCall(MatViewFromOptions(A, NULL, "-A_view"));
145: PetscCall(MatSetOption(B, MAT_SYMMETRIC, symm));
147: /* assemble the H-matrix */
148: PetscCall(MatBindToCPU(B, (PetscBool)!bgpu));
149: PetscCall(MatSetFromOptions(B));
150: PetscCall(MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY));
151: PetscCall(MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY));
152: PetscCall(MatViewFromOptions(B, NULL, "-B_view"));
154: /* Test MatScale */
155: PetscCall(MatScale(A, scale));
156: PetscCall(MatScale(B, scale));
158: /* Test MatMult */
159: PetscCall(MatCreateVecs(A, &Ax, &Ay));
160: PetscCall(MatCreateVecs(B, &Bx, &By));
161: PetscCall(VecSetRandom(Ax, NULL));
162: PetscCall(VecCopy(Ax, Bx));
163: PetscCall(MatMult(A, Ax, Ay));
164: PetscCall(MatMult(B, Bx, By));
165: PetscCall(VecViewFromOptions(Ay, NULL, "-mult_vec_view"));
166: PetscCall(VecViewFromOptions(By, NULL, "-mult_vec_view"));
167: PetscCall(VecNorm(Ay, NORM_INFINITY, &nX));
168: PetscCall(VecAXPY(Ay, -1.0, By));
169: PetscCall(VecViewFromOptions(Ay, NULL, "-mult_vec_view"));
170: PetscCall(VecNorm(Ay, NORM_INFINITY, &err));
171: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "MatMult err %g\n", err / nX));
172: PetscCall(VecScale(By, -1.0));
173: PetscCall(MatMultAdd(B, Bx, By, By));
174: PetscCall(VecNorm(By, NORM_INFINITY, &err));
175: PetscCall(VecViewFromOptions(By, NULL, "-mult_vec_view"));
176: if (err > 10. * PETSC_SMALL) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "MatMultAdd err %g\n", err));
178: /* Test MatNorm */
179: PetscCall(MatNorm(A, NORM_INFINITY, &norms[0]));
180: PetscCall(MatNorm(A, NORM_1, &norms[1]));
181: norms[2] = -1.; /* NORM_2 not supported */
182: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "A Matrix norms: infty=%g, norm_1=%g, norm_2=%g\n", (double)norms[0], (double)norms[1], (double)norms[2]));
183: PetscCall(MatGetOperation(A, MATOP_NORM, &Anormfunc));
184: PetscCall(MatGetOperation(B, MATOP_NORM, &approxnormfunc));
185: PetscCall(MatSetOperation(A, MATOP_NORM, approxnormfunc));
186: PetscCall(MatNorm(A, NORM_INFINITY, &norms[0]));
187: PetscCall(MatNorm(A, NORM_1, &norms[1]));
188: PetscCall(MatNorm(A, NORM_2, &norms[2]));
189: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "A Approx Matrix norms: infty=%g, norm_1=%g, norm_2=%g\n", (double)norms[0], (double)norms[1], (double)norms[2]));
190: if (testnorm) {
191: PetscCall(MatNorm(B, NORM_INFINITY, &norms[0]));
192: PetscCall(MatNorm(B, NORM_1, &norms[1]));
193: PetscCall(MatNorm(B, NORM_2, &norms[2]));
194: } else {
195: norms[0] = -1.;
196: norms[1] = -1.;
197: norms[2] = -1.;
198: }
199: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "B Approx Matrix norms: infty=%g, norm_1=%g, norm_2=%g\n", (double)norms[0], (double)norms[1], (double)norms[2]));
200: PetscCall(MatSetOperation(A, MATOP_NORM, Anormfunc));
202: /* Test MatDuplicate */
203: PetscCall(MatDuplicate(B, MAT_COPY_VALUES, &D));
204: PetscCall(MatSetOption(D, MAT_SYMMETRIC, symm));
205: PetscCall(MatMultEqual(B, D, 10, &flg));
206: if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "MatMult error after MatDuplicate\n"));
207: if (testtrans) {
208: PetscCall(MatMultTransposeEqual(B, D, 10, &flg));
209: if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "MatMultTranspose error after MatDuplicate\n"));
210: }
211: PetscCall(MatDestroy(&D));
213: if (testtrans) { /* MatMultTranspose for nonsymmetric matrices not implemented */
214: PetscCall(VecSetRandom(Ay, NULL));
215: PetscCall(VecCopy(Ay, By));
216: PetscCall(MatMultTranspose(A, Ay, Ax));
217: PetscCall(MatMultTranspose(B, By, Bx));
218: PetscCall(VecViewFromOptions(Ax, NULL, "-multtrans_vec_view"));
219: PetscCall(VecViewFromOptions(Bx, NULL, "-multtrans_vec_view"));
220: PetscCall(VecNorm(Ax, NORM_INFINITY, &nX));
221: PetscCall(VecAXPY(Ax, -1.0, Bx));
222: PetscCall(VecViewFromOptions(Ax, NULL, "-multtrans_vec_view"));
223: PetscCall(VecNorm(Ax, NORM_INFINITY, &err));
224: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "MatMultTranspose err %g\n", err / nX));
225: PetscCall(VecScale(Bx, -1.0));
226: PetscCall(MatMultTransposeAdd(B, By, Bx, Bx));
227: PetscCall(VecNorm(Bx, NORM_INFINITY, &err));
228: if (err > 10. * PETSC_SMALL) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "MatMultTransposeAdd err %g\n", err));
229: }
230: PetscCall(VecDestroy(&Ax));
231: PetscCall(VecDestroy(&Ay));
232: PetscCall(VecDestroy(&Bx));
233: PetscCall(VecDestroy(&By));
235: /* Test MatMatMult */
236: if (ldc) PetscCall(PetscMalloc1(nrhs * (n + ldc), &Cdata));
237: PetscCall(MatCreateDense(PETSC_COMM_WORLD, n, PETSC_DECIDE, N, nrhs, Cdata, &C));
238: PetscCall(MatDenseSetLDA(C, n + ldc));
239: PetscCall(MatSetRandom(C, NULL));
240: if (cgpu) PetscCall(MatConvert(C, MATDENSECUDA, MAT_INPLACE_MATRIX, &C));
241: for (nt = 0; nt < ntrials; nt++) {
242: PetscCall(MatMatMult(B, C, nt ? MAT_REUSE_MATRIX : MAT_INITIAL_MATRIX, PETSC_DEFAULT, &D));
243: PetscCall(MatViewFromOptions(D, NULL, "-bc_view"));
244: PetscCall(PetscObjectBaseTypeCompareAny((PetscObject)D, &flg, MATSEQDENSE, MATMPIDENSE, ""));
245: if (flg) {
246: PetscCall(MatCreateVecs(B, &x, &y));
247: PetscCall(MatCreateVecs(D, NULL, &v));
248: for (i = 0; i < nrhs; i++) {
249: PetscCall(MatGetColumnVector(D, v, i));
250: PetscCall(MatGetColumnVector(C, x, i));
251: PetscCall(MatMult(B, x, y));
252: PetscCall(VecAXPY(y, -1.0, v));
253: PetscCall(VecNorm(y, NORM_INFINITY, &err));
254: if (err > 10. * PETSC_SMALL) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "MatMat err %" PetscInt_FMT " %g\n", i, err));
255: }
256: PetscCall(VecDestroy(&y));
257: PetscCall(VecDestroy(&x));
258: PetscCall(VecDestroy(&v));
259: }
260: }
261: PetscCall(MatDestroy(&D));
263: /* Test MatTransposeMatMult */
264: if (testtrans) { /* MatMultTranspose for nonsymmetric matrices not implemented */
265: for (nt = 0; nt < ntrials; nt++) {
266: PetscCall(MatTransposeMatMult(B, C, nt ? MAT_REUSE_MATRIX : MAT_INITIAL_MATRIX, PETSC_DEFAULT, &D));
267: PetscCall(MatViewFromOptions(D, NULL, "-btc_view"));
268: PetscCall(PetscObjectBaseTypeCompareAny((PetscObject)D, &flg, MATSEQDENSE, MATMPIDENSE, ""));
269: if (flg) {
270: PetscCall(MatCreateVecs(B, &y, &x));
271: PetscCall(MatCreateVecs(D, NULL, &v));
272: for (i = 0; i < nrhs; i++) {
273: PetscCall(MatGetColumnVector(D, v, i));
274: PetscCall(MatGetColumnVector(C, x, i));
275: PetscCall(MatMultTranspose(B, x, y));
276: PetscCall(VecAXPY(y, -1.0, v));
277: PetscCall(VecNorm(y, NORM_INFINITY, &err));
278: if (err > 10. * PETSC_SMALL) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "MatTransMat err %" PetscInt_FMT " %g\n", i, err));
279: }
280: PetscCall(VecDestroy(&y));
281: PetscCall(VecDestroy(&x));
282: PetscCall(VecDestroy(&v));
283: }
284: }
285: PetscCall(MatDestroy(&D));
286: }
288: /* Test basis orthogonalization */
289: if (testorthog) {
290: PetscCall(MatDuplicate(B, MAT_COPY_VALUES, &D));
291: PetscCall(MatSetOption(D, MAT_SYMMETRIC, symm));
292: PetscCall(MatH2OpusOrthogonalize(D));
293: PetscCall(MatMultEqual(B, D, 10, &flg));
294: if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "MatMult error after basis ortogonalization\n"));
295: PetscCall(MatDestroy(&D));
296: }
298: /* Test matrix compression */
299: if (testcompress) {
300: PetscCall(MatDuplicate(B, MAT_COPY_VALUES, &D));
301: PetscCall(MatSetOption(D, MAT_SYMMETRIC, symm));
302: PetscCall(MatH2OpusCompress(D, PETSC_SMALL));
303: PetscCall(MatDestroy(&D));
304: }
306: /* Test low-rank update */
307: if (testhlru) {
308: Mat U, V;
309: PetscScalar *Udata = NULL, *Vdata = NULL;
311: if (ldu) {
312: PetscCall(PetscMalloc1(nlr * (n + ldu), &Udata));
313: PetscCall(PetscMalloc1(nlr * (n + ldu + 2), &Vdata));
314: }
315: PetscCall(MatDuplicate(B, MAT_COPY_VALUES, &D));
316: PetscCall(MatCreateDense(PetscObjectComm((PetscObject)D), n, PETSC_DECIDE, N, nlr, Udata, &U));
317: PetscCall(MatDenseSetLDA(U, n + ldu));
318: PetscCall(MatCreateDense(PetscObjectComm((PetscObject)D), n, PETSC_DECIDE, N, nlr, Vdata, &V));
319: if (ldu) PetscCall(MatDenseSetLDA(V, n + ldu + 2));
320: PetscCall(MatSetRandom(U, NULL));
321: PetscCall(MatSetRandom(V, NULL));
322: PetscCall(MatH2OpusLowRankUpdate(D, U, V, 0.5));
323: PetscCall(MatH2OpusLowRankUpdate(D, U, V, -0.5));
324: PetscCall(MatMultEqual(B, D, 10, &flg));
325: if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "MatMult error after low-rank update\n"));
326: PetscCall(MatDestroy(&D));
327: PetscCall(MatDestroy(&U));
328: PetscCall(PetscFree(Udata));
329: PetscCall(MatDestroy(&V));
330: PetscCall(PetscFree(Vdata));
331: }
333: /* check explicit operator */
334: if (checkexpl) {
335: Mat Be, Bet;
337: PetscCall(MatComputeOperator(B, MATDENSE, &D));
338: PetscCall(MatDuplicate(D, MAT_COPY_VALUES, &Be));
339: PetscCall(MatNorm(D, NORM_FROBENIUS, &nB));
340: PetscCall(MatViewFromOptions(D, NULL, "-expl_view"));
341: PetscCall(MatAXPY(D, -1.0, A, SAME_NONZERO_PATTERN));
342: PetscCall(MatViewFromOptions(D, NULL, "-diff_view"));
343: PetscCall(MatNorm(D, NORM_FROBENIUS, &nD));
344: PetscCall(MatNorm(A, NORM_FROBENIUS, &nA));
345: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Approximation error %g (%g / %g, %g)\n", nD / nA, nD, nA, nB));
346: PetscCall(MatDestroy(&D));
348: if (testtrans) { /* MatMultTranspose for nonsymmetric matrices not implemented */
349: PetscCall(MatTranspose(A, MAT_INPLACE_MATRIX, &A));
350: PetscCall(MatComputeOperatorTranspose(B, MATDENSE, &D));
351: PetscCall(MatDuplicate(D, MAT_COPY_VALUES, &Bet));
352: PetscCall(MatNorm(D, NORM_FROBENIUS, &nB));
353: PetscCall(MatViewFromOptions(D, NULL, "-expl_trans_view"));
354: PetscCall(MatAXPY(D, -1.0, A, SAME_NONZERO_PATTERN));
355: PetscCall(MatViewFromOptions(D, NULL, "-diff_trans_view"));
356: PetscCall(MatNorm(D, NORM_FROBENIUS, &nD));
357: PetscCall(MatNorm(A, NORM_FROBENIUS, &nA));
358: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Approximation error transpose %g (%g / %g, %g)\n", nD / nA, nD, nA, nB));
359: PetscCall(MatDestroy(&D));
361: PetscCall(MatTranspose(Bet, MAT_INPLACE_MATRIX, &Bet));
362: PetscCall(MatAXPY(Be, -1.0, Bet, SAME_NONZERO_PATTERN));
363: PetscCall(MatViewFromOptions(Be, NULL, "-diff_expl_view"));
364: PetscCall(MatNorm(Be, NORM_FROBENIUS, &nB));
365: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Approximation error B - (B^T)^T %g\n", nB));
366: PetscCall(MatDestroy(&Be));
367: PetscCall(MatDestroy(&Bet));
368: }
369: }
370: PetscCall(MatDestroy(&A));
371: PetscCall(MatDestroy(&B));
372: PetscCall(MatDestroy(&C));
373: PetscCall(PetscFree(Cdata));
374: PetscCall(PetscFree(Adata));
375: PetscCall(PetscFinalize());
376: return 0;
377: }
379: /*TEST
381: build:
382: requires: h2opus
384: #tests from kernel
385: test:
386: requires: h2opus
387: nsize: 1
388: suffix: 1
389: args: -n {{17 33}} -kernel 1 -dim {{1 2 3}} -symm {{0 1}} -checkexpl -bgpu 0
391: test:
392: requires: h2opus
393: nsize: 1
394: suffix: 1_ld
395: output_file: output/ex66_1.out
396: args: -n 33 -kernel 1 -dim 1 -lda 13 -ldc 11 -ldu 17 -symm 0 -checkexpl -bgpu 0
398: test:
399: requires: h2opus cuda
400: nsize: 1
401: suffix: 1_cuda
402: output_file: output/ex66_1.out
403: args: -n {{17 33}} -kernel 1 -dim {{1 2 3}} -symm {{0 1}} -checkexpl -bgpu 1
405: test:
406: requires: h2opus cuda
407: nsize: 1
408: suffix: 1_cuda_ld
409: output_file: output/ex66_1.out
410: args: -n 33 -kernel 1 -dim 1 -lda 13 -ldc 11 -ldu 17 -symm 0 -checkexpl -bgpu 1
412: test:
413: requires: h2opus
414: nsize: {{2 3}}
415: suffix: 1_par
416: args: -n 64 -symm -kernel 1 -dim 1 -ldc 12 -testlayout {{0 1}} -bgpu 0 -cgpu 0
418: test:
419: requires: h2opus cuda
420: nsize: {{2 3}}
421: suffix: 1_par_cuda
422: args: -n 64 -symm -kernel 1 -dim 1 -ldc 12 -testlayout {{0 1}} -bgpu {{0 1}} -cgpu {{0 1}}
423: output_file: output/ex66_1_par.out
425: #tests from matrix sampling (parallel or unsymmetric not supported)
426: test:
427: requires: h2opus
428: nsize: 1
429: suffix: 2
430: args: -n {{17 33}} -kernel 0 -dim 2 -symm 1 -checkexpl -bgpu 0
432: test:
433: requires: h2opus cuda
434: nsize: 1
435: suffix: 2_cuda
436: output_file: output/ex66_2.out
437: args: -n {{17 29}} -kernel 0 -dim 2 -symm 1 -checkexpl -bgpu {{0 1}} -agpu {{0 1}}
439: #tests view operation
440: test:
441: requires: h2opus !cuda
442: filter: grep -v " MPI process" | grep -v "\[" | grep -v "\]"
443: nsize: {{1 2 3}}
444: suffix: view
445: args: -ng 64 -kernel 1 -dim 2 -symm 1 -checkexpl -B_view -mat_h2opus_leafsize 17 -mat_h2opus_normsamples 13 -mat_h2opus_indexmap_view ::ascii_matlab -mat_approximate_norm_samples 2 -mat_h2opus_normsamples 2
447: test:
448: requires: h2opus cuda
449: filter: grep -v " MPI process" | grep -v "\[" | grep -v "\]"
450: nsize: {{1 2 3}}
451: suffix: view_cuda
452: args: -ng 64 -kernel 1 -dim 2 -symm 1 -checkexpl -bgpu -B_view -mat_h2opus_leafsize 17 -mat_h2opus_normsamples 13 -mat_h2opus_indexmap_view ::ascii_matlab -mat_approximate_norm_samples 2 -mat_h2opus_normsamples 2
454: TEST*/