[REVIEW] Subgraph extraction python bindings

cpp/include/nvgraph_gdf.h

@@ -132,6 +132,16 @@ gdf_error gdf_AnalyzeClustering_ratio_cut_nvgraph(gdf_graph* gdf_G,
                                                    gdf_column* clustering,
                                                    float* score);
 
+/**
+ * Wrapper function for Nvgraph extract subgraph by vertices
+ * @param gdf_G Pointer to GDF graph object, this is the input graph
+ * @param result Pointer to GDF graph object, this is the output must be a valid pointer
+ * @param vertices Pointer to GDF column object which contains the list of vertices to extract
+ * @return Error code
+ */
+gdf_error gdf_extract_subgraph_vertex_nvgraph(gdf_graph* gdf_G,
+                                              gdf_graph* result,
+                                              gdf_column* vertices);
 /**
  * Wrapper function for Nvgraph triangle counting
  * @param G Pointer to GDF graph object

cpp/src/nvgraph_gdf.cu

@@ -144,15 +144,15 @@ gdf_error gdf_createGraph_nvgraph(nvgraphHandle_t nvg_handle,
 																				0,
 																				settype,
 																				(float * ) gdf_G->transposedAdjList->edge_data->data))
-				break;
+					break;
 				case GDF_FLOAT64:
 					settype = CUDA_R_64F;
 					NVG_TRY(nvgraphAttachEdgeData(nvg_handle,
 																				*nvgraph_G,
 																				0,
 																				settype,
 																				(double * ) gdf_G->transposedAdjList->edge_data->data))
-				break;
+					break;
 				default:
 					return GDF_UNSUPPORTED_DTYPE;
 			}
@@ -183,15 +183,15 @@ gdf_error gdf_createGraph_nvgraph(nvgraphHandle_t nvg_handle,
 																				0,
 																				settype,
 																				(float * ) gdf_G->adjList->edge_data->data))
-				break;
+					break;
 				case GDF_FLOAT64:
 					settype = CUDA_R_64F;
 					NVG_TRY(nvgraphAttachEdgeData(nvg_handle,
 																				*nvgraph_G,
 																				0,
 																				settype,
 																				(double * ) gdf_G->adjList->edge_data->data))
-				break;
+					break;
 				default:
 					return GDF_UNSUPPORTED_DTYPE;
 			}
@@ -515,6 +515,69 @@ gdf_error gdf_AnalyzeClustering_ratio_cut_nvgraph(gdf_graph* gdf_G,
 	return GDF_SUCCESS;
 }
 
+
+gdf_error gdf_extract_subgraph_vertex_nvgraph(gdf_graph* gdf_G,
+																							gdf_graph* result,
+																							gdf_column* vertices) {
+	GDF_REQUIRE(gdf_G != nullptr, GDF_INVALID_API_CALL);
+	GDF_REQUIRE((gdf_G->adjList != nullptr) || (gdf_G->edgeList != nullptr), GDF_INVALID_API_CALL);
+	GDF_REQUIRE(vertices != nullptr, GDF_INVALID_API_CALL);
+	GDF_REQUIRE(vertices->data != nullptr, GDF_INVALID_API_CALL);
+	GDF_REQUIRE(!vertices->valid, GDF_VALIDITY_UNSUPPORTED);
+
+	// Initialize Nvgraph and wrap the graph
+	nvgraphHandle_t nvg_handle = nullptr;
+	nvgraphGraphDescr_t nvgraph_G = nullptr;
+	NVG_TRY(nvgraphCreate(&nvg_handle));
+	GDF_TRY(gdf_createGraph_nvgraph(nvg_handle, gdf_G, &nvgraph_G, false));
+
+	// Create an Nvgraph graph descriptor for the result and initialize
+	nvgraphGraphDescr_t nv_result = nullptr;
+	NVG_TRY(nvgraphCreateGraphDescr(nvg_handle, &nv_result));
+
+	// Call Nvgraph function to get subgraph (into nv_result descriptor)
+	NVG_TRY(nvgraphExtractSubgraphByVertex(	nvg_handle,
+																					nvgraph_G,
+																					nv_result,
+																					(int*)vertices->data,
+																					vertices->size));
+
+	// Get the vertices and edges of the created subgraph to allocate memory:
+	nvgraphCSRTopology32I_st topo;
+	topo.source_offsets = nullptr;
+	topo.destination_indices = nullptr;
+	nvgraphTopologyType_t TT = NVGRAPH_CSR_32;
+	NVG_TRY(nvgraphGetGraphStructure(nvg_handle, nv_result, (void*)&topo, &TT));
+	if (TT != NVGRAPH_CSR_32)
+		return GDF_C_ERROR;
+	int num_verts = topo.nvertices;
+	int num_edges = topo.nedges;
+	result->adjList = new gdf_adj_list;
+	result->adjList->offsets = new gdf_column;
+	result->adjList->indices = new gdf_column;
+	result->adjList->ownership = 0;
+	int *offsets, *indices;
+	CUDA_TRY(cudaMallocManaged((void**)&offsets, sizeof(int) * (num_verts + 1)));
+	CUDA_TRY(cudaMallocManaged((void**)&indices, sizeof(int) * num_edges));
+	gdf_column_view(result->adjList->offsets,
+	                offsets,
+	                nullptr,
+	                num_verts + 1,
+	                GDF_INT32);
+	gdf_column_view(result->adjList->indices,
+	                indices,
+	                nullptr,
+	                num_edges,
+	                GDF_INT32);
+
+	// Call nvgraphGetGraphStructure again to copy out the data
+	topo.source_offsets = (int*)result->adjList->offsets->data;
+	topo.destination_indices = (int*)result->adjList->indices->data;
+	NVG_TRY(nvgraphGetGraphStructure(nvg_handle, nv_result, (void*)&topo, &TT));
+
+	return GDF_SUCCESS;
+}
+
 gdf_error gdf_triangle_count_nvgraph(gdf_graph* G, uint64_t* result) {
   GDF_REQUIRE(G != nullptr, GDF_INVALID_API_CALL);
   GDF_REQUIRE((G->adjList != nullptr) || (G->edgeList != nullptr), GDF_INVALID_API_CALL);

python/cugraph/cugraph.pyx

@@ -28,4 +28,5 @@ include "grmat/grmat_wrapper.pyx"
 include "louvain/louvain_wrapper.pyx"
 include "bfs/bfs_wrapper.pyx"
 include "spectral_clustering/spectral_clustering.pyx"
-include "triangle_count/triangle_count_wrapper.pyx"
+include "subgraph_extraction/subgraph_extraction.pyx"
+include "triangle_count/triangle_count_wrapper.pyx"

python/cugraph/nvgraph/c_nvgraph.pxd

@@ -52,6 +52,10 @@ cdef extern from "nvgraph_gdf.h":
     cdef gdf_error gdf_AnalyzeClustering_ratio_cut_nvgraph(gdf_graph* gdf_G,
                                                             const int n_clusters,
                                                             gdf_column* clustering,
-                                                            float* score) 
+                                                            float* score)
+
+    cdef gdf_error gdf_extract_subgraph_vertex_nvgraph(gdf_graph* gdf_G,
+                                                       gdf_graph* result,
+                                                       gdf_column* vertices) 
 
-    cdef gdf_error gdf_triangle_count_nvgraph(gdf_graph* G, uint64_t* result)                              
+    cdef gdf_error gdf_triangle_count_nvgraph(gdf_graph* G, uint64_t* result)                              

python/cugraph/subgraph_extraction/subgraph_extraction.pyx

@@ -0,0 +1,68 @@
+# Copyright (c) 2019, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from c_nvgraph cimport * 
+from c_graph cimport * 
+from libcpp cimport bool
+from libc.stdint cimport uintptr_t
+from libc.stdlib cimport calloc, malloc, free
+from libc.float cimport FLT_MAX_EXP
+import cudf
+from librmm_cffi import librmm as rmm
+import numpy as np
+
+cpdef subgraph(G, vertices):
+    """
+    Compute a clustering/partitioning of the given graph using the spectral balanced
+    cut method.
+
+    Parameters
+    ----------
+    G : cuGraph.Graph                  
+       cuGraph graph descriptor
+    vertices : cudf.Series
+        Specifies the vertices of the induced subgraph
+
+    Returns
+    -------
+    Sg : cuGraph.Graph
+        A graph object containing the subgraph induced by the given vertex set.
+
+    Example:
+    --------
+    >>> M = ReadMtxFile(graph_file)
+    >>> sources = cudf.Series(M.row)
+    >>> destinations = cudf.Series(M.col)
+    >>> G = cuGraph.Graph()
+    >>> G.add_edge_list(sources,destinations,None)
+    >>> verts = numpy.zeros(3, dtype=np.int32)
+    >>> verts[0] = 0
+    >>> verts[1] = 1
+    >>> verts[2] = 2
+    >>> sverts = cudf.Series(verts)
+    >>> Sg = cuGraph.subgraph(G, sverts)
+    """
+
+    cdef uintptr_t graph = G.graph_ptr
+    cdef gdf_graph * g = < gdf_graph *> graph
+
+    resultGraph = Graph()
+    cdef uintptr_t rGraph = resultGraph.graph_ptr
+    cdef gdf_graph* rg = <gdf_graph*>rGraph
+
+    cdef gdf_column vert_col = get_gdf_column_view(vertices)
+
+    err = gdf_extract_subgraph_vertex_nvgraph(g, rg, &vert_col)
+    cudf.bindings.cudf_cpp.check_gdf_error(err)
+
+    return resultGraph

python/cugraph/subgraph_extraction/test_subgraph_extraction.py

@@ -0,0 +1,65 @@
+# Copyright (c) 2019, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import cugraph
+import cudf
+import pytest
+import numpy as np
+import networkx as nx
+from scipy.io import mmread
+
+def compareEdges(cg, nxg, verts):
+    src, dest = cg.view_edge_list()
+    if (len(src) != nxg.size()):
+        assert False
+    for i in range(len(src)):
+        if not nxg.has_edge(verts[src[i]], verts[dest[i]]):
+            assert False
+    return True
+
+def ReadMtxFile(mmFile):
+    print('Reading '+ str(mmFile) + '...')
+    return mmread(mmFile).asfptype()
+
+def cugraph_call(M, verts):
+    G = cugraph.Graph()
+    rows = cudf.Series(M.row)
+    cols = cudf.Series(M.col)
+    G.add_edge_list(rows, cols, None)
+    cu_verts = cudf.Series(verts)
+    Sg = cugraph.subgraph(G, cu_verts)
+    return Sg
+
+def nx_call(M, verts):
+    G = nx.DiGraph(M)
+    Sg = nx.subgraph(G, verts)
+    return Sg
+
+datasets = ['/datasets/networks/karate.mtx', 
+            '/datasets/networks/dolphins.mtx', 
+            '/datasets/networks/netscience.mtx']
+
+@pytest.mark.parametrize('graph_file', datasets)
+def test_subgraph_extraction(graph_file):
+    M = ReadMtxFile(graph_file)
+    verts = np.zeros(3, dtype=np.int32)
+    verts[0] = 0
+    verts[1] = 1
+    verts[2] = 17
+    cu_Sg = cugraph_call(M, verts)
+    nx_Sg = nx_call(M, verts)
+    assert compareEdges(cu_Sg, nx_Sg, verts)
+
+
+
+