Merge pull request #288 from GraphBLAS/with_GraphBLAS_v10

testing diameter, multibfs, and maximum/maximal matching

Author: DrTimothyAldenDavis

experimental/algorithm/LAGr_MaximumMatching.c

@@ -451,6 +451,7 @@ invert_2(GrB_Vector out,  // input/output
         GrB_free(&getRootsOp);                                                 \
         GrB_free(&parentsUpdate);                                              \
         GrB_free(&ufrontierR);                                                 \
+        GrB_free(&mateC);                                                      \
         GrB_free(&mateR);                                                      \
         GrB_free(&rootsufR);                                                   \
         GrB_free(&pathUpdate);                                                 \
@@ -945,13 +946,16 @@ int LAGr_MaximumMatching(
     } while (npath); // only in the first and last iteration should this
                      // condition be false
 
+    // return result
     if (mateC_handle != NULL)
     {
         (*mateC_handle) = mateC;
+        mateC = NULL ;
     }
     if (mateR_handle != NULL)
     {
         (*mateR_handle) = mateR;
+        mateR = NULL ;
     }
     LG_FREE_WORK;
 

experimental/algorithm/LAGraph_EstimateDiameter.c

@@ -12,7 +12,6 @@
 //------------------------------------------------------------------------------
 
 // FIXME: almost ready for src; need to handle GxB
-// FIXME: need the CI test for this method
 
 // Takes in a graph and estimates the diameter 
 // and optionally also finds pseudo-peripheral nodes of the graph
@@ -157,6 +156,8 @@ int LAGraph_EstimateDiameter
     else
     {
         // srcs = randomized, still of size nsrcs-1, values in range 0 to UINT64_MAX
+        // FIXME: if the graph is very sparse, select nodes at random with at
+        // least one out-going edge.
         LAGRAPH_TRY (LAGraph_Random_Seed (srcs, seed, msg)) ;
         GRB_TRY (GxB_BinaryOp_new (&Mod,
             (n > INT32_MAX) ? ((GxB_binary_function)mod64) :

experimental/algorithm/LAGraph_ExactDiameter.c

@@ -12,7 +12,6 @@
 //------------------------------------------------------------------------------
 
 // FIXME: almost ready for src; says it's not vanilla but should be OK
-// FIXME: need the CI test for this method
 
 // Takes in a graph and finds the diameter 
 // and optionally also the peripheral nodes of the graph

experimental/algorithm/LAGraph_MaximalIndependentSet.c

@@ -300,7 +300,8 @@ int LAGraph_MaximalIndependentSet       // maximal independent set
             // This case is nearly untestable since it can almost never occur.
             nstall++ ;
             // terminate if the method has stalled too many times
-            LG_ASSERT_MSG (nstall <= 32, -111, "stall") ;
+            LG_ASSERT_MSG (nstall <= 32, LAGRAPH_CONVERGENCE_FAILURE,
+                "method has stalled") ;
             // recreate the random number seeds with a new starting seed
             LG_TRY (LAGraph_Random_Seed (Seed, seed + nstall, msg)) ;
         }

experimental/algorithm/LAGraph_MaximalMatching.c

@@ -240,12 +240,16 @@ int LAGraph_MaximalMatching
 
         if (max_degree > 1) {
             nfailures++ ;
+            LG_ASSERT_MSG (nfailures <= MAX_FAILURES, LAGRAPH_CONVERGENCE_FAILURE,
+                "method has stalled") ;
+#if 0
             if (nfailures > MAX_FAILURES) {
     #ifdef dbg
                 printf("[DBG] hit max failures %d\n", nfailures);
     #endif
-                break ; // FIXME: test coverage doesn't test this case.  Is it possible?
+                break ; // test coverage doesn't test this case.  Is it possible?
             }
+#endif
             // regen seed and seed vector
             LG_TRY (LAGraph_Random_Seed (Seed, seed + nfailures, msg)) ;
             continue ;

experimental/algorithm/LAGraph_MultiSourceBFS.c

@@ -12,7 +12,6 @@
 //------------------------------------------------------------------------------
 
 // FIXME: almost ready for src; need a vanilla method
-// FIXME: need the CI test for this method
 
 // Takes in a vector of source nodes and finds level and/or parent vectors for each,
 // stored together in a matrix
@@ -74,16 +73,17 @@ int LAGraph_MultiSourceBFS
     GrB_Matrix A = G->A ;
 
     GrB_Index nsrc; // holds the number of source nodes
-    GrB_Index n;
+    GrB_Index n, nvals ;
     GRB_TRY (GrB_Matrix_nrows (&n, A)) ;
+    GRB_TRY (GrB_Matrix_nvals (&nvals, A)) ;
     GRB_TRY (GrB_Vector_size (&nsrc, src)) ;
     for (int64_t s = 0; s < nsrc; s++) 
     {
         GrB_Index currsrc;
         GRB_TRY (GrB_Vector_extractElement (&currsrc, src, s)) ;
         LG_ASSERT_MSG (currsrc < n, GrB_INVALID_INDEX, "invalid source node") ;
     }
-
+    bool very_sparse = (nvals <= n/16) ;
 
     // determine the semiring type 
     GrB_Type int_type = (n > INT32_MAX) ? GrB_INT64 : GrB_INT32 ;
@@ -98,7 +98,10 @@ int LAGraph_MultiSourceBFS
 
         // create the parent matrix.  pi(i, j) is the parent id of node j in source i's BFS
         GRB_TRY (GrB_Matrix_new (&pi, int_type, nsrc, n)) ;
-        GRB_TRY (LG_SET_FORMAT_HINT (pi, LG_BITMAP + LG_FULL)) ;
+        if (!very_sparse)
+        {
+            GRB_TRY (LG_SET_FORMAT_HINT (pi, LG_BITMAP + LG_FULL)) ;
+        }
 
         // pi (i, src) = src denotes the root of that row's BFS tree
         for (int64_t s = 0; s < nsrc; s++) 
@@ -143,7 +146,10 @@ int LAGraph_MultiSourceBFS
         // create the level matrix. v(i,j) is the level of node j in source i's BFS
         // v (s, src) = 0 denotes the source node of that row
         GRB_TRY (GrB_Matrix_new (&v, int_type, nsrc, n)) ;
-        GRB_TRY (LG_SET_FORMAT_HINT (v, LG_BITMAP + LG_FULL)) ;
+        if (!very_sparse)
+        {
+            GRB_TRY (LG_SET_FORMAT_HINT (v, LG_BITMAP + LG_FULL)) ;
+        }
         for (int64_t s = 0; s < nsrc; s++) 
         {
             GrB_Index currsrc;

experimental/test/test_MaximalIndependentSet.c

@@ -225,7 +225,7 @@ void test_MIS (void)
         result = LAGraph_MaximalIndependentSet (&mis, G, 0, NULL, msg) ;
         random_hack = false ;
         printf ("hack msg: %d %s\n", result, msg) ;
-        TEST_CHECK (result == -111 || result == 0) ;
+        TEST_CHECK (result == LAGRAPH_CONVERGENCE_FAILURE || result == 0) ;
         if (result == 0)
         {
             OK (LG_check_mis (G->A, mis, NULL, msg)) ;

experimental/test/test_MaximumMatching.c

@@ -19,6 +19,19 @@ const char *filenames[NTESTS] = {"random_weighted_bipartite2.mtx",
                                  "lp_afiro_structure.mtx", "sources_7.mtx"};
 const uint64_t spranks[NTESTS] = {298, 2009, 14, 27, 1};
 
+#if 0
+#undef OK
+#define OK(method) \
+{ \
+    GrB_Info info2 = method ; \
+    if (info2 != GrB_SUCCESS) \
+    { \
+        printf ("info: %d, msg: %s\n", info2, msg) ; \
+        TEST_CHECK (false) ; \
+    } \
+}
+#endif
+
 void test_MCM(void)
 {
     LAGraph_Init(msg);
@@ -32,6 +45,7 @@ void test_MCM(void)
         for (uint64_t test = 0; test < NTESTS; test++)
         {
 
+            printf ("\n%s =======================\n", filenames [test]) ;
             GrB_Matrix A = NULL;
             GrB_Matrix AT = NULL;
             snprintf(filename, LEN, LG_DATA_DIR "%s", filenames[test]);
@@ -71,12 +85,16 @@ void test_MCM(void)
             OK(GrB_Vector_new(&mateC, GrB_UINT64, ncols));
 
             GrB_Vector mateC_init = NULL;
+            GrB_Vector mateR_init = NULL;
 
             if (!strcmp(filenames[test], "lp_afiro_structure.mtx"))
             {
                 OK(GrB_Vector_new(&mateC_init, GrB_UINT64, ncols));
+                OK(GrB_Vector_new(&mateR_init, GrB_UINT64, nrows));
                 OK(GrB_Vector_setElement_UINT64(
                     mateC_init, 0, 19)); // col 20 matched with row 1 (1-based)
+                OK(GrB_Vector_setElement_UINT64(
+                    mateR_init, 19, 0)); // col 20 matched with row 1 (1-based)
                 OK(GrB_Matrix_new(&AT, GrB_BOOL, ncols,
                                   nrows)); // transpose matrix has the reverse
                                            // dimensions from the original
@@ -85,7 +103,7 @@ void test_MCM(void)
 
             OK(LAGr_MaximumMatching(&mateC, NULL, A, AT, mateC_init, true,
                                     msg));
-            printf("\nmsg: %s\n", msg);
+//          printf("\nmsg: %s\n", msg);
 
             GrB_Index nmatched = 0;
 
@@ -105,6 +123,7 @@ void test_MCM(void)
             // if nvals of mateC and mateR don't match, then there's at least
             // one row that is used in at least one matching
             TEST_CHECK(nmatched == nmateR);
+            printf ("# of matches: %" PRIu64 "\n", nmatched) ;
 
             // pack matched values in a matrix
             GrB_Matrix M = NULL;
@@ -128,11 +147,44 @@ void test_MCM(void)
             // sprank must be equal to nvals of mateC (nmatched)
             TEST_CHECK(nmatched == spranks[test]);
 
-            OK(GrB_Vector_free(&mateC));
-            OK(GrB_Vector_free(&mateR));
-            OK(GrB_Matrix_free(&M));
-            OK(GrB_Matrix_free(&A));
-            OK(GrB_Matrix_free(&AT));
+            OK(GrB_free(&mateC));
+            OK(GrB_free(&mateR));
+            OK(GrB_free(&M));
+
+            // return both mateR and mateC
+            OK(LAGr_MaximumMatching(&mateC, &mateR, A, AT, mateC_init, true,
+                                    msg));
+            GrB_Index nmateC = 0 ;
+            nmateR = 0 ;
+            OK(GrB_Vector_nvals(&nmateC, mateC));
+            OK(GrB_Vector_nvals(&nmateR, mateR));
+            TEST_CHECK(nmateC == nmateR);
+            TEST_CHECK(nmateC == nmatched);
+            OK(GrB_free(&mateC));
+            OK(GrB_free(&mateR));
+
+            // ensure AT exists, and pass in AT only, and use mateR_init
+            if (AT == NULL)
+            {
+                OK(GrB_Matrix_new(&AT, GrB_BOOL, ncols, nrows));
+                OK(GrB_transpose(AT, NULL, NULL, A, NULL));
+            }
+            OK(LAGr_MaximumMatching(&mateC, &mateR, NULL, AT, mateR_init, false,
+                                    msg));
+            nmateC = 0 ;
+            nmateR = 0 ;
+            OK(GrB_Vector_nvals(&nmateC, mateC));
+            OK(GrB_Vector_nvals(&nmateR, mateR));
+            TEST_CHECK(nmateC == nmateR);
+            TEST_CHECK(nmateC == nmatched);
+            OK(GrB_free(&mateC));
+            OK(GrB_free(&mateR));
+
+            OK(GrB_free(&mateC_init));
+            OK(GrB_free(&mateR_init));
+            OK(GrB_free(&A));
+            OK(GrB_free(&AT));
+
         }
     }
     LAGraph_Finalize(msg);