(maxFlow) using new process and driver

Author: cvvergara

include/max_flow/maxflow.hpp

@@ -44,6 +44,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 #include "c_types/flow_t.h"
 #include "cpp_common/edge_t.hpp"
+#include "c_common/enums.h"
 #include "c_types/path_rt.h"
 #include "cpp_common/interruption.hpp"
 
@@ -107,10 +108,10 @@ class PgrFlowGraph {
      }
 
      PgrFlowGraph(
-             const std::vector<Edge_t> &edges,
-             const std::set<int64_t> &source_vertices,
-             const std::set<int64_t> &sink_vertices,
-             int algorithm);
+             const std::vector<Edge_t>&,
+             const std::set<int64_t>&,
+             const std::set<int64_t>&,
+             Which);
 
      PgrFlowGraph(
              const std::vector<Edge_t> &edges,

src/max_flow/CMakeLists.txt

@@ -7,7 +7,9 @@ ADD_LIBRARY(max_flow OBJECT
     maximum_cardinality_matching.c
     edge_disjoint_paths.c
 
-    max_flow_driver.cpp
+    maxFlow_driver.cpp
+    maxFlow_process.cpp
+
     maximum_cardinality_matching_driver.cpp
     edge_disjoint_paths_driver.cpp
     minCostMaxFlow_driver.cpp

src/max_flow/max_flow.c

@@ -31,124 +31,56 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 #include "c_common/postgres_connection.h"
 
-#include "c_common/debug_macro.h"
-#include "c_common/e_report.h"
-#include "c_common/time_msg.h"
-#include "drivers/max_flow/max_flow_driver.h"
-
 #include "c_types/flow_t.h"
 
-PGDLLEXPORT Datum
-_pgr_maxflow(PG_FUNCTION_ARGS);
-
-static
-void
-process(
-        char *edges_sql,
-        char *combinations_sql,
-        ArrayType *starts,
-        ArrayType *ends,
-        int algorithm,
-        bool only_flow,
-        Flow_t **result_tuples,
-        size_t *result_count) {
-    if (algorithm < 1 || algorithm > 3) {
-        elog(ERROR, "Unknown algorithm");
-    }
-
-    pgr_SPI_connect();
-    char* log_msg = NULL;
-    char* notice_msg = NULL;
-    char* err_msg = NULL;
-
-    clock_t start_t = clock();
-    pgr_do_max_flow(
-            edges_sql,
-            combinations_sql,
-            starts, ends,
-
-            algorithm,
-            only_flow,
-
-            result_tuples, result_count,
-
-            &log_msg,
-            &notice_msg,
-            &err_msg);
-
-    if (only_flow) {
-        time_msg("pgr_maxFlow(many to many)", start_t, clock());
-    } else if (algorithm == 1) {
-        time_msg("pgr_maxFlowPushRelabel(many to many)", start_t, clock());
-    } else if (algorithm == 3) {
-        time_msg("pgr_maxFlowEdmondsKarp(many to many)", start_t, clock());
-    } else {
-        time_msg("pgr_maxFlowBoykovKolmogorov(many to many)", start_t, clock());
-    }
-
-    if (err_msg && (*result_tuples)) {
-        pfree(*result_tuples);
-        (*result_tuples) = NULL;
-        (*result_count) = 0;
-    }
+#include "process/maxFlow_process.h"
 
-    pgr_global_report(&log_msg, &notice_msg, &err_msg);
-
-    pgr_SPI_finish();
-}
+PGDLLEXPORT Datum _pgr_maxflow(PG_FUNCTION_ARGS);
+PG_FUNCTION_INFO_V1(_pgr_maxflow);
 
 
-PG_FUNCTION_INFO_V1(_pgr_maxflow);
-PGDLLEXPORT Datum
-_pgr_maxflow(PG_FUNCTION_ARGS) {
-    FuncCallContext *funcctx;
-    TupleDesc tuple_desc;
+PGDLLEXPORT Datum _pgr_maxflow(PG_FUNCTION_ARGS) {
+    FuncCallContext     *funcctx;
+    TupleDesc           tuple_desc;
 
-    /**************************************************************************/
-    Flow_t *result_tuples = 0;
+    Flow_t *result_tuples = NULL;
     size_t result_count = 0;
-    /**************************************************************************/
 
     if (SRF_IS_FIRSTCALL()) {
-        MemoryContext oldcontext;
+        MemoryContext   oldcontext;
         funcctx = SRF_FIRSTCALL_INIT();
         oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
-
-        /**********************************************************************/
-
         if (PG_NARGS() == 5) {
             /*
              * many to many
              */
-            process(
+            pgr_process_maxFlow(
                 text_to_cstring(PG_GETARG_TEXT_P(0)),
                 NULL,
+
                 PG_GETARG_ARRAYTYPE_P(1),
                 PG_GETARG_ARRAYTYPE_P(2),
-                PG_GETARG_INT32(3),
-                PG_GETARG_BOOL(4),
+                PG_GETARG_BOOL(4)? MAXFLOW : MAXFLOW + PG_GETARG_INT32(3),
                 &result_tuples,
                 &result_count);
 
         } else if (PG_NARGS() == 4) {
             /*
              * combinations
              */
-            process(
+            pgr_process_maxFlow(
                 text_to_cstring(PG_GETARG_TEXT_P(0)),
                 text_to_cstring(PG_GETARG_TEXT_P(1)),
+
                 NULL,
                 NULL,
-                PG_GETARG_INT32(2),
-                PG_GETARG_BOOL(3),
+
+                PG_GETARG_BOOL(3)? MAXFLOW : MAXFLOW + PG_GETARG_INT32(2),
                 &result_tuples,
                 &result_count);
         }
 
-        /*                                                                    */
-        /**********************************************************************/
-
         funcctx->max_calls = result_count;
         funcctx->user_fctx = result_tuples;
         if (get_call_result_type(fcinfo, NULL, &tuple_desc)
@@ -168,14 +100,13 @@ _pgr_maxflow(PG_FUNCTION_ARGS) {
     result_tuples = (Flow_t *) funcctx->user_fctx;
 
     if (funcctx->call_cntr < funcctx->max_calls) {
-        HeapTuple tuple;
-        Datum result;
-        Datum *values;
-        bool *nulls;
+        HeapTuple    tuple;
+        Datum        result;
+        Datum        *values;
+        bool*        nulls;
+
         size_t call_cntr = funcctx->call_cntr;
 
-        /**********************************************************************/
-        /*                          MODIFY AS NEEDED                          */
         values = palloc(6 * sizeof(Datum));
         nulls = palloc(6 * sizeof(bool));
 
@@ -190,7 +121,6 @@ _pgr_maxflow(PG_FUNCTION_ARGS) {
         values[3] = Int64GetDatum(result_tuples[call_cntr].target);
         values[4] = Int64GetDatum(result_tuples[call_cntr].flow);
         values[5] = Int64GetDatum(result_tuples[call_cntr].residual_capacity);
-        /**********************************************************************/
 
         tuple = heap_form_tuple(tuple_desc, values, nulls);
         result = HeapTupleGetDatum(tuple);

src/max_flow/maxflow.cpp

@@ -40,17 +40,25 @@ PgrFlowGraph::PgrFlowGraph(
         const std::vector<Edge_t> &edges,
         const std::set<int64_t> &source_vertices,
         const std::set<int64_t> &sink_vertices,
-        int algorithm) {
+        Which algorithm) {
     add_vertices(edges, source_vertices, sink_vertices);
 
     capacity = get(boost::edge_capacity, graph);
     rev = get(boost::edge_reverse, graph);
     residual_capacity = get(boost::edge_residual_capacity, graph);
 
-    if (algorithm == 1) {
-        insert_edges_push_relabel(edges);
-    } else {
-        insert_edges(edges);
+    switch (algorithm) {
+        case MAXFLOW:
+        case PUSHRELABEL:
+            insert_edges_push_relabel(edges);
+            break;
+        case BOYKOV:
+        case EDMONDSKARP:
+            insert_edges(edges);
+            break;
+        default:
+            ;
+            /* Maybe do a throw */
     }
 }