int run_graphcolor(
crsMat_t input_mat,
KokkosKernels::Experimental::Graph::ColoringAlgorithm coloring_algorithm,
size_t &num_colors,
typename crsMat_t::StaticCrsGraphType::entries_type::non_const_type & vertex_colors){
typedef typename crsMat_t::StaticCrsGraphType graph_t;
typedef typename graph_t::row_map_type lno_view_t;
typedef typename graph_t::entries_type lno_nnz_view_t;
typedef typename crsMat_t::values_type::non_const_type scalar_view_t;
typedef KokkosKernels::Experimental::KokkosKernelsHandle
<lno_view_t,lno_nnz_view_t, scalar_view_t,
typename device::execution_space, typename device::memory_space,typename device::memory_space > KernelHandle;
KernelHandle kh;
kh.set_team_work_size(16);
kh.set_dynamic_scheduling(true);
kh.create_graph_coloring_handle(coloring_algorithm);
const size_t num_rows_1 = input_mat.numRows();
const size_t num_cols_1 = input_mat.numCols();
KokkosKernels::Experimental::Graph::graph_color_symbolic
<KernelHandle,lno_view_t,lno_nnz_view_t> (&kh,num_rows_1, num_cols_1,
input_mat.graph.row_map, input_mat.graph.entries);
num_colors = kh.get_graph_coloring_handle()->get_num_colors();
vertex_colors = kh.get_graph_coloring_handle()->get_vertex_colors();
kh.destroy_graph_coloring_handle();
return 0;
}
int main (int argc, char ** argv){
if (argc < 2){
std::cerr << "Usage:" << argv[0] << " input_bin_file" << std::endl;
exit(1);
}
Kokkos::initialize(argc, argv);
MyExecSpace::print_configuration(std::cout);
idx nv = 0, ne = 0;
idx *xadj, *adj;
//idx *half_srcs, *half_dsts;
wt *ew;
Experimental::KokkosKernels::Graph::Utils::read_graph_bin<idx, wt> (
&nv, &ne, &xadj, &adj, &ew, argv[1]);
delete [] ew;
um_array_type _xadj (xadj, nv + 1);
um_edge_array_type _adj (adj, ne);
idx_array_type kok_xadj ("xadj", nv + 1);
idx_edge_array_type kok_adj("adj", ne);
Kokkos::deep_copy (kok_xadj, _xadj);
Kokkos::deep_copy (kok_adj, _adj);
delete [] xadj;
delete [] adj;
typedef Experimental::KokkosKernels::KokkosKernelsHandle
<idx_array_type,idx_edge_array_type, value_array_type,
MyExecSpace, TemporaryWorkSpace,PersistentWorkSpace > KernelHandle;
KernelHandle kkh;
kkh.set_row_map(kok_xadj);
kkh.set_entries(kok_adj);
//kkh.set_values();
kkh.create_graph_coloring_handle(Experimental::KokkosKernels::Graph::COLORING_EB);
Experimental::KokkosKernels::Graph::graph_color_solve<KernelHandle> (&kkh);
std::cout << "EB " <<
"Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
Experimental::KokkosKernels::Graph::graph_color_solve<KernelHandle> (&kkh);
std::cout << "EBS " <<
"Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
kkh.destroy_graph_coloring_handle();
kkh.create_graph_coloring_handle(Experimental::KokkosKernels::Graph::COLORING_SERIAL);
Experimental::KokkosKernels::Graph::graph_color_solve<KernelHandle> (&kkh);
std::cout << "SEQ " <<
"Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
kkh.destroy_graph_coloring_handle();
kkh.create_graph_coloring_handle(Experimental::KokkosKernels::Graph::COLORING_VB);
Experimental::KokkosKernels::Graph::graph_color_solve<KernelHandle> (&kkh);
std::cout << "VB " <<
"Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
kkh.destroy_graph_coloring_handle();
kkh.create_graph_coloring_handle(Experimental::KokkosKernels::Graph::COLORING_VBBIT);
//kkh.get_graph_coloring_handle()->set_tictoc(true);
Experimental::KokkosKernels::Graph::graph_color_solve<KernelHandle> (&kkh);
std::cout << "VBBIT " <<
"Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
kkh.destroy_graph_coloring_handle();
kkh.create_graph_coloring_handle(Experimental::KokkosKernels::Graph::COLORING_VBCS);
//kkh.get_graph_coloring_handle()->set_tictoc(true);
Experimental::KokkosKernels::Graph::graph_color_solve<KernelHandle> (&kkh);
std::cout << "VBCS " <<
"Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
Experimental::KokkosKernels::Graph::graph_color_solve<KernelHandle> (&kkh);
std::cout << "VBCSS " <<
"Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
kkh.destroy_graph_coloring_handle();
Kokkos::finalize();
return 0;
}
void run_experiment(
crsGraph_t crsGraph, Parameters params){
//using namespace KokkosSparse;
using namespace KokkosGraph;
using namespace KokkosGraph::Experimental;
//using namespace KokkosSparse::Experimental;
int algorithm = params.algorithm;
int repeat = params.repeat;
int chunk_size = params.chunk_size;
int shmemsize = params.shmemsize;
int team_size = params.team_size;
int use_dynamic_scheduling = params.use_dynamic_scheduling;
int verbose = params.verbose;
//char spgemm_step = params.spgemm_step;
int vector_size = params.vector_size;
typedef typename crsGraph_t3::row_map_type::non_const_type lno_view_t;
typedef typename crsGraph_t3::entries_type::non_const_type lno_nnz_view_t;
typedef typename lno_view_t::non_const_value_type size_type;
typedef typename lno_nnz_view_t::non_const_value_type lno_t;
typedef KokkosKernels::Experimental::KokkosKernelsHandle
<size_type,lno_t, lno_t,
ExecSpace, TempMemSpace,PersistentMemSpace > KernelHandle;
KernelHandle kh;
kh.set_team_work_size(chunk_size);
kh.set_shmem_size(shmemsize);
kh.set_suggested_team_size(team_size);
kh.set_suggested_vector_size(vector_size);
if (use_dynamic_scheduling){
kh.set_dynamic_scheduling(true);
}
if (verbose){
kh.set_verbose(true);
}
for (int i = 0; i < repeat; ++i){
switch (algorithm){
case 1:
kh.create_graph_coloring_handle(COLORING_DEFAULT);
break;
case 2:
kh.create_graph_coloring_handle(COLORING_SERIAL);
break;
case 3:
kh.create_graph_coloring_handle(COLORING_VB);
break;
case 4:
kh.create_graph_coloring_handle(COLORING_VBBIT);
break;
case 5:
kh.create_graph_coloring_handle(COLORING_VBCS);
break;
case 6:
kh.create_graph_coloring_handle(COLORING_EB);
break;
default:
kh.create_graph_coloring_handle(COLORING_DEFAULT);
}
graph_color_symbolic(&kh,crsGraph.numRows(), crsGraph.numCols(), crsGraph.row_map, crsGraph.entries);
std::cout <<
"Time:" << kh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kh.get_graph_coloring_handle()->get_num_phases() << std::endl;
std::cout << "\t"; KokkosKernels::Impl::print_1Dview(kh.get_graph_coloring_handle()->get_vertex_colors());
}
}
int main (int argc, char ** argv){
if (argc < 2){
std::cerr << "Usage:" << argv[0] << " input_bin_file" << std::endl;
exit(1);
}
Kokkos::initialize(argc, argv);
const int numColoringAlgos = 6;
using namespace KokkosKernels::Experimental::Graph;
const ColoringAlgorithm ColoringAlgorithms[] = {COLORING_DEFAULT, COLORING_SERIAL, COLORING_VB, COLORING_VBBIT, COLORING_VBCS, COLORING_EB, COLORING_EB};
const std::string ColoringAlgorithmNames[] = {"COLORING_DEFAULT", "COLORING_SERIAL", "COLORING_VB", "COLORING_VBBIT", "COLORING_VBCS", "COLORING_EB"};
typedef int idx;
typedef double wt;
idx nr = 0, ne = 0;
idx *xadj, *adj;
wt *ew;
KokkosKernels::Experimental::Graph::Utils::read_graph_bin<idx, wt> (
&nr, &ne, &xadj, &adj, &ew, argv[1]);
delete [] ew;
idx nc = 0;
for (idx i = 0; i < ne; ++i){
if (adj[i] > nc) nc = adj[i];
}
nc += 1;
#if defined( KOKKOS_HAVE_SERIAL )
{
std::cout << "SERIAL TEST 1" << std::endl;
typedef unsigned int size_type;
typedef int lno_t;
typedef double scalar_t;
//typedef unsigned int color_t;
typedef Kokkos::Serial ExecSpace;
typedef Kokkos::Serial RowMemorySpace;
typedef Kokkos::Serial NonzeroMemorySpace;
ExecSpace::print_configuration(std::cout);
typedef Kokkos::Serial::memory_space TempWorkSpace;
typedef Kokkos::Serial::memory_space PersistentWorkSpace;
typedef Kokkos::View<size_type *, RowMemorySpace> row_index_view_type;
typedef Kokkos::View<lno_t *, NonzeroMemorySpace> nonzero_index_view_type;
typedef Kokkos::View<scalar_t *, NonzeroMemorySpace> nonzero_scalar_view_type;
//typedef Kokkos::View<color_t * , RowMemorySpace> color_view_type;
typedef Kokkos::View<idx *, RowMemorySpace::array_layout, Kokkos::Serial, Kokkos::MemoryUnmanaged> um_array_type;
typedef Kokkos::View<idx *, RowMemorySpace::array_layout, NonzeroMemorySpace, Kokkos::MemoryUnmanaged> um_edge_array_type;
um_array_type _xadj (xadj, nr + 1);
um_edge_array_type _adj (adj, ne);
row_index_view_type kok_xadj ("xadj", nr + 1);
nonzero_index_view_type kok_adj("adj", ne);
KokkosKernels::Experimental::Util::copy_vector<um_array_type, row_index_view_type, ExecSpace>(nr+1, _xadj, kok_xadj );
KokkosKernels::Experimental::Util::copy_vector<um_edge_array_type, nonzero_index_view_type, ExecSpace>(ne, _adj, kok_adj );
typedef KokkosKernels::Experimental::KokkosKernelsHandle
<row_index_view_type,nonzero_index_view_type, nonzero_scalar_view_type, ExecSpace, TempWorkSpace,PersistentWorkSpace > KernelHandle;
KernelHandle kkh;
for (int i = 0; i < numColoringAlgos; ++i){
std::cout << "\t:" << "Running " << ColoringAlgorithmNames[i] << std::endl;
kkh.create_graph_coloring_handle(ColoringAlgorithms[i]);
KokkosKernels::Experimental::Graph::graph_color_symbolic
<KernelHandle,row_index_view_type,nonzero_index_view_type> (&kkh,nr, nc, kok_xadj, kok_adj);
std::cout << "\t:" << ColoringAlgorithmNames[i] <<
" Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
std::cout << "\t"; KokkosKernels::Experimental::Util::print_1Dview(kkh.get_graph_coloring_handle()->get_vertex_colors());
}
/*
typedef typename KernelHandle::row_index_temp_work_view_type row_view_type;
typedef typename KernelHandle::row_index_persistent_work_view_type edge_view_type;
row_view_type sym_row_map;
edge_view_type sym_entries;
KokkosKernels::Experimental::Util::symmetrize_graph_symbolic
< row_index_view_type, nonzero_index_view_type,row_view_type, edge_view_type,ExecSpace>
(nr, kok_xadj, kok_adj, sym_row_map,sym_entries );
kok_xadj = row_index_view_type("s");
kok_adj = nonzero_index_view_type("s");
for (int i = 0; i < numColoringAlgos; ++i){
std::cout << "\t:" << "On Temp Memory Space Running " << ColoringAlgorithmNames[i] << std::endl;
kkh.create_graph_coloring_handle(ColoringAlgorithms[i]);
KokkosKernels::Experimental::Graph::graph_color_symbolic
<KernelHandle,row_view_type,edge_view_type> (&kkh,nr, nc, sym_row_map, sym_entries);
std::cout << "\t:" << ColoringAlgorithmNames[i] <<
" Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
std::cout << "\t"; KokkosKernels::Experimental::Util::print_1Dview(kkh.get_graph_coloring_handle()->get_vertex_colors());
}
*/
}
#endif
#if defined( KOKKOS_HAVE_OPENMP )
{
//OPENMP TEST1
{
std::cout << "OPENMP TEST 1" << std::endl;
typedef size_t size_type;
typedef int lno_t;
typedef double scalar_t;
//typedef unsigned int color_t;
typedef Kokkos::OpenMP ExecSpace;
typedef Kokkos::OpenMP RowMemorySpace;
typedef Kokkos::OpenMP::memory_space NonzeroMemorySpace;
ExecSpace::print_configuration(std::cout);
typedef Kokkos::OpenMP TempWorkSpace;
typedef Kokkos::OpenMP PersistentWorkSpace;
typedef Kokkos::View<size_type *, RowMemorySpace> row_index_view_type;
typedef Kokkos::View<lno_t *, NonzeroMemorySpace> nonzero_index_view_type;
typedef Kokkos::View<scalar_t *, NonzeroMemorySpace> nonzero_scalar_view_type;
//typedef Kokkos::View<color_t * , RowMemorySpace> color_view_type;
typedef Kokkos::View<idx *, RowMemorySpace::array_layout, Kokkos::Serial, Kokkos::MemoryUnmanaged> um_array_type;
typedef Kokkos::View<idx *, RowMemorySpace::array_layout, NonzeroMemorySpace, Kokkos::MemoryUnmanaged> um_edge_array_type;
um_array_type _xadj (xadj, nr + 1);
um_edge_array_type _adj (adj, ne);
row_index_view_type kok_xadj ("xadj", nr + 1);
nonzero_index_view_type kok_adj("adj", ne);
KokkosKernels::Experimental::Util::copy_vector<um_array_type, row_index_view_type, ExecSpace>(nr+1, _xadj, kok_xadj );
KokkosKernels::Experimental::Util::copy_vector<um_edge_array_type, nonzero_index_view_type, ExecSpace>(ne, _adj, kok_adj );
typedef KokkosKernels::Experimental::KokkosKernelsHandle
<row_index_view_type,nonzero_index_view_type, nonzero_scalar_view_type, ExecSpace, TempWorkSpace,PersistentWorkSpace > KernelHandle;
KernelHandle kkh;
for (int i = 0; i < numColoringAlgos; ++i){
std::cout << "\t:" << "Running " << ColoringAlgorithmNames[i] << std::endl;
kkh.create_graph_coloring_handle(ColoringAlgorithms[i]);
KokkosKernels::Experimental::Graph::graph_color_symbolic
<KernelHandle,row_index_view_type,nonzero_index_view_type> (&kkh,nr, nc, kok_xadj, kok_adj);
std::cout << "\t:" << ColoringAlgorithmNames[i] <<
" Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
std::cout << "\t"; KokkosKernels::Experimental::Util::print_1Dview(kkh.get_graph_coloring_handle()->get_vertex_colors());
}
/*
typedef typename KernelHandle::row_index_temp_work_view_type row_view_type;
typedef typename KernelHandle::row_index_persistent_work_view_type edge_view_type;
row_view_type sym_row_map;
edge_view_type sym_entries;
KokkosKernels::Experimental::Util::symmetrize_graph_symbolic
< row_index_view_type, nonzero_index_view_type,row_view_type, edge_view_type,ExecSpace>
(nr, kok_xadj, kok_adj, sym_row_map,sym_entries );
kok_xadj = row_index_view_type("s");
kok_adj = nonzero_index_view_type("s");
for (int i = 0; i < numColoringAlgos; ++i){
std::cout << "\t:" << "On Temp Memory Space Running " << ColoringAlgorithmNames[i] << std::endl;
kkh.create_graph_coloring_handle(ColoringAlgorithms[i]);
KokkosKernels::Experimental::Graph::graph_color_symbolic
<KernelHandle,row_view_type,edge_view_type> (&kkh,nr, nc, sym_row_map, sym_entries);
std::cout << "\t:" << ColoringAlgorithmNames[i] <<
" Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
std::cout << "\t"; KokkosKernels::Experimental::Util::print_1Dview(kkh.get_graph_coloring_handle()->get_vertex_colors());
}
*/
}
//OPENMP TEST2
{
std::cout << "OPENMP TEST 2" << std::endl;
typedef int size_type;
typedef unsigned long lno_t;
typedef float scalar_t;
//typedef int color_t;
typedef Kokkos::OpenMP ExecSpace;
typedef Kokkos::OpenMP RowMemorySpace;
typedef Kokkos::OpenMP::memory_space NonzeroMemorySpace;
ExecSpace::print_configuration(std::cout);
typedef Kokkos::OpenMP TempWorkSpace;
typedef Kokkos::OpenMP PersistentWorkSpace;
typedef Kokkos::View<size_type *, Kokkos::LayoutLeft, RowMemorySpace> row_index_view_type;
typedef Kokkos::View<lno_t *, Kokkos::LayoutRight, NonzeroMemorySpace> nonzero_index_view_type;
typedef Kokkos::View<scalar_t *, NonzeroMemorySpace> nonzero_scalar_view_type;
typedef Kokkos::View<const size_type *, Kokkos::LayoutLeft, RowMemorySpace> const_row_index_view_type;
typedef Kokkos::View<const lno_t *, Kokkos::LayoutRight, NonzeroMemorySpace> const_nonzero_index_view_type;
//typedef Kokkos::View<color_t * , Kokkos::LayoutStride, RowMemorySpace> color_view_type;
typedef Kokkos::View<idx *, RowMemorySpace::array_layout, Kokkos::Serial, Kokkos::MemoryUnmanaged> um_array_type;
typedef Kokkos::View<idx *, RowMemorySpace::array_layout, NonzeroMemorySpace, Kokkos::MemoryUnmanaged> um_edge_array_type;
um_array_type _xadj (xadj, nr + 1);
um_edge_array_type _adj (adj, ne);
row_index_view_type kok_xadj ("xadj", nr + 1);
nonzero_index_view_type kok_adj("adj", ne);
KokkosKernels::Experimental::Util::copy_vector<um_array_type, row_index_view_type, ExecSpace>(nr+1, _xadj, kok_xadj );
KokkosKernels::Experimental::Util::copy_vector<um_edge_array_type, nonzero_index_view_type, ExecSpace>(ne, _adj, kok_adj );
typedef KokkosKernels::Experimental::KokkosKernelsHandle
<const_row_index_view_type,const_nonzero_index_view_type, nonzero_scalar_view_type, ExecSpace, TempWorkSpace,PersistentWorkSpace > KernelHandle;
KernelHandle kkh;
for (int i = 0; i < numColoringAlgos; ++i){
std::cout << "\t:" << "Running " << ColoringAlgorithmNames[i] << std::endl;
kkh.create_graph_coloring_handle(ColoringAlgorithms[i]);
KokkosKernels::Experimental::Graph::graph_color_symbolic
<KernelHandle,const_row_index_view_type,const_nonzero_index_view_type> (&kkh,nr, nc, kok_xadj, kok_adj);
std::cout << "\t:" << ColoringAlgorithmNames[i] <<
" Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
std::cout << "\t"; KokkosKernels::Experimental::Util::print_1Dview(kkh.get_graph_coloring_handle()->get_vertex_colors());
}
/*
typedef typename KernelHandle::row_index_temp_work_view_type row_view_type;
typedef typename KernelHandle::row_index_persistent_work_view_type edge_view_type;
row_view_type sym_row_map;
edge_view_type sym_entries;
KokkosKernels::Experimental::Util::symmetrize_graph_symbolic
< row_index_view_type, nonzero_index_view_type,row_view_type, edge_view_type,ExecSpace>
(nr, kok_xadj, kok_adj, sym_row_map,sym_entries );
kok_xadj = row_index_view_type("s");
kok_adj = nonzero_index_view_type("s");
for (int i = 0; i < numColoringAlgos; ++i){
std::cout << "\t:" << "On Temp Memory Space Running " << ColoringAlgorithmNames[i] << std::endl;
kkh.create_graph_coloring_handle(ColoringAlgorithms[i]);
KokkosKernels::Experimental::Graph::graph_color_symbolic
<KernelHandle,row_view_type,edge_view_type> (&kkh,nr, nc, sym_row_map, sym_entries);
std::cout << "\t:" << ColoringAlgorithmNames[i] <<
" Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
std::cout << "\t"; KokkosKernels::Experimental::Util::print_1Dview(kkh.get_graph_coloring_handle()->get_vertex_colors());
}
*/
}
}
#endif
#if defined( KOKKOS_HAVE_CUDA )
{
//CUDA TEST1
{
std::cout << "Cuda TEST 1" << std::endl;
typedef unsigned int size_type;
typedef int lno_t;
typedef double scalar_t;
typedef unsigned int color_t;
typedef Kokkos::Cuda ExecSpace;
typedef Kokkos::Cuda RowMemorySpace;
typedef Kokkos::Cuda::memory_space NonzeroMemorySpace;
ExecSpace::print_configuration(std::cout);
typedef Kokkos::Cuda TempWorkSpace;
typedef Kokkos::Cuda PersistentWorkSpace;
typedef Kokkos::View<size_type *, RowMemorySpace> row_index_view_type;
typedef Kokkos::View<lno_t *, NonzeroMemorySpace> nonzero_index_view_type;
typedef Kokkos::View<scalar_t *, NonzeroMemorySpace> nonzero_scalar_view_type;
typedef Kokkos::View<color_t * , RowMemorySpace> color_view_type;
typedef Kokkos::View<idx *, RowMemorySpace::array_layout, Kokkos::Serial, Kokkos::MemoryUnmanaged> um_array_type;
typedef Kokkos::View<idx *, RowMemorySpace::array_layout, Kokkos::Serial, Kokkos::MemoryUnmanaged> um_edge_array_type;
um_array_type _xadj (xadj, nr + 1);
um_edge_array_type _adj (adj, ne);
row_index_view_type kok_xadj ("xadj", nr + 1);
nonzero_index_view_type kok_adj("adj", ne);
Kokkos::deep_copy (kok_xadj , _xadj);
Kokkos::deep_copy (kok_adj , _adj);
//KokkosKernels::Experimental::Util::copy_vector<um_array_type, row_index_view_type, ExecSpace>(nr+1, _xadj, kok_xadj );
//KokkosKernels::Experimental::Util::copy_vector<um_edge_array_type, nonzero_index_view_type, ExecSpace>(ne, _adj, kok_adj );
typedef KokkosKernels::Experimental::KokkosKernelsHandle
<row_index_view_type,nonzero_index_view_type, nonzero_scalar_view_type, ExecSpace, TempWorkSpace,PersistentWorkSpace > KernelHandle;
KernelHandle kkh;
for (int i = 0; i < numColoringAlgos; ++i){
std::cout << "\t:" << "Running " << ColoringAlgorithmNames[i] << std::endl;
kkh.create_graph_coloring_handle(ColoringAlgorithms[i]);
KokkosKernels::Experimental::Graph::graph_color_symbolic
<KernelHandle,row_index_view_type,nonzero_index_view_type> (&kkh,nr, nc, kok_xadj, kok_adj);
std::cout << "\t:" << ColoringAlgorithmNames[i] <<
" Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
std::cout << "\t"; KokkosKernels::Experimental::Util::print_1Dview(kkh.get_graph_coloring_handle()->get_vertex_colors());
}
typedef typename KernelHandle::row_lno_temp_work_view_t row_view_type;
typedef typename KernelHandle::row_lno_persistent_work_view_t edge_view_type;
row_view_type sym_row_map;
edge_view_type sym_entries;
/*
KokkosKernels::Experimental::Util::symmetrize_graph_symbolic
< row_index_view_type, nonzero_index_view_type,row_view_type, edge_view_type,ExecSpace>
(nr, kok_xadj, kok_adj, sym_row_map,sym_entries );
kok_xadj = row_index_view_type("s");
kok_adj = nonzero_index_view_type("s");
for (int i = 0; i < numColoringAlgos; ++i){
std::cout << "\t:" << "On Temp Memory Space Running " << ColoringAlgorithmNames[i] << std::endl;
kkh.create_graph_coloring_handle(ColoringAlgorithms[i]);
KokkosKernels::Experimental::Graph::graph_color_symbolic
<KernelHandle,row_view_type,edge_view_type> (&kkh,nr, nc, sym_row_map, sym_entries);
std::cout << "\t:" << ColoringAlgorithmNames[i] <<
" Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
std::cout << "\t"; KokkosKernels::Experimental::Util::print_1Dview(kkh.get_graph_coloring_handle()->get_vertex_colors());
}
*/
}
//CUDA TEST2
{
std::cout << "Cuda TEST 2" << std::endl;
typedef int size_type;
typedef unsigned long lno_t;
typedef float scalar_t;
typedef int color_t;
typedef Kokkos::Cuda ExecSpace;
typedef Kokkos::Cuda RowMemorySpace;
typedef Kokkos::Cuda::memory_space NonzeroMemorySpace;
ExecSpace::print_configuration(std::cout);
typedef Kokkos::Cuda TempWorkSpace;
typedef Kokkos::Cuda PersistentWorkSpace;
typedef Kokkos::View<size_type *, Kokkos::LayoutLeft, RowMemorySpace> row_index_view_type;
typedef Kokkos::View<lno_t *, Kokkos::LayoutRight, NonzeroMemorySpace> nonzero_index_view_type;
typedef Kokkos::View<scalar_t *, NonzeroMemorySpace> nonzero_scalar_view_type;
typedef Kokkos::View<color_t * , Kokkos::LayoutStride, RowMemorySpace> color_view_type;
typedef Kokkos::View<idx *, RowMemorySpace::array_layout, Kokkos::Serial, Kokkos::MemoryUnmanaged> um_array_type;
typedef Kokkos::View<idx *, RowMemorySpace::array_layout, NonzeroMemorySpace, Kokkos::MemoryUnmanaged> um_edge_array_type;
um_array_type _xadj (xadj, nr + 1);
um_edge_array_type _adj (adj, ne);
typedef Kokkos::View<const size_type *, Kokkos::LayoutLeft, RowMemorySpace> const_row_index_view_type;
typedef Kokkos::View<const lno_t *, Kokkos::LayoutRight, NonzeroMemorySpace> const_nonzero_index_view_type;
typedef Kokkos::View<idx *, RowMemorySpace> tmp_view_type;
typedef Kokkos::View<idx *, NonzeroMemorySpace> tmp_edge_view_type;
tmp_view_type __xadj ("xadj", nr + 1);
tmp_edge_view_type __adj("adj", ne);
Kokkos::deep_copy (__xadj , _xadj);
Kokkos::deep_copy (__adj , _adj);
row_index_view_type kok_xadj ("xadj", nr + 1);
nonzero_index_view_type kok_adj("adj", ne);
KokkosKernels::Experimental::Util::copy_vector<tmp_view_type, row_index_view_type, ExecSpace>(nr+1, __xadj, kok_xadj );
KokkosKernels::Experimental::Util::copy_vector<tmp_edge_view_type, nonzero_index_view_type, ExecSpace>(ne, __adj, kok_adj );
__xadj = tmp_view_type("");
__adj = tmp_edge_view_type("");
//KokkosKernels::Experimental::Util::copy_vector<um_array_type, row_index_view_type, ExecSpace>(nr+1, _xadj, kok_xadj );
//KokkosKernels::Experimental::Util::copy_vector<um_edge_array_type, nonzero_index_view_type, ExecSpace>(ne, _adj, kok_adj );
typedef KokkosKernels::Experimental::KokkosKernelsHandle
<const_row_index_view_type,const_nonzero_index_view_type, nonzero_scalar_view_type, ExecSpace, TempWorkSpace,PersistentWorkSpace > KernelHandle;
KernelHandle kkh;
for (int i = 0; i < numColoringAlgos; ++i){
std::cout << "\t:" << "Running " << ColoringAlgorithmNames[i] << std::endl;
kkh.create_graph_coloring_handle(ColoringAlgorithms[i]);
KokkosKernels::Experimental::Graph::graph_color_symbolic
<KernelHandle,const_row_index_view_type,const_nonzero_index_view_type> (&kkh,nr, nc, kok_xadj, kok_adj);
std::cout << "\t:" << ColoringAlgorithmNames[i] <<
" Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
std::cout << "\t"; KokkosKernels::Experimental::Util::print_1Dview(kkh.get_graph_coloring_handle()->get_vertex_colors());
}
/*
typedef typename KernelHandle::row_index_temp_work_view_type row_view_type;
typedef typename KernelHandle::row_index_persistent_work_view_type edge_view_type;
row_view_type sym_row_map;
edge_view_type sym_entries;
KokkosKernels::Experimental::Util::symmetrize_graph_symbolic
< const_row_index_view_type, const_nonzero_index_view_type,row_view_type, edge_view_type,ExecSpace>
(nr, kok_xadj, kok_adj, sym_row_map,sym_entries );
kok_xadj = row_index_view_type("s");
kok_adj = nonzero_index_view_type("s");
for (int i = 0; i < numColoringAlgos; ++i){
std::cout << "\t:" << "On Temp Memory Space Running " << ColoringAlgorithmNames[i] << std::endl;
kkh.create_graph_coloring_handle(ColoringAlgorithms[i]);
KokkosKernels::Experimental::Graph::graph_color_symbolic
<KernelHandle,row_view_type,edge_view_type> (&kkh,nr, nc, sym_row_map, sym_entries);
std::cout << "\t:" << ColoringAlgorithmNames[i] <<
" Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
std::cout << "\t"; KokkosKernels::Experimental::Util::print_1Dview(kkh.get_graph_coloring_handle()->get_vertex_colors());
}
*/
}
#if defined( KOKKOS_USE_CUDA_UVM )
//CUDA TEST3
{
std::cout << "Cuda TEST 3" << std::endl;
typedef unsigned int size_type;
typedef unsigned long lno_t;
typedef float scalar_t;
typedef int color_t;
typedef Kokkos::Cuda ExecSpace;
typedef Kokkos::CudaUVMSpace RowMemorySpace;
typedef Kokkos::Cuda NonzeroMemorySpace;
ExecSpace::print_configuration(std::cout);
typedef Kokkos::CudaUVMSpace TempWorkSpace;
typedef Kokkos::CudaHostPinnedSpace PersistentWorkSpace;
typedef Kokkos::View<size_type *, Kokkos::LayoutLeft, RowMemorySpace> row_index_view_type;
typedef Kokkos::View<lno_t *, Kokkos::LayoutRight, NonzeroMemorySpace> nonzero_index_view_type;
typedef Kokkos::View<scalar_t *, NonzeroMemorySpace> nonzero_scalar_view_type;
typedef Kokkos::View<color_t * , Kokkos::LayoutStride, RowMemorySpace> color_view_type;
typedef Kokkos::View<idx *,NonzeroMemorySpace::array_layout, Kokkos::Serial, Kokkos::MemoryUnmanaged> um_array_type;
typedef Kokkos::View<idx *,NonzeroMemorySpace::array_layout, Kokkos::Serial, Kokkos::MemoryUnmanaged> um_edge_array_type;
um_array_type _xadj (xadj, nr + 1);
um_edge_array_type _adj (adj, ne);
//row_index_view_type kok_xadj ("xadj", nr + 1);
//nonzero_index_view_type kok_adj("adj", ne);
typedef Kokkos::View<idx *, RowMemorySpace> tmp_view_type;
typedef Kokkos::View<idx *, NonzeroMemorySpace> tmp_edge_view_type;
tmp_view_type __xadj ("xadj", nr + 1);
tmp_edge_view_type __adj("adj", ne);
Kokkos::deep_copy (__xadj , _xadj);
Kokkos::deep_copy (__adj , _adj);
row_index_view_type kok_xadj ("xadj", nr + 1);
nonzero_index_view_type kok_adj("adj", ne);
KokkosKernels::Experimental::Util::copy_vector<tmp_view_type, row_index_view_type, ExecSpace>(nr+1, __xadj, kok_xadj );
KokkosKernels::Experimental::Util::copy_vector<tmp_edge_view_type, nonzero_index_view_type, ExecSpace>(ne, __adj, kok_adj );
__xadj = tmp_view_type("");
__adj = tmp_edge_view_type("");
typedef KokkosKernels::Experimental::KokkosKernelsHandle
<row_index_view_type,nonzero_index_view_type, nonzero_scalar_view_type, ExecSpace, TempWorkSpace,PersistentWorkSpace > KernelHandle;
KernelHandle kkh;
for (int i = 0; i < numColoringAlgos; ++i){
std::cout << "\t:" << "Running " << ColoringAlgorithmNames[i] << std::endl;
kkh.create_graph_coloring_handle(ColoringAlgorithms[i]);
KokkosKernels::Experimental::Graph::graph_color_symbolic
<KernelHandle,row_index_view_type,nonzero_index_view_type> (&kkh,nr, nc, kok_xadj, kok_adj);
std::cout << "\t:" << ColoringAlgorithmNames[i] <<
" Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
std::cout << "\t"; KokkosKernels::Experimental::Util::print_1Dview(kkh.get_graph_coloring_handle()->get_vertex_colors());
}
/*
typedef typename KernelHandle::row_index_temp_work_view_type row_view_type;
typedef typename KernelHandle::row_index_persistent_work_view_type edge_view_type;
row_view_type sym_row_map;
edge_view_type sym_entries;
KokkosKernels::Experimental::Util::symmetrize_graph_symbolic
< row_index_view_type, nonzero_index_view_type,row_view_type, edge_view_type,ExecSpace>
(nr, kok_xadj, kok_adj, sym_row_map,sym_entries );
kok_xadj = row_index_view_type("s");
kok_adj = nonzero_index_view_type("s");
for (int i = 0; i < numColoringAlgos; ++i){
std::cout << "\t:" << "On Temp Memory Space Running " << ColoringAlgorithmNames[i] << std::endl;
kkh.create_graph_coloring_handle(ColoringAlgorithms[i]);
KokkosKernels::Experimental::Graph::graph_color_symbolic
<KernelHandle,row_view_type,edge_view_type> (&kkh,nr, nc, sym_row_map, sym_entries);
std::cout << "\t:" << ColoringAlgorithmNames[i] <<
" Time:" << kkh.get_graph_coloring_handle()->get_overall_coloring_time() << " "
"Num colors:" << kkh.get_graph_coloring_handle()->get_num_colors() << " "
"Num Phases:" << kkh.get_graph_coloring_handle()->get_num_phases() << std::endl;
std::cout << "\t"; KokkosKernels::Experimental::Util::print_1Dview(kkh.get_graph_coloring_handle()->get_vertex_colors());
}
*/
}
#endif
}
#endif
delete [] xadj;
delete [] adj;
Kokkos::finalize();
return 0;
}
int main (int argc, char ** argv){
if (argc < 2){
std::cerr << "Usage:" << argv[0] << " input_bin_file" << std::endl;
exit(1);
}
Kokkos::initialize(argc, argv);
MyExecSpace::print_configuration(std::cout);
idx m = 0, nnzA = 0, n = 0, k = 0;
idx *xadj, *adj;
wt *ew;
KokkosKernels::Experimental::Graph::Utils::read_graph_bin<idx, wt> (&m, &nnzA, &xadj, &adj, &ew, argv[1]);
std::cout << "m:" << m << " nnzA:" << nnzA << std::endl;
k = n = m;
um_array_type _xadj (xadj, m + 1);
um_edge_array_type _adj (adj, nnzA);
wt_um_edge_array_type _mtx_vals (ew, nnzA);
idx_array_type kok_xadj ("xadj", m + 1);
idx_edge_array_type kok_adj("adj", nnzA);
value_array_type kok_mtx_vals ("MTX_VALS", nnzA);
Kokkos::deep_copy (kok_xadj, _xadj);
Kokkos::deep_copy (kok_adj, _adj);
Kokkos::deep_copy (kok_mtx_vals, _mtx_vals);
delete [] xadj;
delete [] adj;
delete [] ew;
idx_array_type row_mapC, row_mapC2;
idx_edge_array_type entriesC, entriesC2;
value_array_type valuesC, valuesC2;
typedef KokkosKernels::Experimental::KokkosKernelsHandle
<idx_array_type,idx_edge_array_type, value_array_type,
MyExecSpace, TemporaryWorkSpace,PersistentWorkSpace > KernelHandle;
KernelHandle kh;
kh.create_spgemm_handle(KokkosKernels::Experimental::Graph::SPGEMM_CUSP);
Kokkos::Impl::Timer timer1;
KokkosKernels::Experimental::Graph::spgemm_symbolic<KernelHandle> (
&kh,
m,
n,
k,
kok_xadj,
kok_adj,
false,
kok_xadj,
kok_adj,
false,
row_mapC,
entriesC
);
Kokkos::fence();
double symbolic_time = timer1.seconds();
Kokkos::Impl::Timer timer2;
KokkosKernels::Experimental::Graph::spgemm_numeric(
&kh,
m,
n,
k,
kok_xadj,
kok_adj,
kok_mtx_vals,
false,
kok_xadj,
kok_adj,
kok_mtx_vals,
true,
row_mapC,
entriesC,
valuesC
);
Kokkos::fence();
double numeric_time = timer2.seconds();
std::cout << "mm_time:" << numeric_time + symbolic_time
<< " symbolic_time:" << symbolic_time
<< " numeric:" << numeric_time << std::endl;
std::cout << "row_mapC:" << row_mapC.dimension_0() << std::endl;
std::cout << "entriesC:" << entriesC.dimension_0() << std::endl;
std::cout << "valuesC:" << valuesC.dimension_0() << std::endl;
kh.create_spgemm_handle();
Kokkos::Impl::Timer timer3;
KokkosKernels::Experimental::Graph::spgemm_symbolic<KernelHandle> (
&kh,
m,
n,
k,
kok_xadj,
kok_adj,
false,
kok_xadj,
kok_adj,
false,
row_mapC2,
entriesC2
);
Kokkos::fence();
symbolic_time = timer3.seconds();
Kokkos::Impl::Timer timer4;
KokkosKernels::Experimental::Graph::spgemm_numeric(
&kh,
m,
n,
k,
kok_xadj,
kok_adj,
kok_mtx_vals,
false,
kok_xadj,
kok_adj,
kok_mtx_vals,
true,
row_mapC2,
entriesC2,
valuesC2
);
Kokkos::fence();
numeric_time = timer4.seconds();
std::cout << "mm_time:" << numeric_time + symbolic_time
<< " symbolic_time:" << symbolic_time
<< " numeric:" << numeric_time << std::endl;
std::cout << "row_mapC:" << row_mapC2.dimension_0() << std::endl;
std::cout << "entriesC:" << entriesC2.dimension_0() << std::endl;
std::cout << "valuesC:" << valuesC2.dimension_0() << std::endl;
typedef Kokkos::RangePolicy<MyExecSpace> my_exec_space;
size_t map = 0, ent = 0, val = 0;
Kokkos::parallel_reduce(my_exec_space(0,row_mapC2.dimension_0()), compare<idx_array_type>(row_mapC,row_mapC2), map);
Kokkos::parallel_reduce(my_exec_space(0,entriesC2.dimension_0()), compare<idx_edge_array_type>(entriesC,entriesC2), ent);
Kokkos::parallel_reduce(my_exec_space(0,valuesC2.dimension_0()), compare<value_array_type>(valuesC,valuesC2), val);
std::cout << "map:" << map << " ent:" << ent << " val:" << val << std::endl;
Kokkos::finalize();
return 0;
}
inline
void pcgsolve( //const ImportType & import,
KernelHandle &kh
, const CrsMatrix <typename KernelHandle::nonzero_value_type , typename KernelHandle::row_index_type, typename KernelHandle::HandleExecSpace > & A
, const Kokkos::View <typename KernelHandle::nonzero_value_type *,
typename KernelHandle::HandleExecSpace> & b
, const Kokkos::View <typename KernelHandle::nonzero_value_type * ,
typename KernelHandle::HandleExecSpace > & x
, const size_t maximum_iteration = 200
, const double tolerance = std::numeric_limits<double>::epsilon()
, CGSolveResult * result = 0
, bool use_sgs = true
)
{
typedef typename KernelHandle::HandleExecSpace Space;
//typedef typename KernelHandle::nonzero_value_type MScalar;
typedef typename KernelHandle::nonzero_value_type VScalar;
//typedef typename KernelHandle::row_index_type Idx_Type;
//typedef typename KernelHandle::idx_array_type idx_array_type;
typedef typename Kokkos::View< VScalar * , Space > VectorType ;
//const size_t count_owned = import.count_owned ;
//const size_t count_total = import.count_owned + import.count_receive;
const size_t count_owned = A.graph.nv;
const size_t count_total = count_owned;
size_t iteration = 0 ;
double iter_time = 0 ;
double matvec_time = 0 ;
double norm_res = 0 ;
double precond_time = 0;
double precond_init_time = 0;
Kokkos::Impl::Timer wall_clock ;
Kokkos::Impl::Timer timer;
// Need input vector to matvec to be owned + received
VectorType pAll ( "cg::p" , count_total );
VectorType p = Kokkos::subview( pAll , std::pair<size_t,size_t>(0,count_owned) );
VectorType r ( "cg::r" , count_owned );
VectorType Ap( "cg::Ap", count_owned );
/* r = b - A * x ; */
/* p = x */ Kokkos::deep_copy( p , x );
///* import p */ import( pAll );
/* Ap = A * p */ multiply( count_owned , Ap , A , pAll );
/* r = b - Ap */ waxpby( count_owned , r , 1.0 , b , -1.0 , Ap );
/* p = r */ Kokkos::deep_copy( p , r );
//double old_rdot = Kokkos::Example::all_reduce( dot( count_owned , r , r ) , import.comm );
double old_rdot = dot( count_owned , r , r );
norm_res = sqrt( old_rdot );
int apply_count = 1;
VectorType z;
//double precond_old_rdot = Kokkos::Example::all_reduce( dot( count_owned , r , z ) , import.comm );
double precond_old_rdot = 1;
#ifdef PRECOND_NORM
double precond_norm_res = 1;
#endif
Kokkos::deep_copy( p , z );
//typename KernelHandle::GaussSeidelHandleType *gsHandler;
bool owner_handle = false;
if (use_sgs){
if (kh.get_gs_handle() == NULL){
owner_handle = true;
kh.create_gs_handle();
}
//gsHandler = kh.get_gs_handle();
timer.reset();
KokkosKernels::Experimental::Graph::gauss_seidel_numeric
(&kh, count_owned, count_owned, A.graph.row_map, A.graph.entries, A.coeff);
Space::fence();
precond_init_time += timer.seconds();
z = VectorType( "pcg::z" , count_owned );
Space::fence();
timer.reset();
KokkosKernels::Experimental::Graph::symmetric_gauss_seidel_apply
(&kh, count_owned, count_owned, A.graph.row_map, A.graph.entries, A.coeff, z, r, true, apply_count);
Space::fence();
precond_time += timer.seconds();
//double precond_old_rdot = Kokkos::Example::all_reduce( dot( count_owned , r , z ) , import.comm );
precond_old_rdot = dot( count_owned , r , z );
#ifdef PRECOND_NORM
precond_norm_res = sqrt( precond_old_rdot );
#endif
Kokkos::deep_copy( p , z );
}
iteration = 0 ;
#ifdef PRINTRES
std::cout << "norm_res:" << norm_res << " old_rdot:" << old_rdot<< std::endl;
#ifdef PRECOND_NORM
if (use_sgs)
std::cout << "precond_norm_res:" << precond_norm_res << " precond_old_rdot:" << precond_old_rdot<< std::endl;
#endif
#endif
while ( tolerance < norm_res && iteration < maximum_iteration ) {
/* pAp_dot = dot( p , Ap = A * p ) */
timer.reset();
///* import p */ import( pAll );
/* Ap = A * p */ multiply( count_owned , Ap , A , pAll );
Space::fence();
matvec_time += timer.seconds();
//const double pAp_dot = Kokkos::Example::all_reduce( dot( count_owned , p , Ap ) , import.comm );
const double pAp_dot = dot( count_owned , p , Ap ) ;
double alpha = 0;
if (use_sgs){
alpha = precond_old_rdot / pAp_dot ;
}
else {
alpha = old_rdot / pAp_dot ;
}
/* x += alpha * p ; */ waxpby( count_owned , x , alpha, p , 1.0 , x );
/* r += -alpha * Ap ; */ waxpby( count_owned , r , -alpha, Ap , 1.0 , r );
//const double r_dot = Kokkos::Example::all_reduce( dot( count_owned , r , r ) , import.comm );
const double r_dot = dot( count_owned , r , r );
const double beta_original = r_dot / old_rdot ;
double precond_r_dot = 1;
double precond_beta = 1;
if (use_sgs){
Space::fence();
timer.reset();
KokkosKernels::Experimental::Graph::symmetric_gauss_seidel_apply(&kh, count_owned, count_owned, A.graph.row_map, A.graph.entries, A.coeff, z, r, true, apply_count);
Space::fence();
precond_time += timer.seconds();
//const double precond_r_dot = Kokkos::Example::all_reduce( dot( count_owned , r , z ) , import.comm );
precond_r_dot = dot( count_owned , r , z );
precond_beta = precond_r_dot / precond_old_rdot ;
}
double beta = 1;
if (!use_sgs){
beta = beta_original;
/* p = r + beta * p ; */ waxpby( count_owned , p , 1.0 , r , beta , p );
}
else {
beta = precond_beta;
waxpby( count_owned , p , 1.0 , z , beta , p );
}
#ifdef PRINTRES
std::cout << "\tbeta_original:" << beta_original << std::endl;
if (use_sgs)
std::cout << "\tprecond_beta:" << precond_beta << std::endl;
#endif
norm_res = sqrt( old_rdot = r_dot );
#ifdef PRECOND_NORM
if (use_sgs){
precond_norm_res = sqrt( precond_old_rdot = precond_r_dot );
}
#else
precond_old_rdot = precond_r_dot;
#endif
#ifdef PRINTRES
std::cout << "\tnorm_res:" << norm_res << " old_rdot:" << old_rdot<< std::endl;
#ifdef PRECOND_NORM
if (use_sgs)
std::cout << "\tprecond_norm_res:" << precond_norm_res << " precond_old_rdot:" << precond_old_rdot<< std::endl;
#endif
#endif
++iteration ;
}
Space::fence();
iter_time = wall_clock.seconds();
if ( 0 != result ) {
result->iteration = iteration ;
result->iter_time = iter_time ;
result->matvec_time = matvec_time ;
result->norm_res = norm_res ;
result->precond_time = precond_time;
result->precond_init_time = precond_init_time;
}
if (use_sgs & owner_handle ){
kh.destroy_gs_handle();
}
}
void run_experiment(
crsMat_t crsmat){
typedef typename crsMat_t::values_type scalar_view_t;
idx nv = crsmat.numRows();
scalar_view_t kok_x_original = create_x_vector<scalar_view_t>(nv, MAXVAL);
KokkosKernels::Experimental::Util::print_1Dview(kok_x_original);
scalar_view_t kok_b_vector = create_y_vector(crsmat, kok_x_original);
//create X vector
scalar_view_t kok_x_vector("kok_x_vector", nv);
double solve_time = 0;
const unsigned cg_iteration_limit = 100000;
const double cg_iteration_tolerance = 1e-7 ;
KokkosKernels::Experimental::Example::CGSolveResult cg_result ;
typedef KokkosKernels::Experimental::KokkosKernelsHandle
< typename crsMat_t::StaticCrsGraphType::row_map_type,
typename crsMat_t::StaticCrsGraphType::entries_type,
typename crsMat_t::values_type,
ExecSpace, ExecSpace, ExecSpace > KernelHandle;
KernelHandle kh;
kh.create_gs_handle();
Kokkos::Impl::Timer timer1;
KokkosKernels::Experimental::Example::pcgsolve(
kh
, crsmat
, kok_b_vector
, kok_x_vector
, cg_iteration_limit
, cg_iteration_tolerance
, & cg_result
, true
);
Kokkos::fence();
solve_time = timer1.seconds();
std::cout << "DEFAULT SOLVE:"
<< "\n\t(P)CG_NUM_ITER [" << cg_result.iteration << "]"
<< "\n\tMATVEC_TIME [" << cg_result.matvec_time << "]"
<< "\n\tCG_RESIDUAL [" << cg_result.norm_res << "]"
<< "\n\tCG_ITERATION_TIME [" << cg_result.iter_time << "]"
<< "\n\tPRECONDITIONER_TIME [" << cg_result.precond_time << "]"
<< "\n\tPRECONDITIONER_INIT_TIME [" << cg_result.precond_init_time << "]"
<< "\n\tPRECOND_APPLY_TIME_PER_ITER [" << cg_result.precond_time / (cg_result.iteration + 1) << "]"
<< "\n\tSOLVE_TIME [" << solve_time<< "]"
<< std::endl ;
/*
kh.destroy_gs_handle();
kh.create_gs_handle(KokkosKernels::Experimental::Graph::GS_PERMUTED);
kok_x_vector = scalar_view_t("kok_x_vector", nv);
timer1.reset();
KokkosKernels::Experimental::Example::pcgsolve(
kh
, crsmat
, kok_b_vector
, kok_x_vector
, cg_iteration_limit
, cg_iteration_tolerance
, & cg_result
, true
);
Kokkos::fence();
solve_time = timer1.seconds();
std::cout << "\nPERMUTED SGS SOLVE:"
<< "\n\t(P)CG_NUM_ITER [" << cg_result.iteration << "]"
<< "\n\tMATVEC_TIME [" << cg_result.matvec_time << "]"
<< "\n\tCG_RESIDUAL [" << cg_result.norm_res << "]"
<< "\n\tCG_ITERATION_TIME [" << cg_result.iter_time << "]"
<< "\n\tPRECONDITIONER_TIME [" << cg_result.precond_time << "]"
<< "\n\tPRECONDITIONER_INIT_TIME [" << cg_result.precond_init_time << "]"
<< "\n\tPRECOND_APPLY_TIME_PER_ITER [" << cg_result.precond_time / (cg_result.iteration + 1) << "]"
<< "\n\tSOLVE_TIME [" << solve_time<< "]"
<< std::endl ;
kh.destroy_gs_handle();
kh.create_gs_handle(KokkosKernels::Experimental::Graph::GS_TEAM);
kok_x_vector = scalar_view_t("kok_x_vector", nv);
timer1.reset();
KokkosKernels::Experimental::Example::pcgsolve(
kh
, crsmat
, kok_b_vector
, kok_x_vector
, cg_iteration_limit
, cg_iteration_tolerance
, & cg_result
, true
);
Kokkos::fence();
solve_time = timer1.seconds();
std::cout << "\nTEAM SGS SOLVE:"
<< "\n\t(P)CG_NUM_ITER [" << cg_result.iteration << "]"
<< "\n\tMATVEC_TIME [" << cg_result.matvec_time << "]"
<< "\n\tCG_RESIDUAL [" << cg_result.norm_res << "]"
<< "\n\tCG_ITERATION_TIME [" << cg_result.iter_time << "]"
<< "\n\tPRECONDITIONER_TIME [" << cg_result.precond_time << "]"
<< "\n\tPRECONDITIONER_INIT_TIME [" << cg_result.precond_init_time << "]"
<< "\n\tPRECOND_APPLY_TIME_PER_ITER [" << cg_result.precond_time / (cg_result.iteration + 1) << "]"
<< "\n\tSOLVE_TIME [" << solve_time<< "]"
<< std::endl ;
kok_x_vector = scalar_view_t("kok_x_vector", nv);
timer1.reset();
KokkosKernels::Experimental::Example::pcgsolve(
kh
, crsmat
, kok_b_vector
, kok_x_vector
, cg_iteration_limit
, cg_iteration_tolerance
, & cg_result
, false
);
Kokkos::fence();
solve_time = timer1.seconds();
std::cout << "\nCG SOLVE (With no Preconditioner):"
<< "\n\t(P)CG_NUM_ITER [" << cg_result.iteration << "]"
<< "\n\tMATVEC_TIME [" << cg_result.matvec_time << "]"
<< "\n\tCG_RESIDUAL [" << cg_result.norm_res << "]"
<< "\n\tCG_ITERATION_TIME [" << cg_result.iter_time << "]"
<< "\n\tPRECONDITIONER_TIME [" << cg_result.precond_time << "]"
<< "\n\tPRECONDITIONER_INIT_TIME [" << cg_result.precond_init_time << "]"
<< "\n\tPRECOND_APPLY_TIME_PER_ITER [" << cg_result.precond_time / (cg_result.iteration + 1) << "]"
<< "\n\tSOLVE_TIME [" << solve_time<< "]"
<< std::endl ;
*/
}
void run_experiment(
int repeatcount, idx nv, idx ne,
idx_array_type kok_xadj,
idx_edge_array_type kok_adj,
value_array_type kok_mtx_vals
){
value_array_type kok_x_original = create_x_vector(nv, MAXVAL);
value_array_type kok_b_vector = create_b_vector(
nv,
kok_xadj,
kok_adj,
kok_mtx_vals,
kok_x_original);
Experimental::KokkosKernels::Example::CrsMatrix<wt, idx, MyExecSpace> A(nv ,ne, kok_xadj, kok_adj, kok_mtx_vals);
//create X vector
value_array_type kok_x_vector("kok_x_vector", nv);
double gs_time = 0;
const unsigned cg_iteration_limit = 100000;
const double cg_iteration_tolerance = 1e-7 ;
Experimental::KokkosKernels::Example::CGSolveResult cg_result ;
typedef Experimental::KokkosKernels::KokkosKernelsHandle
<idx_array_type,idx_edge_array_type, value_array_type,
MyExecSpace, TemporaryWorkSpace,PersistentWorkSpace > KernelHandle;
KernelHandle kh;
kh.set_row_map(A.graph.row_map);
kh.set_entries(A.graph.entries);
kh.set_values(A.coeff);
Kokkos::Impl::Timer timer1;
Experimental::KokkosKernels::Example::pcgsolve(
kh
, A
, kok_b_vector
, kok_x_vector
, cg_iteration_limit
, cg_iteration_tolerance
, & cg_result
, true
);
Kokkos::fence();
gs_time = timer1.seconds();
std::cout << " cg_iteration[" << cg_result.iteration << "]"
<< " matvec_time[" << cg_result.matvec_time << "]"
<< " cg_residual[" << cg_result.norm_res << "]"
<< " cg_iter_time[" << cg_result.iter_time << "]"
<< " precond_time[" << cg_result.precond_time << "]"
<< " precond_init_time[" << cg_result.precond_init_time << "]"
<< " precond_time/iter[" << cg_result.precond_time / (cg_result.iteration + 1) << "]"
<< " GSTIME[" << gs_time<< "]"
<< std::endl ;
kh.create_graph_coloring_handle(Experimental::KokkosKernels::Graph::COLORING_VB);
Experimental::KokkosKernels::Graph::graph_color_solve<KernelHandle> (&kh);
kok_x_vector = value_array_type("kok_x_vector", nv);
timer1.reset();
Experimental::KokkosKernels::Example::pcgsolve(
kh
, A
, kok_b_vector
, kok_x_vector
, cg_iteration_limit
, cg_iteration_tolerance
, & cg_result
, true
);
Kokkos::fence();
gs_time = timer1.seconds();
std::cout << "\n\nCOLORING_VB PRECALL:\n cg_iteration[" << cg_result.iteration << "]"
<< " matvec_time[" << cg_result.matvec_time << "]"
<< " cg_residual[" << cg_result.norm_res << "]"
<< " cg_iter_time[" << cg_result.iter_time << "]"
<< " precond_time[" << cg_result.precond_time << "]"
<< " precond_init_time[" << cg_result.precond_init_time << "]"
<< " precond_time/iter[" << cg_result.precond_time / (cg_result.iteration + 1) << "]"
<< " GSTIME[" << gs_time<< "]"
<< " numColor[" << kh.get_graph_coloring_handle()->get_num_colors()<<"]"
<< std::endl ;
kh.destroy_graph_coloring_handle();
kh.create_graph_coloring_handle(Experimental::KokkosKernels::Graph::COLORING_EB);
Experimental::KokkosKernels::Graph::graph_color_solve<KernelHandle> (&kh);
kok_x_vector = value_array_type("kok_x_vector", nv);
timer1.reset();
Experimental::KokkosKernels::Example::pcgsolve(
kh
, A
, kok_b_vector
, kok_x_vector
, cg_iteration_limit
, cg_iteration_tolerance
, & cg_result
, true
);
Kokkos::fence();
gs_time = timer1.seconds();
std::cout << "\n\nCOLORING_EB PRECALL:\n cg_iteration[" << cg_result.iteration << "]"
<< " matvec_time[" << cg_result.matvec_time << "]"
<< " cg_residual[" << cg_result.norm_res << "]"
<< " cg_iter_time[" << cg_result.iter_time << "]"
<< " precond_time[" << cg_result.precond_time << "]"
<< " precond_init_time[" << cg_result.precond_init_time << "]"
<< " precond_time/iter[" << cg_result.precond_time / (cg_result.iteration + 1) << "]"
<< " GSTIME[" << gs_time<< "]"
<< " numColor[" << kh.get_graph_coloring_handle()->get_num_colors()<<"]"
<< std::endl ;
kh.destroy_graph_coloring_handle();
kh.destroy_gs_handle();
kh.create_gs_handle(Experimental::KokkosKernels::Graph::GS_PERMUTED);
kok_x_vector = value_array_type("kok_x_vector", nv);
timer1.reset();
Experimental::KokkosKernels::Example::pcgsolve(
kh
, A
, kok_b_vector
, kok_x_vector
, cg_iteration_limit
, cg_iteration_tolerance
, & cg_result
, true
);
Kokkos::fence();
gs_time = timer1.seconds();
std::cout << "\n\nPERMUTED:\n cg_iteration[" << cg_result.iteration << "]"
<< " matvec_time[" << cg_result.matvec_time << "]"
<< " cg_residual[" << cg_result.norm_res << "]"
<< " cg_iter_time[" << cg_result.iter_time << "]"
<< " precond_time[" << cg_result.precond_time << "]"
<< " precond_init_time[" << cg_result.precond_init_time << "]"
<< " precond_time/iter[" << cg_result.precond_time / (cg_result.iteration + 1) << "]"
<< " GSTIME[" << gs_time<< "]"
<< std::endl ;
kh.destroy_graph_coloring_handle();
kh.destroy_gs_handle();
kh.create_gs_handle(Experimental::KokkosKernels::Graph::GS_TEAM);
kok_x_vector = value_array_type("kok_x_vector", nv);
timer1.reset();
Experimental::KokkosKernels::Example::pcgsolve(
kh
, A
, kok_b_vector
, kok_x_vector
, cg_iteration_limit
, cg_iteration_tolerance
, & cg_result
, true
);
Kokkos::fence();
gs_time = timer1.seconds();
std::cout << "\n\nGSTEAM:\n cg_iteration[" << cg_result.iteration << "]"
<< " matvec_time[" << cg_result.matvec_time << "]"
<< " cg_residual[" << cg_result.norm_res << "]"
<< " cg_iter_time[" << cg_result.iter_time << "]"
<< " precond_time[" << cg_result.precond_time << "]"
<< " precond_init_time[" << cg_result.precond_init_time << "]"
<< " precond_time/iter[" << cg_result.precond_time / (cg_result.iteration + 1) << "]"
<< " GSTIME[" << gs_time<< "]"
<< std::endl ;
}
