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
}
