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;
}
Exemplo n.º 2
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;
}
Exemplo n.º 3
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;
}
Exemplo n.º 5
0
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 ;




}