nvGRAPH API參考分析(二)

wujianming_110117發表於2020-12-25

nvGRAPH API參考分析(二)
nvGRAPH Code Examples
本文提供了簡單的示例。

  1. nvGRAPH convert topology example
    void check(nvgraphStatus_t status) {
    if (status != NVGRAPH_STATUS_SUCCESS) {
    printf(“ERROR : %d\n”,status);
    exit(0);
    }
    }
    int main(int argc, char argv) {
    size_t n = 6, nnz = 10;
    // nvgraph variables
    nvgraphHandle_t handle;
    nvgraphCSCTopology32I_t CSC_input;
    nvgraphCSRTopology32I_t CSR_output;
    float src_weights_d, dst_weights_d;
    cudaDataType_t edge_dimT = CUDA_R_32F;
    // Allocate source data
    CSC_input = (nvgraphCSCTopology32I_t) malloc(sizeof(struct nvgraphCSCTopology32I_st));
    CSC_input->nvertices = n; CSC_input->nedges = nnz;
    cudaMalloc( (void
    )&(CSC_input->destination_offsets), (n+1)sizeof(int));
    cudaMalloc( (void
    )&(CSC_input->source_indices), nnzsizeof(int));
    cudaMalloc( (void
    *)&src_weights_d, nnz
    sizeof(float));
    // Copy source data
    float src_weights_h[] = {0.333333f, 0.5f, 0.333333f, 0.5f, 0.5f, 1.0f, 0.333333f, 0.5f, 0.5f, 0.5f};
    int destination_offsets_h[] = {0, 1, 3, 4, 6, 8, 10};
    int source_indices_h[] = {2, 0, 2, 0, 4, 5, 2, 3, 3, 4};
    cudaMemcpy(CSC_input->destination_offsets, destination_offsets_h, (n+1)sizeof(int), cudaMemcpyDefault);
    cudaMemcpy(CSC_input->source_indices, source_indices_h, nnz
    sizeof(int), cudaMemcpyDefault);
    cudaMemcpy(src_weights_d, src_weights_h, nnzsizeof(float), cudaMemcpyDefault);
    // Allocate destination data
    CSR_output = (nvgraphCSRTopology32I_t) malloc(sizeof(struct nvgraphCSRTopology32I_st));
    cudaMalloc( (void**)&(CSR_output->source_offsets), (n+1)sizeof(int));
    cudaMalloc( (void
    *)&(CSR_output->destination_indices), nnz
    sizeof(int));
    cudaMalloc( (void**)&dst_weights_d, nnz*sizeof(float));
    // Starting nvgraph and convert
    check(nvgraphCreate (&handle));
    check(nvgraphConvertTopology(handle, NVGRAPH_CSC_32, CSC_input, src_weights_d,
    &edge_dimT, NVGRAPH_CSR_32, CSR_output, dst_weights_d));
    // Free memory
    check(nvgraphDestroy(handle));
    cudaFree(CSC_input->destination_offsets);
    cudaFree(CSC_input->source_indices);
    cudaFree(CSR_output->source_offsets);
    cudaFree(CSR_output->destination_indices);
    cudaFree(src_weights_d);
    cudaFree(dst_weights_d);
    free(CSC_input);
    free(CSR_output);
    return 0;
    }

  2. nvGRAPH convert graph example
    void check(nvgraphStatus_t status) {
    if (status != NVGRAPH_STATUS_SUCCESS) {
    printf(“ERROR : %d\n”,status);
    exit(0);
    }
    }
    int main(int argc, char argv) {
    size_t n = 6, nnz = 10, vert_sets = 2, edge_sets = 1;
    // nvgraph variables
    nvgraphHandle_t handle; nvgraphGraphDescr_t src_csc_graph;
    nvgraphCSCTopology32I_t CSC_input;
    cudaDataType_t edge_dimT = CUDA_R_32F;
    cudaDataType_t
    vertex_dimT;
    // Allocate host data
    float pr_1 = (float)malloc(nsizeof(float));
    void vertex_dim = (void)malloc(vert_sets
    sizeof(void
    ));
    vertex_dimT = (cudaDataType_t*)malloc(vert_setssizeof(cudaDataType_t));
    CSC_input = (nvgraphCSCTopology32I_t) malloc(sizeof(struct nvgraphCSCTopology32I_st));
    // Initialize host data
    float weights_h[] = {0.333333f, 0.5f, 0.333333f, 0.5f, 0.5f, 1.0f, 0.333333f, 0.5f, 0.5f, 0.5f};
    int destination_offsets_h[] = {0, 1, 3, 4, 6, 8, 10};
    int source_indices_h[] = {2, 0, 2, 0, 4, 5, 2, 3, 3, 4};
    float bookmark_h[] = {0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f};
    vertex_dim[0] = (void
    )bookmark_h; vertex_dim[1]= (void*)pr_1;
    vertex_dimT[0] = CUDA_R_32F; vertex_dimT[1]= CUDA_R_32F, vertex_dimT[2]= CUDA_R_32F;
    // Starting nvgraph
    check(nvgraphCreate (&handle));
    check(nvgraphCreateGraphDescr (handle, &src_csc_graph));
    CSC_input->nvertices = n; CSC_input->nedges = nnz;
    CSC_input->destination_offsets = destination_offsets_h;
    CSC_input->source_indices = source_indices_h;
    // Set graph connectivity and properties (tranfers)
    check(nvgraphSetGraphStructure(handle, src_csc_graph, (void*)CSC_input, NVGRAPH_CSC_32));
    check(nvgraphAllocateVertexData(handle, src_csc_graph, vert_sets, vertex_dimT));
    check(nvgraphAllocateEdgeData (handle, src_csc_graph, edge_sets, &edge_dimT));
    for (int i = 0; i < 2; ++i)
    check(nvgraphSetVertexData(handle, src_csc_graph, vertex_dim[i], i));
    check(nvgraphSetEdgeData(handle, src_csc_graph, (void*)weights_h, 0));
    // Convert to CSR graph
    nvgraphGraphDescr_t dst_csr_graph;
    check(nvgraphCreateGraphDescr (handle, &dst_csr_graph));
    check(nvgraphConvertGraph(handle, src_csc_graph, dst_csr_graph, NVGRAPH_CSR_32));
    check(nvgraphDestroyGraphDescr(handle, src_csc_graph));
    check(nvgraphDestroyGraphDescr(handle, dst_csr_graph));
    check(nvgraphDestroy(handle));
    free(pr_1); free(vertex_dim); free(vertex_dimT);
    free(CSC_input);
    return 0;
    }

  3. nvGRAPH pagerank example
    void check(nvgraphStatus_t status) {
    if (status != NVGRAPH_STATUS_SUCCESS) {
    printf(“ERROR : %d\n”,status);
    exit(0);
    }
    }
    int main(int argc, char argv) {
    size_t n = 6, nnz = 10, vert_sets = 2, edge_sets = 1;
    float alpha1 = 0.9f; void alpha1_p = (void ) &alpha1;
    // nvgraph variables
    nvgraphHandle_t handle; nvgraphGraphDescr_t graph;
    nvgraphCSCTopology32I_t CSC_input;
    cudaDataType_t edge_dimT = CUDA_R_32F;
    cudaDataType_t
    vertex_dimT;
    // Allocate host data
    float pr_1 = (float)malloc(n
    sizeof(float));
    void vertex_dim = (void)malloc(vert_setssizeof(void));
    vertex_dimT = (cudaDataType_t
    )malloc(vert_setssizeof(cudaDataType_t));
    CSC_input = (nvgraphCSCTopology32I_t) malloc(sizeof(struct nvgraphCSCTopology32I_st));
    // Initialize host data
    float weights_h[] = {0.333333f, 0.5f, 0.333333f, 0.5f, 0.5f, 1.0f, 0.333333f, 0.5f, 0.5f, 0.5f};
    int destination_offsets_h[] = {0, 1, 3, 4, 6, 8, 10};
    int source_indices_h[] = {2, 0, 2, 0, 4, 5, 2, 3, 3, 4};
    float bookmark_h[] = {0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f};
    vertex_dim[0] = (void
    )bookmark_h; vertex_dim[1]= (void
    )pr_1;
    vertex_dimT[0] = CUDA_R_32F; vertex_dimT[1]= CUDA_R_32F, vertex_dimT[2]= CUDA_R_32F;
    // Starting nvgraph
    check(nvgraphCreate (&handle));
    check(nvgraphCreateGraphDescr (handle, &graph));
    CSC_input->nvertices = n; CSC_input->nedges = nnz;
    CSC_input->destination_offsets = destination_offsets_h;
    CSC_input->source_indices = source_indices_h;
    // Set graph connectivity and properties (tranfers)
    check(nvgraphSetGraphStructure(handle, graph, (void*)CSC_input, NVGRAPH_CSC_32));
    check(nvgraphAllocateVertexData(handle, graph, vert_sets, vertex_dimT));
    check(nvgraphAllocateEdgeData (handle, graph, edge_sets, &edge_dimT));
    for (int i = 0; i < 2; ++i)
    check(nvgraphSetVertexData(handle, graph, vertex_dim[i], i));
    check(nvgraphSetEdgeData(handle, graph, (void*)weights_h, 0));

    check(nvgraphPagerank(handle, graph, 0, alpha1_p, 0, 0, 1, 0.0f, 0));
    // Get result
    check(nvgraphGetVertexData(handle, graph, vertex_dim[1], 1));
    check(nvgraphDestroyGraphDescr(handle, graph));
    check(nvgraphDestroy(handle));
    free(pr_1); free(vertex_dim); free(vertex_dimT);
    free(CSC_input);
    return 0;
    }

  4. nvGRAPH SSSP example
    void check(nvgraphStatus_t status) {
    if (status != NVGRAPH_STATUS_SUCCESS) {
    printf(“ERROR : %d\n”,status);
    exit(0);
    }
    }
    int main(int argc, char argv) {
    const size_t n = 6, nnz = 10, vertex_numsets = 1, edge_numsets = 1;
    float sssp_1_h;
    void
    vertex_dim;
    // nvgraph variables
    nvgraphStatus_t status; nvgraphHandle_t handle;
    nvgraphGraphDescr_t graph;
    nvgraphCSCTopology32I_t CSC_input;
    cudaDataType_t edge_dimT = CUDA_R_32F;
    cudaDataType_t
    vertex_dimT;
    // Init host data
    sssp_1_h = (float*)malloc(nsizeof(float));
    vertex_dim = (void**)malloc(vertex_numsets
    sizeof(void*));
    vertex_dimT = (cudaDataType_t*)malloc(vertex_numsetssizeof(cudaDataType_t));
    CSC_input = (nvgraphCSCTopology32I_t) malloc(sizeof(struct nvgraphCSCTopology32I_st));
    vertex_dim[0]= (void
    )sssp_1_h; vertex_dimT[0] = CUDA_R_32F;
    float weights_h[] = {0.333333, 0.5, 0.333333, 0.5, 0.5, 1.0, 0.333333, 0.5, 0.5, 0.5};
    int destination_offsets_h[] = {0, 1, 3, 4, 6, 8, 10};
    int source_indices_h[] = {2, 0, 2, 0, 4, 5, 2, 3, 3, 4};
    check(nvgraphCreate(&handle));
    check(nvgraphCreateGraphDescr (handle, &graph));
    CSC_input->nvertices = n; CSC_input->nedges = nnz;
    CSC_input->destination_offsets = destination_offsets_h;
    CSC_input->source_indices = source_indices_h;
    // Set graph connectivity and properties (tranfers)
    check(nvgraphSetGraphStructure(handle, graph, (void*)CSC_input, NVGRAPH_CSC_32));
    check(nvgraphAllocateVertexData(handle, graph, vertex_numsets, vertex_dimT));
    check(nvgraphAllocateEdgeData (handle, graph, edge_numsets, &edge_dimT));
    check(nvgraphSetEdgeData(handle, graph, (void*)weights_h, 0));
    // Solve
    int source_vert = 0;
    check(nvgraphSssp(handle, graph, 0, &source_vert, 0));
    // Get and print result
    check(nvgraphGetVertexData(handle, graph, (void*)sssp_1_h, 0));
    //Clean
    free(sssp_1_h); free(vertex_dim);
    free(vertex_dimT); free(CSC_input);
    check(nvgraphDestroyGraphDescr(handle, graph));
    check(nvgraphDestroy(handle));
    return 0;
    }

  5. nvGRAPH Semi-Ring SPMV example
    void check(nvgraphStatus_t status) {
    if (status != NVGRAPH_STATUS_SUCCESS) {
    printf(“ERROR : %d\n”,status);
    exit(0);
    }
    }
    int main(int argc, char argv) {
    size_t n = 5, nnz = 10, vertex_numsets = 2, edge_numsets = 1;
    float alpha = 1.0, beta = 0.0;
    void alpha_p = (void )&alpha, beta_p = (void
    void
    vertex_dim;
    cudaDataType_t edge_dimT = CUDA_R_32F;
    cudaDataType_t
    vertex_dimT;
    // nvgraph variables
    nvgraphStatus_t status; nvgraphHandle_t handle;
    nvgraphGraphDescr_t graph;
    nvgraphCSRTopology32I_t CSR_input;
    // Init host data
    vertex_dim = (void
    )malloc(vertex_numsetssizeof(void));
    vertex_dimT = (cudaDataType_t
    )malloc(vertex_numsetssizeof(cudaDataType_t));
    CSR_input = (nvgraphCSRTopology32I_t) malloc(sizeof(struct nvgraphCSRTopology32I_st));
    float x_h[] = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f};
    float y_h[] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
    vertex_dim[0]= (void
    )x_h; vertex_dim[1]= (void*)y_h;
    vertex_dimT[0] = CUDA_R_32F; vertex_dimT[1]= CUDA_R_32F;
    float weights_h[] = {1.0f, 4.0f, 2.0f, 3.0f, 5.0f, 7.0f, 8.0f, 9.0f, 6.0f, 1.5f};
    int source_offsets_h[] = {0, 2, 4, 7, 9, 10};
    int destination_indices_h[] = {0, 1, 1, 2, 0, 3, 4, 2, 4, 2};
    check(nvgraphCreate(&handle));
    check(nvgraphCreateGraphDescr(handle, &graph));
    CSR_input->nvertices = n; CSR_input->nedges = nnz;
    CSR_input->source_offsets = source_offsets_h;
    CSR_input->destination_indices = destination_indices_h;
    // Set graph connectivity and properties (tranfers)
    check(nvgraphSetGraphStructure(handle, graph, (void*)CSR_input, NVGRAPH_CSR_32));
    check(nvgraphAllocateVertexData(handle, graph, vertex_numsets, vertex_dimT));
    for (int i = 0; i < vertex_numsets; ++i)
    check(nvgraphSetVertexData(handle, graph, vertex_dim[i], i));
    check(nvgraphAllocateEdgeData (handle, graph, edge_numsets, &edge_dimT));
    check(nvgraphSetEdgeData(handle, graph, (void*)weights_h, 0));
    // Solve
    check(nvgraphSrSpmv(handle, graph, 0, alpha_p, 0, beta_p, 1, NVGRAPH_PLUS_TIMES_SR));
    //Get result
    check(nvgraphGetVertexData(handle, graph, (void*)y_h, 1));
    //Clean
    check(nvgraphDestroyGraphDescr(handle, graph));
    check(nvgraphDestroy(handle));
    free(vertex_dim); free(vertex_dimT); free(CSR_input);
    return 0;
    }

  6. nvGRAPH Triangles Counting example
    #include “stdlib.h”
    #include “inttypes.h”
    #include “stdio.h”

#include “nvgraph.h”

#define check( a )
{
nvgraphStatus_t status = (a);
if ( (status) != NVGRAPH_STATUS_SUCCESS) {
printf(“ERROR : %d in %s : %d\n”, status, FILE , LINE );
exit(0);
}
}

int main(int argc, char **argv)
{
// nvgraph variables
nvgraphHandle_t handle;
nvgraphGraphDescr_t graph;
nvgraphCSRTopology32I_t CSR_input;

// Init host data
CSR_input = (nvgraphCSRTopology32I_t) malloc(sizeof(struct nvgraphCSRTopology32I_st));

// Undirected graph:
// 0       2-------4       
//  \     / \     / \
//   \   /   \   /   \
//    \ /     \ /     \
//     1-------3-------5
// 3 triangles
// CSR of lower triangular of adjacency matrix:
const size_t n = 6, nnz = 8;
int source_offsets[] = {0, 0, 1, 2, 4, 6, 8};
int destination_indices[] = {0, 1, 1, 2, 2, 3, 3, 4};

check(nvgraphCreate(&handle));
check(nvgraphCreateGraphDescr (handle, &graph));
CSR_input->nvertices = n; 
CSR_input->nedges = nnz;
CSR_input->source_offsets = source_offsets;
CSR_input->destination_indices = destination_indices;
// Set graph connectivity
check(nvgraphSetGraphStructure(handle, graph, (void*)CSR_input, NVGRAPH_CSR_32));

uint64_t trcount = 0;
check(nvgraphTriangleCount(handle, graph, &trcount));
printf("Triangles count: %" PRIu64 "\n", trcount);

free(CSR_input);
check(nvgraphDestroyGraphDescr(handle, graph));
check(nvgraphDestroy(handle));
return 0;

}

  1. nvGRAPH Traversal example
    void check_status(nvgraphStatus_t status){
    if ((int)status != 0) {
    printf(“ERROR : %d\n”,status);
    exit(0);
    }
    }
    int main(int argc, char argv){
    //Example of graph (CSR format)
    const size_t n = 7, nnz = 12, vertex_numsets = 2, edge_numset = 0;
    int source_offsets_h[] = {0, 1, 3, 4, 6, 8, 10, 12};
    int destination_indices_h[] = {5, 0, 2, 0, 4, 5, 2, 3, 3, 4, 1, 5};
    //where to store results (distances from source) and where to store results (predecessors in search tree)
    int bfs_distances_h[n], bfs_predecessors_h[n];
    // nvgraph variables
    nvgraphStatus_t status;
    nvgraphHandle_t handle;
    nvgraphGraphDescr_t graph;
    nvgraphCSRTopology32I_t CSR_input;
    cudaDataType_t
    vertex_dimT;
    size_t distances_index = 0;
    size_t predecessors_index = 1;
    vertex_dimT = (cudaDataType_t
    )malloc(vertex_numsetssizeof(cudaDataType_t));
    vertex_dimT[distances_index] = CUDA_R_32I;
    vertex_dimT[predecessors_index] = CUDA_R_32I;
    //Creating nvgraph objects
    check_status(nvgraphCreate (&handle));
    check_status(nvgraphCreateGraphDescr (handle, &graph));
    // Set graph connectivity and properties (tranfers)
    CSR_input = (nvgraphCSRTopology32I_t) malloc(sizeof(struct nvgraphCSCTopology32I_st));
    CSR_input->nvertices = n;
    CSR_input->nedges = nnz;
    CSR_input->source_offsets = source_offsets_h;
    CSR_input->destination_indices = destination_indices_h;
    check_status(nvgraphSetGraphStructure(handle, graph, (void
    )CSR_input, NVGRAPH_CSR_32));
    check_status(nvgraphAllocateVertexData(handle, graph, vertex_numsets, vertex_dimT));
    int source_vert = 1;
    //Setting the traversal parameters
    nvgraphTraversalParameter_t traversal_param;
    nvgraphTraversalParameterInit(&traversal_param);
    nvgraphTraversalSetDistancesIndex(&traversal_param, distances_index);
    nvgraphTraversalSetPredecessorsIndex(&traversal_param, predecessors_index);
    nvgraphTraversalSetUndirectedFlag(&traversal_param, false);
    //Computing traversal using BFS algorithm
    check_status(nvgraphTraversal(handle, graph, NVGRAPH_TRAVERSAL_BFS, &source_vert, traversal_param));
    // Get result
    check_status(nvgraphGetVertexData(handle, graph, (void*)bfs_distances_h, distances_index));
    check_status(nvgraphGetVertexData(handle, graph, (void*)bfs_predecessors_h, predecessors_index));
    // expect bfs distances_h = (1 0 1 3 3 2 2147483647)
    for (int i = 0; i<n; i++) printf(“Distance to vertex %d: %i\n”,i, bfs_distances_h[i]); printf("\n");
    // expect bfs predecessors = (1 -1 1 5 5 0 -1)
    for (int i = 0; i<n; i++) printf(“Predecessor of vertex %d: %i\n”,i, bfs_predecessors_h[i]); printf("\n");
    free(vertex_dimT);
    free(CSR_input);
    check_status(nvgraphDestroyGraphDescr (handle, graph));
    check_status(nvgraphDestroy (handle));
    return 0;
    }

相關文章