Skip to content

Commit c2ae795

Browse files
alvaroborrasalvaroborras
committed
Add FLOP estimates for operator assembly
Signed-off-by: alvaroborras <13698600+alvaroborras@users.noreply.github.com>
1 parent 03c6d39 commit c2ae795

6 files changed

Lines changed: 233 additions & 4 deletions

File tree

‎include/ceed/ceed.h‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -457,13 +457,16 @@ CEED_EXTERN int CeedOperatorSetQFunctionAssemblyDataUpdateNeeded(CeedOperator o
457457
CEED_EXTERN int CeedOperatorLinearAssembleQFunction(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request);
458458
CEED_EXTERN int CeedOperatorLinearAssembleQFunctionBuildOrUpdate(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr,
459459
CeedRequest *request);
460+
CEED_EXTERN int CeedOperatorLinearAssembleDiagonalGetFlopsEstimate(CeedOperator op, CeedSize *flops);
460461
CEED_EXTERN int CeedOperatorLinearAssembleDiagonal(CeedOperator op, CeedVector assembled, CeedRequest *request);
461462
CEED_EXTERN int CeedOperatorLinearAssembleAddDiagonal(CeedOperator op, CeedVector assembled, CeedRequest *request);
463+
CEED_EXTERN int CeedOperatorLinearAssemblePointBlockDiagonalGetFlopsEstimate(CeedOperator op, CeedSize *flops);
462464
CEED_EXTERN int CeedOperatorLinearAssemblePointBlockDiagonal(CeedOperator op, CeedVector assembled, CeedRequest *request);
463465
CEED_EXTERN int CeedOperatorLinearAssembleAddPointBlockDiagonal(CeedOperator op, CeedVector assembled, CeedRequest *request);
464466
CEED_EXTERN int CeedOperatorLinearAssemblePointBlockDiagonalSymbolic(CeedOperator op, CeedSize *num_entries, CeedInt **rows, CeedInt **cols);
465467
CEED_EXTERN int CeedOperatorLinearAssembleSymbolic(CeedOperator op, CeedSize *num_entries, CeedInt **rows, CeedInt **cols);
466468
CEED_EXTERN int CeedOperatorLinearAssembleGetNumEntries(CeedOperator op, CeedSize *num_entries);
469+
CEED_EXTERN int CeedOperatorLinearAssembleGetFlopsEstimate(CeedOperator op, CeedSize *flops);
467470
CEED_EXTERN int CeedOperatorLinearAssemble(CeedOperator op, CeedVector values);
468471
CEED_EXTERN int CeedOperatorCompositeGetMultiplicity(CeedOperator op, CeedInt num_skip_indices, CeedInt *skip_indices, CeedVector mult);
469472
CEED_EXTERN int CeedOperatorMultigridLevelCreate(CeedOperator op_fine, CeedVector p_mult_fine, CeedElemRestriction rstr_coarse,

‎interface/ceed-preconditioning.c‎

Lines changed: 148 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2375,6 +2375,154 @@ int CeedOperatorLinearAssembleQFunctionBuildOrUpdate(CeedOperator op, CeedVector
23752375
return CeedOperatorLinearAssembleQFunctionBuildOrUpdate_Core(op, *assembled == NULL, true, assembled, rstr, request);
23762376
}
23772377

2378+
// Estimate the work to rebuild the assembled QFunction data, without changing its state.
2379+
static int CeedOperatorLinearAssembleQFunctionGetFlopsEstimate(CeedOperator op, CeedSize *flops) {
2380+
CeedInt num_elem, num_qpts, num_input_fields, num_active_inputs = 0;
2381+
CeedQFunction qf;
2382+
CeedQFunctionField *qf_input_fields;
2383+
CeedOperatorField *op_input_fields;
2384+
CeedQFunctionAssemblyData data;
2385+
bool is_setup, update_needed;
2386+
2387+
*flops = 0;
2388+
CeedCall(CeedOperatorGetQFunctionAssemblyData(op, &data));
2389+
CeedCall(CeedQFunctionAssemblyDataIsSetup(data, &is_setup));
2390+
if (is_setup) {
2391+
CeedCall(CeedQFunctionAssemblyDataIsUpdateNeeded(data, &update_needed));
2392+
} else {
2393+
update_needed = true;
2394+
}
2395+
if (!update_needed) return CEED_ERROR_SUCCESS;
2396+
2397+
CeedCall(CeedOperatorGetNumElements(op, &num_elem));
2398+
CeedCall(CeedOperatorGetNumQuadraturePoints(op, &num_qpts));
2399+
CeedCall(CeedOperatorGetQFunction(op, &qf));
2400+
CeedCall(CeedQFunctionGetFields(qf, &num_input_fields, &qf_input_fields, NULL, NULL));
2401+
CeedCall(CeedOperatorGetFields(op, NULL, &op_input_fields, NULL, NULL));
2402+
for (CeedInt i = 0; i < num_input_fields; i++) {
2403+
CeedEvalMode eval_mode;
2404+
CeedVector vec;
2405+
2406+
CeedCall(CeedOperatorFieldGetVector(op_input_fields[i], &vec));
2407+
if (vec == CEED_VECTOR_ACTIVE) {
2408+
CeedInt size;
2409+
2410+
CeedCall(CeedQFunctionFieldGetSize(qf_input_fields[i], &size));
2411+
num_active_inputs += size;
2412+
} else {
2413+
CeedBasis basis;
2414+
CeedElemRestriction rstr;
2415+
CeedSize basis_flops, rstr_flops;
2416+
2417+
CeedCall(CeedQFunctionFieldGetEvalMode(qf_input_fields[i], &eval_mode));
2418+
if (eval_mode != CEED_EVAL_WEIGHT) {
2419+
CeedCall(CeedOperatorFieldGetElemRestriction(op_input_fields[i], &rstr));
2420+
CeedCall(CeedElemRestrictionGetFlopsEstimate(rstr, CEED_NOTRANSPOSE, &rstr_flops));
2421+
CeedCall(CeedElemRestrictionDestroy(&rstr));
2422+
CeedCall(CeedOperatorFieldGetBasis(op_input_fields[i], &basis));
2423+
basis_flops = 0;
2424+
if (basis != CEED_BASIS_NONE) CeedCall(CeedBasisGetFlopsEstimate(basis, CEED_NOTRANSPOSE, eval_mode, false, 0, &basis_flops));
2425+
CeedCall(CeedBasisDestroy(&basis));
2426+
*flops += rstr_flops + basis_flops * num_elem;
2427+
}
2428+
}
2429+
CeedCall(CeedVectorDestroy(&vec));
2430+
}
2431+
{
2432+
CeedSize qf_flops;
2433+
2434+
CeedCall(CeedQFunctionGetFlopsEstimate(qf, &qf_flops));
2435+
CeedCheck(qf_flops > -1, CeedOperatorReturnCeed(op), CEED_ERROR_INCOMPLETE,
2436+
"Must set CeedQFunction FLOPs estimate with CeedQFunctionSetUserFlopsEstimate");
2437+
*flops += (CeedSize)num_elem * num_qpts * num_active_inputs * qf_flops;
2438+
}
2439+
CeedCall(CeedQFunctionDestroy(&qf));
2440+
return CEED_ERROR_SUCCESS;
2441+
}
2442+
2443+
static int CeedOperatorLinearAssembleGetFlopsEstimate_Core(CeedOperator op, bool is_point_block, bool is_diagonal, CeedSize *flops) {
2444+
bool is_at_points, is_composite;
2445+
2446+
CeedCall(CeedOperatorCheckReady(op));
2447+
*flops = 0;
2448+
CeedCall(CeedOperatorIsComposite(op, &is_composite));
2449+
if (is_composite) {
2450+
CeedInt num_sub;
2451+
CeedOperator *suboperators;
2452+
2453+
CeedCall(CeedOperatorCompositeGetNumSub(op, &num_sub));
2454+
CeedCall(CeedOperatorCompositeGetSubList(op, &suboperators));
2455+
for (CeedInt i = 0; i < num_sub; i++) {
2456+
CeedSize sub_flops;
2457+
2458+
CeedCall(CeedOperatorLinearAssembleGetFlopsEstimate_Core(suboperators[i], is_point_block, is_diagonal, &sub_flops));
2459+
*flops += sub_flops;
2460+
}
2461+
return CEED_ERROR_SUCCESS;
2462+
}
2463+
CeedCall(CeedOperatorIsAtPoints(op, &is_at_points));
2464+
CeedCheck(!is_at_points, CeedOperatorReturnCeed(op), CEED_ERROR_UNSUPPORTED, "AtPoints operator not supported");
2465+
2466+
CeedCall(CeedOperatorLinearAssembleQFunctionGetFlopsEstimate(op, flops));
2467+
{
2468+
CeedOperatorAssemblyData data;
2469+
CeedBasis *bases_in, *bases_out;
2470+
CeedElemRestriction *rstrs_in, *rstrs_out;
2471+
CeedInt num_bases_in, num_bases_out, *num_eval_modes_in, *num_eval_modes_out;
2472+
2473+
CeedCall(CeedOperatorGetOperatorAssemblyData(op, &data));
2474+
CeedCall(CeedOperatorAssemblyDataGetEvalModes(data, &num_bases_in, &num_eval_modes_in, NULL, NULL, &num_bases_out, &num_eval_modes_out,
2475+
NULL, NULL, NULL));
2476+
CeedCall(CeedOperatorAssemblyDataGetBases(data, NULL, &bases_in, NULL, NULL, &bases_out, NULL));
2477+
CeedCall(CeedOperatorAssemblyDataGetElemRestrictions(data, NULL, &rstrs_in, NULL, &rstrs_out));
2478+
for (CeedInt b_in = 0; b_in < num_bases_in; b_in++) {
2479+
for (CeedInt b_out = 0; b_out < num_bases_out; b_out++) {
2480+
CeedInt num_elem, num_nodes_in, num_nodes_out, num_comp_in, num_comp_out, num_qpts;
2481+
2482+
if (is_diagonal && bases_in[b_in] != bases_out[b_out]) continue;
2483+
CeedCall(CeedElemRestrictionGetNumElements(rstrs_in[b_in], &num_elem));
2484+
CeedCall(CeedElemRestrictionGetNumComponents(rstrs_in[b_in], &num_comp_in));
2485+
CeedCall(CeedElemRestrictionGetNumComponents(rstrs_out[b_out], &num_comp_out));
2486+
if (bases_in[b_in] == CEED_BASIS_NONE) {
2487+
CeedCall(CeedElemRestrictionGetElementSize(rstrs_in[b_in], &num_nodes_in));
2488+
num_qpts = num_nodes_in;
2489+
} else {
2490+
CeedCall(CeedBasisGetNumNodes(bases_in[b_in], &num_nodes_in));
2491+
CeedCall(CeedBasisGetNumQuadraturePoints(bases_in[b_in], &num_qpts));
2492+
}
2493+
if (bases_out[b_out] == CEED_BASIS_NONE) {
2494+
CeedCall(CeedElemRestrictionGetElementSize(rstrs_out[b_out], &num_nodes_out));
2495+
} else {
2496+
CeedCall(CeedBasisGetNumNodes(bases_out[b_out], &num_nodes_out));
2497+
}
2498+
if (is_diagonal) {
2499+
const CeedSize num_comp = is_point_block ? num_comp_in * num_comp_out : num_comp_in;
2500+
2501+
*flops += 3 * (CeedSize)num_elem * num_nodes_in * num_qpts * num_eval_modes_in[b_in] * num_eval_modes_out[b_out] * num_comp;
2502+
*flops += (CeedSize)num_elem * num_nodes_in * num_comp;
2503+
if (is_point_block) *flops += (CeedSize)num_elem * num_nodes_in * num_comp * (num_comp_out - 1);
2504+
} else {
2505+
*flops += 2 * (CeedSize)num_elem * num_comp_in * num_comp_out * num_nodes_out * num_qpts * num_eval_modes_in[b_in] *
2506+
(num_eval_modes_out[b_out] + num_nodes_in);
2507+
}
2508+
}
2509+
}
2510+
}
2511+
return CEED_ERROR_SUCCESS;
2512+
}
2513+
2514+
int CeedOperatorLinearAssembleDiagonalGetFlopsEstimate(CeedOperator op, CeedSize *flops) {
2515+
return CeedOperatorLinearAssembleGetFlopsEstimate_Core(op, false, true, flops);
2516+
}
2517+
2518+
int CeedOperatorLinearAssemblePointBlockDiagonalGetFlopsEstimate(CeedOperator op, CeedSize *flops) {
2519+
return CeedOperatorLinearAssembleGetFlopsEstimate_Core(op, true, true, flops);
2520+
}
2521+
2522+
int CeedOperatorLinearAssembleGetFlopsEstimate(CeedOperator op, CeedSize *flops) {
2523+
return CeedOperatorLinearAssembleGetFlopsEstimate_Core(op, false, false, flops);
2524+
}
2525+
23782526
/**
23792527
@brief Assemble the diagonal of a square linear `CeedOperator`
23802528

‎tests/t526-operator.c‎

Lines changed: 27 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -19,13 +19,13 @@
1919

2020
int main(int argc, char **argv) {
2121
Ceed ceed;
22-
CeedSize flop_estimate;
22+
CeedSize flop_estimate, num_entries;
2323
CeedElemRestriction elem_restriction_x_tet, elem_restriction_u_tet, elem_restriction_q_data_tet, elem_restriction_x_hex, elem_restriction_u_hex,
2424
elem_restriction_q_data_hex;
2525
CeedBasis basis_x_tet, basis_u_tet, basis_x_hex, basis_u_hex;
2626
CeedQFunction qf_mass;
2727
CeedOperator op_mass_tet, op_mass_hex, op_mass;
28-
CeedVector q_data_tet, q_data_hex;
28+
CeedVector q_data_tet, q_data_hex, assembled;
2929
CeedInt num_elem_tet = 6, p_tet = 6, q_tet = 4, num_elem_hex = 6, p_hex = 3, q_hex = 4, dim = 2;
3030
CeedInt n_x = 3, n_y = 3, n_x_tet = 3, n_y_tet = 1, n_x_hex = 3;
3131
CeedInt row, col, offset;
@@ -39,6 +39,8 @@ int main(int argc, char **argv) {
3939
// Qdata Vectors
4040
CeedVectorCreate(ceed, num_qpts_tet, &q_data_tet);
4141
CeedVectorCreate(ceed, num_qpts_hex, &q_data_hex);
42+
CeedVectorSetValue(q_data_tet, 1.0);
43+
CeedVectorSetValue(q_data_hex, 1.0);
4244

4345
// Set up Tet Elements
4446
// -- Restrictions
@@ -123,12 +125,34 @@ int main(int argc, char **argv) {
123125
CeedQFunctionSetUserFlopsEstimate(qf_mass, 1);
124126
CeedOperatorGetFlopsEstimate(op_mass, &flop_estimate);
125127

126-
// Check output
128+
// Check apply estimate
127129
if (flop_estimate != 3042) printf("Incorrect FLOP estimate computed, %" CeedSize_FMT " != 3042\n", flop_estimate);
128130

131+
// Check assembly estimates with stale QFunction data. Repeating the query must not update it.
132+
CeedOperatorLinearAssembleGetFlopsEstimate(op_mass, &flop_estimate);
133+
if (flop_estimate != 19416) printf("Incorrect full assembly FLOP estimate, %" CeedSize_FMT " != 19416\n", flop_estimate);
134+
CeedOperatorLinearAssembleDiagonalGetFlopsEstimate(op_mass, &flop_estimate);
135+
if (flop_estimate != 3234) printf("Incorrect diagonal assembly FLOP estimate, %" CeedSize_FMT " != 3234\n", flop_estimate);
136+
CeedOperatorLinearAssemblePointBlockDiagonalGetFlopsEstimate(op_mass, &flop_estimate);
137+
if (flop_estimate != 3234) printf("Incorrect point-block diagonal assembly FLOP estimate, %" CeedSize_FMT " != 3234\n", flop_estimate);
138+
139+
// Assemble once with reuse enabled, then check the cached-QFunction path
140+
CeedOperatorSetQFunctionAssemblyReuse(op_mass, true);
141+
CeedOperatorLinearAssembleGetNumEntries(op_mass, &num_entries);
142+
CeedVectorCreate(ceed, num_entries, &assembled);
143+
CeedVectorSetValue(assembled, 0.0);
144+
CeedOperatorLinearAssemble(op_mass, assembled);
145+
CeedOperatorLinearAssembleGetFlopsEstimate(op_mass, &flop_estimate);
146+
if (flop_estimate != 19296) printf("Incorrect cached full assembly FLOP estimate, %" CeedSize_FMT " != 19296\n", flop_estimate);
147+
CeedOperatorLinearAssembleDiagonalGetFlopsEstimate(op_mass, &flop_estimate);
148+
if (flop_estimate != 3114) printf("Incorrect cached diagonal assembly FLOP estimate, %" CeedSize_FMT " != 3114\n", flop_estimate);
149+
CeedOperatorLinearAssemblePointBlockDiagonalGetFlopsEstimate(op_mass, &flop_estimate);
150+
if (flop_estimate != 3114) printf("Incorrect cached point-block diagonal assembly FLOP estimate, %" CeedSize_FMT " != 3114\n", flop_estimate);
151+
129152
// Cleanup
130153
CeedVectorDestroy(&q_data_tet);
131154
CeedVectorDestroy(&q_data_hex);
155+
CeedVectorDestroy(&assembled);
132156
CeedElemRestrictionDestroy(&elem_restriction_u_tet);
133157
CeedElemRestrictionDestroy(&elem_restriction_x_tet);
134158
CeedElemRestrictionDestroy(&elem_restriction_q_data_tet);

‎tests/t537-operator.c‎

Lines changed: 17 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ int main(int argc, char **argv) {
2020
CeedInt num_dofs = (n_x * 2 + 1) * (n_y * 2 + 1), num_qpts = num_elem * q * q;
2121
CeedInt ind_x[num_elem * p * p];
2222
CeedInt *rows, *cols;
23-
CeedSize num_entries;
23+
CeedSize num_entries, flop_estimate;
2424
CeedScalar assembled_true[num_comp * num_comp * num_dofs];
2525
CeedScalar assembled_full_true[num_comp * num_dofs][num_comp * num_dofs];
2626

@@ -87,10 +87,26 @@ int main(int argc, char **argv) {
8787
// Apply Setup Operator
8888
CeedOperatorApply(op_setup, x, q_data, CEED_REQUEST_IMMEDIATE);
8989

90+
// Estimate assembly FLOPs before assembling QFunction data
91+
CeedQFunctionSetUserFlopsEstimate(qf_mass, 1);
92+
CeedOperatorLinearAssembleGetFlopsEstimate(op_mass, &flop_estimate);
93+
if (flop_estimate != 69312) printf("Incorrect full assembly FLOP estimate, %" CeedSize_FMT " != 69312\n", flop_estimate);
94+
CeedOperatorLinearAssembleDiagonalGetFlopsEstimate(op_mass, &flop_estimate);
95+
if (flop_estimate != 5484) printf("Incorrect diagonal assembly FLOP estimate, %" CeedSize_FMT " != 5484\n", flop_estimate);
96+
CeedOperatorLinearAssemblePointBlockDiagonalGetFlopsEstimate(op_mass, &flop_estimate);
97+
if (flop_estimate != 10992) printf("Incorrect point-block diagonal assembly FLOP estimate, %" CeedSize_FMT " != 10992\n", flop_estimate);
98+
9099
// Assemble diagonal
100+
CeedOperatorSetQFunctionAssemblyReuse(op_mass, true);
91101
CeedVectorCreate(ceed, num_comp * num_comp * num_dofs, &assembled);
92102
CeedOperatorLinearAssemblePointBlockDiagonal(op_mass, assembled, CEED_REQUEST_IMMEDIATE);
93103
CeedOperatorLinearAssemblePointBlockDiagonalSymbolic(op_mass, &num_entries, &rows, &cols);
104+
CeedOperatorLinearAssembleGetFlopsEstimate(op_mass, &flop_estimate);
105+
if (flop_estimate != 69120) printf("Incorrect cached full assembly FLOP estimate, %" CeedSize_FMT " != 69120\n", flop_estimate);
106+
CeedOperatorLinearAssembleDiagonalGetFlopsEstimate(op_mass, &flop_estimate);
107+
if (flop_estimate != 5292) printf("Incorrect cached diagonal assembly FLOP estimate, %" CeedSize_FMT " != 5292\n", flop_estimate);
108+
CeedOperatorLinearAssemblePointBlockDiagonalGetFlopsEstimate(op_mass, &flop_estimate);
109+
if (flop_estimate != 10800) printf("Incorrect cached point-block diagonal assembly FLOP estimate, %" CeedSize_FMT " != 10800\n", flop_estimate);
94110

95111
// Manually assemble point-block diagonal
96112
CeedVectorCreate(ceed, num_comp * num_dofs, &u);

‎tests/t570-operator.c‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,34 @@ int main(int argc, char **argv) {
4646
CeedOperatorSetField(op_identity, "input", elem_restriction_u, basis_u, CEED_VECTOR_ACTIVE);
4747
CeedOperatorSetField(op_identity, "output", elem_restriction_u_i, CEED_BASIS_NONE, CEED_VECTOR_ACTIVE);
4848

49+
// Estimate assembly FLOPs with a basis-none active output
50+
{
51+
CeedSize flop_estimate;
52+
53+
CeedQFunctionSetUserFlopsEstimate(qf_identity, 0);
54+
CeedOperatorLinearAssembleGetFlopsEstimate(op_identity, &flop_estimate);
55+
if (flop_estimate != 11520) printf("Incorrect full assembly FLOP estimate, %" CeedSize_FMT " != 11520\n", flop_estimate);
56+
}
57+
{
58+
CeedOperator op_identity_none;
59+
CeedQFunction qf_identity_none;
60+
CeedSize flop_estimate;
61+
62+
CeedQFunctionCreateIdentity(ceed, 1, CEED_EVAL_NONE, CEED_EVAL_NONE, &qf_identity_none);
63+
CeedQFunctionSetUserFlopsEstimate(qf_identity_none, 0);
64+
CeedOperatorCreate(ceed, qf_identity_none, CEED_QFUNCTION_NONE, CEED_QFUNCTION_NONE, &op_identity_none);
65+
CeedOperatorSetField(op_identity_none, "input", elem_restriction_u_i, CEED_BASIS_NONE, CEED_VECTOR_ACTIVE);
66+
CeedOperatorSetField(op_identity_none, "output", elem_restriction_u_i, CEED_BASIS_NONE, CEED_VECTOR_ACTIVE);
67+
CeedOperatorLinearAssembleGetFlopsEstimate(op_identity_none, &flop_estimate);
68+
if (flop_estimate != 17280) printf("Incorrect basis-none full assembly FLOP estimate, %" CeedSize_FMT " != 17280\n", flop_estimate);
69+
CeedOperatorLinearAssembleDiagonalGetFlopsEstimate(op_identity_none, &flop_estimate);
70+
if (flop_estimate != 3000) printf("Incorrect basis-none diagonal assembly FLOP estimate, %" CeedSize_FMT " != 3000\n", flop_estimate);
71+
CeedOperatorLinearAssemblePointBlockDiagonalGetFlopsEstimate(op_identity_none, &flop_estimate);
72+
if (flop_estimate != 3000) printf("Incorrect basis-none point-block diagonal assembly FLOP estimate, %" CeedSize_FMT " != 3000\n", flop_estimate);
73+
CeedOperatorDestroy(&op_identity_none);
74+
CeedQFunctionDestroy(&qf_identity_none);
75+
}
76+
4977
// Fully assemble operator
5078
CeedSize num_entries;
5179
CeedInt *rows;

‎tests/t595-operator.c‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -110,6 +110,16 @@ int main(int argc, char **argv) {
110110
printf("Incorrect FLOP estimate computed, %ld != 16317\n", flop_estimate);
111111
// LCOV_EXCL_STOP
112112
}
113+
CeedSetErrorHandler(ceed, CeedErrorReturn);
114+
if (CeedOperatorLinearAssembleGetFlopsEstimate(op_mass, &flop_estimate) != CEED_ERROR_UNSUPPORTED) {
115+
printf("AtPoints full assembly FLOP estimate should be unsupported\n");
116+
}
117+
if (CeedOperatorLinearAssembleDiagonalGetFlopsEstimate(op_mass, &flop_estimate) != CEED_ERROR_UNSUPPORTED) {
118+
printf("AtPoints diagonal assembly FLOP estimate should be unsupported\n");
119+
}
120+
if (CeedOperatorLinearAssemblePointBlockDiagonalGetFlopsEstimate(op_mass, &flop_estimate) != CEED_ERROR_UNSUPPORTED) {
121+
printf("AtPoints point-block diagonal assembly FLOP estimate should be unsupported\n");
122+
}
113123

114124
CeedVectorDestroy(&x_points);
115125
CeedVectorDestroy(&q_data);

0 commit comments

Comments
 (0)