Skip to content

Commit d33eda4

Browse files
DrTimothyAldenDavisDrTimothyAldenDavis
committed
maxflow: do not free objects required for test coverage
1 parent 170c10a commit d33eda4

File tree

1 file changed

+69
-69
lines changed

1 file changed

+69
-69
lines changed

‎experimental/algorithm/LAGr_MaxFlow.c‎

Lines changed: 69 additions & 69 deletions
Original file line numberDiff line numberDiff line change
@@ -132,7 +132,6 @@ static GrB_Info LG_global_relabel
132132
#define LG_FREE_WORK_EXCEPT_R \
133133
{ \
134134
GrB_free(&CompareTuple); \
135-
GrB_free(&ResultTuple); \
136135
GrB_free(&e); \
137136
GrB_free(&d); \
138137
GrB_free(&theta); \
@@ -147,18 +146,16 @@ static GrB_Info LG_global_relabel
147146
GrB_free(&UpdateFlow); \
148147
GrB_free(&Relabel); \
149148
GrB_free(&ResidualFlow); \
150-
GrB_free(&MxeIndexMult); \
151-
GrB_free(&MxeMult); \
152-
GrB_free(&MxeAdd); \
153-
GrB_free(&MxeAddMonoid); \
154-
GrB_free(&MxeSemiring); \
149+
GrB_free(&Cxe_IndexMult); \
150+
GrB_free(&Cxe_Mult); \
151+
GrB_free(&Cxe_Semiring); \
155152
GrB_free(&ExtractJ); \
156153
GrB_free(&CreateCompareVec); \
157-
GrB_free(&RxdSemiring); \
158-
GrB_free(&RxdAdd); \
159-
GrB_free(&RxdAddMonoid); \
160-
GrB_free(&RxdIndexMult); \
161-
GrB_free(&RxdMult); \
154+
GrB_free(&Rxd_Semiring); \
155+
GrB_free(&Rxd_Add); \
156+
GrB_free(&Rxd_AddMonoid); \
157+
GrB_free(&Rxd_IndexMult); \
158+
GrB_free(&Rxd_Mult); \
162159
GrB_free(&InitForw); \
163160
GrB_free(&InitBack); \
164161
GrB_free(&ResidualForward); \
@@ -180,6 +177,9 @@ static GrB_Info LG_global_relabel
180177
#define LG_FREE_WORK \
181178
{ \
182179
LG_FREE_WORK_EXCEPT_R \
180+
GrB_free(&Cxe_Add); \
181+
GrB_free(&Cxe_AddMonoid); \
182+
GrB_free(&ResultTuple); \
183183
GrB_free(&FlowEdge); \
184184
GrB_free(&ExtractMatrixFlow); \
185185
GrB_free(&R); \
@@ -262,7 +262,7 @@ JIT_STR(void LG_MF_ResidualBackward(LG_MF_flowEdge *z, const double *y) {
262262
//------------------------------------------------------------------------------
263263

264264
// multiplicative operator, z = R(i,j) * d(j), 64-bit case
265-
JIT_STR(void LG_MF_RxdMult64(LG_MF_resultTuple64 *z,
265+
JIT_STR(void LG_MF_Rxd_Mult64(LG_MF_resultTuple64 *z,
266266
const LG_MF_flowEdge *x, GrB_Index i, GrB_Index j,
267267
const int64_t *y, GrB_Index iy, GrB_Index jy,
268268
const bool* theta) {
@@ -280,7 +280,7 @@ JIT_STR(void LG_MF_RxdMult64(LG_MF_resultTuple64 *z,
280280
}, RXDMULT_STR64)
281281

282282
// multiplicative operator, z = R(i,j) * d(j), 32-bit case
283-
JIT_STR(void LG_MF_RxdMult32(LG_MF_resultTuple32 *z,
283+
JIT_STR(void LG_MF_Rxd_Mult32(LG_MF_resultTuple32 *z,
284284
const LG_MF_flowEdge *x, GrB_Index i, GrB_Index j,
285285
const int32_t *y, GrB_Index iy, GrB_Index jy,
286286
const bool* theta) {
@@ -298,7 +298,7 @@ JIT_STR(void LG_MF_RxdMult32(LG_MF_resultTuple32 *z,
298298
}, RXDMULT_STR32)
299299

300300
// additive monoid: z = the best tuple, x or y, 64-bit case
301-
JIT_STR(void LG_MF_RxdAdd64(LG_MF_resultTuple64 * z,
301+
JIT_STR(void LG_MF_Rxd_Add64(LG_MF_resultTuple64 * z,
302302
const LG_MF_resultTuple64 * x,
303303
const LG_MF_resultTuple64 * y) {
304304
if(x->d < y->d){
@@ -326,7 +326,7 @@ JIT_STR(void LG_MF_RxdAdd64(LG_MF_resultTuple64 * z,
326326
}, RXDADD_STR64)
327327

328328
// additive monoid: z = the best tuple, x or y, 32-bit case
329-
JIT_STR(void LG_MF_RxdAdd32(LG_MF_resultTuple32 * z,
329+
JIT_STR(void LG_MF_Rxd_Add32(LG_MF_resultTuple32 * z,
330330
const LG_MF_resultTuple32 * x, const LG_MF_resultTuple32 * y) {
331331
if(x->d < y->d){
332332
(*z) = (*x) ;
@@ -437,7 +437,7 @@ JIT_STR(void LG_MF_InitBack(LG_MF_flowEdge * z,
437437
//------------------------------------------------------------------------------
438438

439439
// multiplicative operator, z = C(i,j)*e(j), 64-bit case
440-
JIT_STR(void LG_MF_MxeMult64(LG_MF_resultTuple64 * z,
440+
JIT_STR(void LG_MF_Cxe_Mult64(LG_MF_resultTuple64 * z,
441441
const LG_MF_compareTuple64 * x, GrB_Index i, GrB_Index j,
442442
const double * y, GrB_Index iy, GrB_Index jy,
443443
const bool* theta){
@@ -460,7 +460,7 @@ JIT_STR(void LG_MF_MxeMult64(LG_MF_resultTuple64 * z,
460460
}, MXEMULT_STR64)
461461

462462
// multiplicative operator, z = C(i,j)*e(j), 32-bit case
463-
JIT_STR(void LG_MF_MxeMult32(LG_MF_resultTuple32 * z,
463+
JIT_STR(void LG_MF_Cxe_Mult32(LG_MF_resultTuple32 * z,
464464
const LG_MF_compareTuple32 * x, GrB_Index i, GrB_Index j,
465465
const double * y, GrB_Index iy, GrB_Index jy,
466466
const bool* theta){
@@ -486,12 +486,12 @@ JIT_STR(void LG_MF_MxeMult32(LG_MF_resultTuple32 * z,
486486
// because any given node only pushes to one neighbor at a time. As a result,
487487
// no reduction is needed in GrB_mxv. The semiring still needs a monoid,
488488
// however.
489-
JIT_STR(void LG_MF_MxeAdd64(LG_MF_resultTuple64 * z,
489+
JIT_STR(void LG_MF_Cxe_Add64(LG_MF_resultTuple64 * z,
490490
const LG_MF_resultTuple64 * x, const LG_MF_resultTuple64 * y){
491491
(*z) = (*y) ;
492492
}, MXEADD_STR64)
493493

494-
JIT_STR(void LG_MF_MxeAdd32(LG_MF_resultTuple32 * z,
494+
JIT_STR(void LG_MF_Cxe_Add32(LG_MF_resultTuple32 * z,
495495
const LG_MF_resultTuple32 * x, const LG_MF_resultTuple32 * y){
496496
(*z) = (*y) ;
497497
}, MXEADD_STR32)
@@ -646,10 +646,10 @@ int LAGr_MaxFlow
646646
// semiring and vectors for push_vector<struct(e)> = R*d
647647
GrB_Vector push_vector = NULL ;
648648
GrB_IndexUnaryOp Prune = NULL ;
649-
GxB_IndexBinaryOp RxdIndexMult = NULL ;
650-
GrB_BinaryOp RxdAdd = NULL, RxdMult = NULL ;
651-
GrB_Monoid RxdAddMonoid = NULL ;
652-
GrB_Semiring RxdSemiring = NULL ;
649+
GxB_IndexBinaryOp Rxd_IndexMult = NULL ;
650+
GrB_BinaryOp Rxd_Add = NULL, Rxd_Mult = NULL ;
651+
GrB_Monoid Rxd_AddMonoid = NULL ;
652+
GrB_Semiring Rxd_Semiring = NULL ;
653653
GrB_Scalar theta = NULL ;
654654

655655
// binary op and pd
@@ -662,10 +662,10 @@ int LAGr_MaxFlow
662662
GrB_UnaryOp ExtractJ = NULL, ExtractYJ = NULL ;
663663

664664
// C*e semiring
665-
GrB_Semiring MxeSemiring = NULL ;
666-
GrB_Monoid MxeAddMonoid = NULL ;
667-
GrB_BinaryOp MxeAdd = NULL, MxeMult = NULL ;
668-
GxB_IndexBinaryOp MxeIndexMult = NULL ;
665+
GrB_Semiring Cxe_Semiring = NULL ;
666+
GrB_Monoid Cxe_AddMonoid = NULL ;
667+
GrB_BinaryOp Cxe_Add = NULL, Cxe_Mult = NULL ;
668+
GxB_IndexBinaryOp Cxe_IndexMult = NULL ;
669669

670670
// to extract the residual flow
671671
GrB_UnaryOp ResidualFlow = NULL ;
@@ -833,15 +833,15 @@ int LAGr_MaxFlow
833833

834834
// create ops for R*d semiring
835835

836-
GRB_TRY(GxB_IndexBinaryOp_new(&RxdIndexMult,
837-
F_INDEX_BINARY(LG_MF_RxdMult64), ResultTuple, FlowEdge, GrB_INT64, GrB_BOOL,
838-
"LG_MF_RxdMult64", RXDMULT_STR64));
839-
GRB_TRY(GxB_BinaryOp_new_IndexOp(&RxdMult, RxdIndexMult, theta));
840-
GRB_TRY(GxB_BinaryOp_new(&RxdAdd,
841-
F_BINARY(LG_MF_RxdAdd64), ResultTuple, ResultTuple, ResultTuple,
842-
"LG_MF_RxdAdd64", RXDADD_STR64));
836+
GRB_TRY(GxB_IndexBinaryOp_new(&Rxd_IndexMult,
837+
F_INDEX_BINARY(LG_MF_Rxd_Mult64), ResultTuple, FlowEdge, GrB_INT64, GrB_BOOL,
838+
"LG_MF_Rxd_Mult64", RXDMULT_STR64));
839+
GRB_TRY(GxB_BinaryOp_new_IndexOp(&Rxd_Mult, Rxd_IndexMult, theta));
840+
GRB_TRY(GxB_BinaryOp_new(&Rxd_Add,
841+
F_BINARY(LG_MF_Rxd_Add64), ResultTuple, ResultTuple, ResultTuple,
842+
"LG_MF_Rxd_Add64", RXDADD_STR64));
843843
LG_MF_resultTuple64 id = {.d = INT64_MAX, .j = -1, .residual = 0};
844-
GRB_TRY(GrB_Monoid_new_UDT(&RxdAddMonoid, RxdAdd, &id));
844+
GRB_TRY(GrB_Monoid_new_UDT(&Rxd_AddMonoid, Rxd_Add, &id));
845845

846846
// create binary op for pd
847847
GRB_TRY(GxB_BinaryOp_new(&CreateCompareVec,
@@ -862,14 +862,14 @@ int LAGr_MaxFlow
862862
"LG_MF_ExtractYJ64", EXTRACTYJ_STR64));
863863

864864
// create ops for C*e semiring
865-
GRB_TRY(GxB_IndexBinaryOp_new(&MxeIndexMult,
866-
F_INDEX_BINARY(LG_MF_MxeMult64), ResultTuple, CompareTuple, GrB_FP64, GrB_BOOL,
867-
"LG_MF_MxeMult64", MXEMULT_STR64));
868-
GRB_TRY(GxB_BinaryOp_new_IndexOp(&MxeMult, MxeIndexMult, theta));
869-
GRB_TRY(GxB_BinaryOp_new(&MxeAdd,
870-
F_BINARY(LG_MF_MxeAdd64), ResultTuple, ResultTuple, ResultTuple,
871-
"LG_MF_MxeAdd64", MXEADD_STR64));
872-
GRB_TRY(GrB_Monoid_new_UDT(&MxeAddMonoid, MxeAdd, &id));
865+
GRB_TRY(GxB_IndexBinaryOp_new(&Cxe_IndexMult,
866+
F_INDEX_BINARY(LG_MF_Cxe_Mult64), ResultTuple, CompareTuple, GrB_FP64, GrB_BOOL,
867+
"LG_MF_Cxe_Mult64", MXEMULT_STR64));
868+
GRB_TRY(GxB_BinaryOp_new_IndexOp(&Cxe_Mult, Cxe_IndexMult, theta));
869+
GRB_TRY(GxB_BinaryOp_new(&Cxe_Add,
870+
F_BINARY(LG_MF_Cxe_Add64), ResultTuple, ResultTuple, ResultTuple,
871+
"LG_MF_Cxe_Add64", MXEADD_STR64));
872+
GRB_TRY(GrB_Monoid_new_UDT(&Cxe_AddMonoid, Cxe_Add, &id));
873873

874874
// update height binary op
875875
GRB_TRY(GxB_BinaryOp_new(&Relabel,
@@ -905,15 +905,15 @@ int LAGr_MaxFlow
905905
"LG_MF_ResidualFlow32", RESIDUALFLOW_STR32));
906906

907907
// create ops for R*d semiring
908-
GRB_TRY(GxB_IndexBinaryOp_new(&RxdIndexMult,
909-
F_INDEX_BINARY(LG_MF_RxdMult32), ResultTuple, FlowEdge, GrB_INT32, GrB_BOOL,
910-
"LG_MF_RxdMult32", RXDMULT_STR32));
911-
GRB_TRY(GxB_BinaryOp_new_IndexOp(&RxdMult, RxdIndexMult, theta));
912-
GRB_TRY(GxB_BinaryOp_new(&RxdAdd,
913-
F_BINARY(LG_MF_RxdAdd32), ResultTuple, ResultTuple, ResultTuple,
914-
"LG_MF_RxdAdd32", RXDADD_STR32));
908+
GRB_TRY(GxB_IndexBinaryOp_new(&Rxd_IndexMult,
909+
F_INDEX_BINARY(LG_MF_Rxd_Mult32), ResultTuple, FlowEdge, GrB_INT32, GrB_BOOL,
910+
"LG_MF_Rxd_Mult32", RXDMULT_STR32));
911+
GRB_TRY(GxB_BinaryOp_new_IndexOp(&Rxd_Mult, Rxd_IndexMult, theta));
912+
GRB_TRY(GxB_BinaryOp_new(&Rxd_Add,
913+
F_BINARY(LG_MF_Rxd_Add32), ResultTuple, ResultTuple, ResultTuple,
914+
"LG_MF_Rxd_Add32", RXDADD_STR32));
915915
LG_MF_resultTuple32 id = {.d = INT32_MAX, .j = -1, .residual = 0};
916-
GRB_TRY(GrB_Monoid_new_UDT(&RxdAddMonoid, RxdAdd, &id));
916+
GRB_TRY(GrB_Monoid_new_UDT(&Rxd_AddMonoid, Rxd_Add, &id));
917917

918918
// create binary op for pd
919919
GRB_TRY(GxB_BinaryOp_new(&CreateCompareVec,
@@ -934,14 +934,14 @@ int LAGr_MaxFlow
934934
"LG_MF_ExtractYJ32", EXTRACTYJ_STR32));
935935

936936
// create ops for C*e semiring
937-
GRB_TRY(GxB_IndexBinaryOp_new(&MxeIndexMult,
938-
F_INDEX_BINARY(LG_MF_MxeMult32), ResultTuple, CompareTuple, GrB_FP64, GrB_BOOL,
939-
"LG_MF_MxeMult32", MXEMULT_STR32));
940-
GRB_TRY(GxB_BinaryOp_new_IndexOp(&MxeMult, MxeIndexMult, theta));
941-
GRB_TRY(GxB_BinaryOp_new(&MxeAdd,
942-
F_BINARY(LG_MF_MxeAdd32), ResultTuple, ResultTuple, ResultTuple,
943-
"LG_MF_MxeAdd32", MXEADD_STR32));
944-
GRB_TRY(GrB_Monoid_new_UDT(&MxeAddMonoid, MxeAdd, &id));
937+
GRB_TRY(GxB_IndexBinaryOp_new(&Cxe_IndexMult,
938+
F_INDEX_BINARY(LG_MF_Cxe_Mult32), ResultTuple, CompareTuple, GrB_FP64, GrB_BOOL,
939+
"LG_MF_Cxe_Mult32", MXEMULT_STR32));
940+
GRB_TRY(GxB_BinaryOp_new_IndexOp(&Cxe_Mult, Cxe_IndexMult, theta));
941+
GRB_TRY(GxB_BinaryOp_new(&Cxe_Add,
942+
F_BINARY(LG_MF_Cxe_Add32), ResultTuple, ResultTuple, ResultTuple,
943+
"LG_MF_Cxe_Add32", MXEADD_STR32));
944+
GRB_TRY(GrB_Monoid_new_UDT(&Cxe_AddMonoid, Cxe_Add, &id));
945945

946946
// update height binary op
947947
GRB_TRY(GxB_BinaryOp_new(&Relabel,
@@ -958,8 +958,8 @@ int LAGr_MaxFlow
958958
GRB_TRY(GrB_Vector_new(&pd, CompareTuple, n));
959959
GRB_TRY(GrB_Vector_new(&push_vector, ResultTuple, n));
960960

961-
GRB_TRY(GrB_Semiring_new(&RxdSemiring, RxdAddMonoid, RxdMult));
962-
GRB_TRY(GrB_Semiring_new(&MxeSemiring, MxeAddMonoid, MxeMult));
961+
GRB_TRY(GrB_Semiring_new(&Rxd_Semiring, Rxd_AddMonoid, Rxd_Mult));
962+
GRB_TRY(GrB_Semiring_new(&Cxe_Semiring, Cxe_AddMonoid, Cxe_Mult));
963963

964964
// create descriptor for building the C and Delta matrices
965965
GRB_TRY(GrB_Descriptor_new(&desc));
@@ -1036,8 +1036,8 @@ int LAGr_MaxFlow
10361036
// Part 2: deciding where to push
10371037
//--------------------------------------------------------------------------
10381038

1039-
// push_vector<struct(e),replace> = R*d using the RxdSemiring
1040-
GRB_TRY(GrB_mxv(push_vector, e, NULL, RxdSemiring, R, d, GrB_DESC_RS));
1039+
// push_vector<struct(e),replace> = R*d using the Rxd_Semiring
1040+
GRB_TRY(GrB_mxv(push_vector, e, NULL, Rxd_Semiring, R, d, GrB_DESC_RS));
10411041

10421042
// remove empty tuples (0,inf,-1) from push_vector
10431043
GRB_TRY(GrB_select(push_vector, NULL, NULL, Prune, push_vector, 0, NULL));
@@ -1068,8 +1068,8 @@ int LAGr_MaxFlow
10681068
// or always full with e(i)=0 denoting a non-active node.
10691069
GRB_TRY(GrB_assign(e, e, NULL, 0, GrB_ALL, n, GrB_DESC_SC));
10701070

1071-
// push_vector = C*e using the MxeSemiring
1072-
GRB_TRY(GrB_mxv(push_vector, NULL, NULL, MxeSemiring, C, e, NULL));
1071+
// push_vector = C*e using the Cxe_Semiring
1072+
GRB_TRY(GrB_mxv(push_vector, NULL, NULL, Cxe_Semiring, C, e, NULL));
10731073
GRB_TRY(GrB_Matrix_clear(C));
10741074

10751075
// remove empty tuples (0,inf,-1) from push_vector
@@ -1158,8 +1158,8 @@ int LAGr_MaxFlow
11581158
//----------------------------------------------------------------------------
11591159

11601160
#ifdef COVERAGE
1161-
// The MxeAdd operator is not tested via the call to GrB_mxv with the
1162-
// MxeSemiring above, so test it via the MxeAddMonoid.
1161+
// The Cxe_Add operator is not tested via the call to GrB_mxv with the
1162+
// Cxe_Semiring above, so test it via the Cxe_AddMonoid.
11631163
GrB_free(&push_vector);
11641164
GRB_TRY(GrB_Vector_new(&push_vector, ResultTuple, 3));
11651165
if (n > NBIG)
@@ -1169,7 +1169,7 @@ int LAGr_MaxFlow
11691169
GRB_TRY (GrB_Vector_setElement_UDT (push_vector, (void *) &a, 0)) ;
11701170
GRB_TRY (GrB_Vector_setElement_UDT (push_vector, (void *) &b, 0)) ;
11711171
LG_MF_resultTuple64 c = {.d = 0, .j = 0, .residual = 0};
1172-
GRB_TRY (GrB_Vector_reduce_UDT ((void *) &c, NULL, MxeAddMonoid, push_vector, NULL)) ;
1172+
GRB_TRY (GrB_Vector_reduce_UDT ((void *) &c, NULL, Cxe_AddMonoid, push_vector, NULL)) ;
11731173
LG_ASSERT ((c.residual == 6 && c.j == 5 && c.d == 4), GrB_PANIC) ;
11741174
}
11751175
else
@@ -1179,7 +1179,7 @@ int LAGr_MaxFlow
11791179
GRB_TRY (GrB_Vector_setElement_UDT (push_vector, (void *) &a, 0)) ;
11801180
GRB_TRY (GrB_Vector_setElement_UDT (push_vector, (void *) &b, 0)) ;
11811181
LG_MF_resultTuple32 c = {.d = 0, .j = 0, .residual = 0};
1182-
GRB_TRY (GrB_Vector_reduce_UDT ((void *) &c, NULL, MxeAddMonoid, push_vector, NULL)) ;
1182+
GRB_TRY (GrB_Vector_reduce_UDT ((void *) &c, NULL, Cxe_AddMonoid, push_vector, NULL)) ;
11831183
LG_ASSERT ((c.residual == 6 && c.j == 5 && c.d == 4), GrB_PANIC) ;
11841184
}
11851185
#endif

0 commit comments

Comments
 (0)