void graph_color_symbolic(KernelHandle *handle){ Kokkos::Impl::Timer timer; typename KernelHandle::idx_array_type row_map = handle->get_row_map(); typename KernelHandle::idx_edge_array_type entries = handle->get_entries(); typename KernelHandle::GraphColoringHandleType *gch = handle->get_graph_coloring_handle(); Experimental::KokkosKernels::Graph::ColoringAlgorithm algorithm = gch->get_coloring_type(); typedef typename KernelHandle::GraphColoringHandleType::color_array_type color_view_type; color_view_type colors_out = color_view_type("Graph Colors", row_map.dimension_0() - 1); typedef typename Experimental::KokkosKernels::Graph::Impl::GraphColor <typename KernelHandle::GraphColoringHandleType> BaseGraphColoring; BaseGraphColoring *gc = NULL; switch (algorithm){ case Experimental::KokkosKernels::Graph::COLORING_SERIAL: gc = new BaseGraphColoring( row_map.dimension_0() - 1, entries.dimension_0(), row_map, entries, gch); break; case Experimental::KokkosKernels::Graph::COLORING_VB: case Experimental::KokkosKernels::Graph::COLORING_VBBIT: case Experimental::KokkosKernels::Graph::COLORING_VBCS: typedef typename Experimental::KokkosKernels::Graph::Impl::GraphColor_VB <typename KernelHandle::GraphColoringHandleType> VBGraphColoring; gc = new VBGraphColoring( row_map.dimension_0() - 1, entries.dimension_0(), row_map, entries, gch); break; case Experimental::KokkosKernels::Graph::COLORING_EB: typedef typename Experimental::KokkosKernels::Graph::Impl::GraphColor_EB <typename KernelHandle::GraphColoringHandleType> EBGraphColoring; gc = new EBGraphColoring(row_map.dimension_0() - 1, entries.dimension_0(),row_map, entries, gch); break; case Experimental::KokkosKernels::Graph::COLORING_DEFAULT: break; } int num_phases = 0; gc->color_graph(colors_out, num_phases); delete gc; double coloring_time = timer.seconds(); gch->add_to_overall_coloring_time(coloring_time); gch->set_coloring_time(coloring_time); gch->set_num_phases(num_phases); gch->set_vertex_colors(colors_out); }
void mkl_apply( KernelHandle *handle, typename KernelHandle::idx m, typename KernelHandle::idx n, typename KernelHandle::idx k, typename KernelHandle::idx_array_type row_mapA, typename KernelHandle::idx_edge_array_type entriesA, typename KernelHandle::value_array_type valuesA, bool transposeA, typename KernelHandle::idx_array_type row_mapB, typename KernelHandle::idx_edge_array_type entriesB, typename KernelHandle::value_array_type valuesB, bool transposeB, typename KernelHandle::idx_array_type &row_mapC, typename KernelHandle::idx_edge_array_type &entriesC, typename KernelHandle::value_array_type &valuesC){ #ifdef KERNELS_HAVE_MKL typedef typename KernelHandle::idx idx; typedef typename KernelHandle::idx_array_type idx_array_type; typedef typename KernelHandle::value_type value_type; typedef typename KernelHandle::idx_device_type device1; typedef typename KernelHandle::idx_edge_device_type device2; typedef typename KernelHandle::value_type_device_type device3; typedef typename KernelHandle::HandleExecSpace MyExecSpace; std::cout << "RUNNING MKL" << std::endl; #if defined( KOKKOS_HAVE_CUDA ) if (!Kokkos::Impl::is_same<Kokkos::Cuda, device1 >::value){ std::cerr << "MEMORY IS NOT ALLOCATED IN HOST DEVICE for MKL" << std::endl; return; } if (!Kokkos::Impl::is_same<Kokkos::Cuda, device2 >::value){ std::cerr << "MEMORY IS NOT ALLOCATED IN HOST DEVICE for MKL" << std::endl; return; } if (!Kokkos::Impl::is_same<Kokkos::Cuda, device3 >::value){ std::cerr << "MEMORY IS NOT ALLOCATED IN HOST DEVICE for MKL" << std::endl; return; } #endif if (Kokkos::Impl::is_same<idx, int>::value){ int *a_xadj = (int *)row_mapA.ptr_on_device(); int *b_xadj = (int *)row_mapB.ptr_on_device(); int *c_xadj = (int *)row_mapC.ptr_on_device(); int *a_adj = (int *)entriesA.ptr_on_device(); int *b_adj = (int *)entriesB.ptr_on_device(); int *c_adj = (int *)entriesC.ptr_on_device(); int nnzA = entriesA.dimension_0(); int nnzB = entriesB.dimension_0(); value_type *a_ew = valuesA.ptr_on_device(); value_type *b_ew = valuesB.ptr_on_device(); value_type *c_ew = valuesC.ptr_on_device(); sparse_matrix_t A; sparse_matrix_t B; sparse_matrix_t C; if (Kokkos::Impl::is_same<value_type, float>::value){ if (SPARSE_STATUS_SUCCESS != mkl_sparse_s_create_csr (&A, SPARSE_INDEX_BASE_ZERO, m, n, a_xadj, a_xadj + 1, a_adj, (float *)a_ew)){ std::cerr << "CANNOT CREATE mkl_sparse_s_create_csr A" << std::endl; return; } if (SPARSE_STATUS_SUCCESS != mkl_sparse_s_create_csr (&B, SPARSE_INDEX_BASE_ZERO, n, k, b_xadj, b_xadj + 1, b_adj, (float *)b_ew)){ std::cerr << "CANNOT CREATE mkl_sparse_s_create_csr B" << std::endl; return; } sparse_operation_t operation; if (transposeA && transposeB){ operation = SPARSE_OPERATION_TRANSPOSE; } else if (!(transposeA || transposeB)){ operation = SPARSE_OPERATION_NON_TRANSPOSE; } else { std::cerr << "Ask both to transpose or non transpose for MKL SPGEMM" << std::endl; return; } if (SPARSE_STATUS_SUCCESS != mkl_sparse_spmm (operation, A, B, &C)){ std::cerr << "CANNOT multiply mkl_sparse_spmm " << std::endl; return; } else{ sparse_index_base_t c_indexing; MKL_INT c_rows, c_cols, *rows_start, *rows_end, *columns; float *values; if (SPARSE_STATUS_SUCCESS != mkl_sparse_s_export_csr (C, &c_indexing, &c_rows, &c_cols, &rows_start, &rows_end, &columns, &values)){ std::cerr << "CANNOT export result matrix " << std::endl; return; } if (SPARSE_INDEX_BASE_ZERO != c_indexing){ std::cerr << "C is not zero based indexed." << std::endl; return; } row_mapC = idx_array_type("rowmapC", c_rows + 1); entriesC = typename KernelHandle::idx_edge_array_type ("EntriesC" , rows_end[m - 1] ); valuesC = typename KernelHandle::value_array_type ("valuesC" , rows_end[m - 1]); KokkosKernels::Experimental::Util::copy_vector<MKL_INT *, idx_array_type, MyExecSpace> (m, rows_start, row_mapC); idx nnz = row_mapC(m) = rows_end[m - 1]; KokkosKernels::Experimental::Util::copy_vector<MKL_INT *, typename KernelHandle::idx_edge_array_type, MyExecSpace> (nnz, columns, entriesC); KokkosKernels::Experimental::Util::copy_vector<float *, typename KernelHandle::value_array_type, MyExecSpace> (m, values, valuesC); } if (SPARSE_STATUS_SUCCESS != mkl_sparse_destroy (A)){ std::cerr << "CANNOT DESTROY mkl_sparse_destroy A" << std::endl; return; } if (SPARSE_STATUS_SUCCESS != mkl_sparse_destroy (B)){ std::cerr << "CANNOT DESTROY mkl_sparse_destroy B" << std::endl; return; } if (SPARSE_STATUS_SUCCESS != mkl_sparse_destroy (C)){ std::cerr << "CANNOT DESTROY mkl_sparse_destroy C" << std::endl; return; } } else if (Kokkos::Impl::is_same<value_type, double>::value){ /* std::cout << "create a" << std::endl; std::cout << "m:" << m << " n:" << n << std::endl; std::cout << "a_xadj[0]:" << a_xadj[0] << " a_xadj[m]:" << a_xadj[m] << std::endl; std::cout << "a_adj[a_xadj[m] - 1]:" << a_adj[a_xadj[m] - 1] << " a_ew[a_xadj[m] - 1]:" << a_ew[a_xadj[m] - 1] << std::endl; */ if (SPARSE_STATUS_SUCCESS != mkl_sparse_d_create_csr (&A, SPARSE_INDEX_BASE_ZERO, m, n, a_xadj, a_xadj + 1, a_adj, (double *)a_ew)){ std::cerr << "CANNOT CREATE mkl_sparse_d_create_csr A" << std::endl; return; } //std::cout << "create b" << std::endl; if (SPARSE_STATUS_SUCCESS != mkl_sparse_d_create_csr (&B, SPARSE_INDEX_BASE_ZERO, n, k, b_xadj, b_xadj + 1, b_adj, (double *) b_ew)){ std::cerr << "CANNOT CREATE mkl_sparse_d_create_csr B" << std::endl; return; } sparse_operation_t operation; if (transposeA && transposeB){ operation = SPARSE_OPERATION_TRANSPOSE; } else if (!(transposeA || transposeB)){ operation = SPARSE_OPERATION_NON_TRANSPOSE; } else { std::cerr << "Ask both to transpose or non transpose for MKL SPGEMM" << std::endl; return; } if (SPARSE_STATUS_SUCCESS != mkl_sparse_spmm (operation, A, B, &C)){ std::cerr << "CANNOT multiply mkl_sparse_spmm " << std::endl; return; } else{ sparse_index_base_t c_indexing; MKL_INT c_rows, c_cols, *rows_start, *rows_end, *columns; double *values; if (SPARSE_STATUS_SUCCESS != mkl_sparse_d_export_csr (C, &c_indexing, &c_rows, &c_cols, &rows_start, &rows_end, &columns, &values)){ std::cerr << "CANNOT export result matrix " << std::endl; return; } if (SPARSE_INDEX_BASE_ZERO != c_indexing){ std::cerr << "C is not zero based indexed." << std::endl; return; } row_mapC = idx_array_type("rowmapC", c_rows + 1); entriesC = typename KernelHandle::idx_edge_array_type ("EntriesC" , rows_end[m - 1] ); valuesC = typename KernelHandle::value_array_type ("valuesC" , rows_end[m - 1]); KokkosKernels::Experimental::Util::copy_vector<MKL_INT *, idx_array_type, MyExecSpace> (m, rows_start, row_mapC); idx nnz = row_mapC(m) = rows_end[m - 1]; KokkosKernels::Experimental::Util::copy_vector<MKL_INT *, typename KernelHandle::idx_edge_array_type, MyExecSpace> (nnz, columns, entriesC); KokkosKernels::Experimental::Util::copy_vector<double *, typename KernelHandle::value_array_type, MyExecSpace> (m, values, valuesC); } if (SPARSE_STATUS_SUCCESS != mkl_sparse_destroy (A)){ std::cerr << "CANNOT DESTROY mkl_sparse_destroy A" << std::endl; return; } if (SPARSE_STATUS_SUCCESS != mkl_sparse_destroy (B)){ std::cerr << "CANNOT DESTROY mkl_sparse_destroy B" << std::endl; return; } if (SPARSE_STATUS_SUCCESS != mkl_sparse_destroy (C)){ std::cerr << "CANNOT DESTROY mkl_sparse_destroy C" << std::endl; return; } } else { std::cerr << "CUSPARSE requires float or double values. cuComplex and cuDoubleComplex are not implemented yet." << std::endl; return; } } else { std::cerr << "MKL requires integer values" << std::endl; return; } #else std::cerr << "MKL IS NOT DEFINED" << std::endl; return; #endif }