C++ View::extent方法代码示例

  KOKKOS_INLINE_FUNCTION
  void operator() ( const team_member & thread) const {
    int i = thread.league_rank();

    // Allocate a shared array for the team.
    shared_1d_int count(thread.team_shmem(),data.extent(1));

    // With each team run a parallel_for with its threads
    Kokkos::parallel_for(Kokkos::TeamThreadRange(thread,data.extent(1)), [=] (const int& j) {
      int tsum;
      // Run a vector loop reduction over the inner dimension of data
      // Count how many values are multiples of 4
      // Every vector lane gets the same reduction value (tsum) back, it is broadcast to all vector lanes
      Kokkos::parallel_reduce(Kokkos::ThreadVectorRange(thread,data.extent(2)), [=] (const int& k, int & vsum) {
        vsum+= (data(i,j,k) % 4 == 0)?1:0;
      },tsum);

      // Make sure only one vector lane adds the reduction value to the shared array, i.e. execute
      // the next line only once PerThread
      Kokkos::single(Kokkos::PerThread(thread),[=] () {
        count(j) = tsum;
      });
    });

    // Wait for all threads to finish the parallel_for so that all shared memory writes are done
    thread.team_barrier();

    // Check with one vector lane from each thread how many consecutive
    // data segments have the same number of values divisible by 4
    // The team reduction value is again broadcast to every team member (and every vector lane)
    int team_sum = 0;
    Kokkos::parallel_reduce(Kokkos::TeamThreadRange(thread, data.extent(1)-1), [=] (const int& j, int& thread_sum) {
      // It is not valid to directly add to thread_sum
      // Use a single function with broadcast instead
      // team_sum will be used as input to the operator (i.e. it is used to initialize sum)
      // the end value of sum will be broadcast to all vector lanes in the thread.
      Kokkos::single(Kokkos::PerThread(thread),[=] (int& sum) {
        if(count(j)==count(j+1)) sum++;
      },thread_sum);
    },team_sum);

    // Add with one thread and vectorlane of the team the team_sum to the global value
    Kokkos::single(Kokkos::PerTeam(thread),[=] () {
      Kokkos::atomic_add(&gsum(),team_sum);
    });
  }

void NearestNeighborOperator<DeviceType>::apply(
    Kokkos::View<double const *, DeviceType> source_values,
    Kokkos::View<double *, DeviceType> target_values ) const
{
    // Precondition: check that the source and target are properly sized
    DTK_REQUIRE( _indices.extent( 0 ) == target_values.extent( 0 ) );
    DTK_REQUIRE( _size == source_values.extent_int( 0 ) );

    auto values = Details::NearestNeighborOperatorImpl<DeviceType>::fetch(
        _comm, _ranks, _indices, source_values );

    Kokkos::deep_copy( target_values, values );
}

    static Kokkos::View<size_t *, DeviceType>
    sortQueriesAlongZOrderCurve( Box const &scene_bounding_box,
                                 Kokkos::View<Query *, DeviceType> queries )
    {
        auto const n_queries = queries.extent( 0 );

        Kokkos::View<unsigned int *, DeviceType> morton_codes(
            Kokkos::ViewAllocateWithoutInitializing( "morton" ), n_queries );
        Kokkos::parallel_for(
            ARBORX_MARK_REGION( "assign_morton_codes_to_queries" ),
            Kokkos::RangePolicy<ExecutionSpace>( 0, n_queries ),
            KOKKOS_LAMBDA( int i ) {
                Point xyz = Details::returnCentroid( queries( i )._geometry );
                translateAndScale( xyz, xyz, scene_bounding_box );
                morton_codes( i ) = morton3D( xyz[0], xyz[1], xyz[2] );
            } );

void pointInCell( double threshold,
                  Kokkos::View<Coordinate **, DeviceType> physical_points,
                  Kokkos::View<Coordinate ***, DeviceType> cells,
                  Kokkos::View<int *, DeviceType> coarse_search_output_cells,
                  Kokkos::View<Coordinate **, DeviceType> reference_points,
                  Kokkos::View<bool *, DeviceType> point_in_cell )
{
    using ExecutionSpace = typename DeviceType::execution_space;
    int const n_ref_pts = reference_points.extent( 0 );

    Functor::PointInCell<CellType, DeviceType> search_functor(
        threshold, physical_points, cells, coarse_search_output_cells,
        reference_points, point_in_cell );
    Kokkos::parallel_for( DTK_MARK_REGION( "point_in_cell" ),
                          Kokkos::RangePolicy<ExecutionSpace>( 0, n_ref_pts ),
                          search_functor );
}

void kk_inspector_matvec(AType A, XType x, YType y, int rows_per_thread, int team_size, int vector_length) {

  typedef typename XType::non_const_value_type Scalar;
  typedef typename AType::execution_space execution_space;
  typedef KokkosSparse::CrsMatrix<const Scalar,int,execution_space,void,int> matrix_type ;
  typedef typename Kokkos::View<Scalar*,Kokkos::LayoutLeft,execution_space> y_type;
  typedef typename Kokkos::View<const Scalar*,Kokkos::LayoutLeft,execution_space,Kokkos::MemoryRandomAccess > x_type;

  //int rows_per_team = launch_parameters<execution_space>(A.numRows(),A.nnz(),rows_per_thread,team_size,vector_length);
  //static int worksets = (y.extent(0)+rows_per_team-1)/rows_per_team;
  static int worksets = std::is_same<Schedule,Kokkos::Static>::value ?
                        team_size>0?execution_space::concurrency()/team_size:execution_space::concurrency() : //static
                        team_size>0?execution_space::concurrency()*32/team_size:execution_space::concurrency()*32 ; //dynamic
  static Kokkos::View<int*> workset_offsets;
  if(workset_offsets.extent(0) == 0) {
    workset_offsets = Kokkos::View<int*> ("WorksetOffsets",worksets+1);
    const size_t nnz = A.nnz();
    int nnz_per_workset = (nnz+worksets-1)/worksets;
    workset_offsets(0) = 0;
    int ws = 1;
    for(int row = 0; row<A.numRows(); row++) {
      if(A.graph.row_map(row) > ws*nnz_per_workset) {
        workset_offsets(ws) = row;
        ws++;
      }
    }
    if(workset_offsets(ws-1) < A.numRows()) {
      workset_offsets(ws) = A.numRows();
    }
    printf("Worksets: %i %i\n",worksets,ws);
    worksets = ws;
  }
  double s_a = 1.0;
  double s_b = 0.0;
  SPMV_Inspector_Functor<matrix_type,x_type,y_type,0,false,int> func (s_a,A,x,workset_offsets,s_b,y);

  Kokkos::TeamPolicy<Kokkos::Schedule<Schedule> > policy(1,1);

  if(team_size>0)
    policy = Kokkos::TeamPolicy<Kokkos::Schedule<Schedule> >(worksets,team_size,vector_length);
  else
    policy = Kokkos::TeamPolicy<Kokkos::Schedule<Schedule> >(worksets,Kokkos::AUTO,vector_length);

  Kokkos::parallel_for("KokkosSparse::PerfTest::SpMV_Inspector", policy,func);
}

void PointInCell<DeviceType>::search(
    Kokkos::View<Coordinate **, DeviceType> physical_points,
    Kokkos::View<Coordinate ***, DeviceType> cells,
    Kokkos::View<int *, DeviceType> coarse_search_output_cells,
    DTK_CellTopology cell_topo,
    Kokkos::View<Coordinate **, DeviceType> reference_points,
    Kokkos::View<bool *, DeviceType> point_in_cell )
{
    // Check the size of the Views
    DTK_REQUIRE( reference_points.extent( 0 ) == point_in_cell.extent( 0 ) );
    DTK_REQUIRE( reference_points.extent( 0 ) == physical_points.extent( 0 ) );
    DTK_REQUIRE( reference_points.extent( 1 ) == physical_points.extent( 1 ) );
    DTK_REQUIRE( reference_points.extent( 1 ) == cells.extent( 2 ) );

    // Perform the point in cell search. We hide the template parameters used by
    // Intrepid2, using the CellType template.
    // Note that if the Newton solver does not converge, Intrepid2 will just
    // return the last results and there is no way to know that the coordinates
    // in the reference frames where not found.
    switch ( cell_topo )
    {
    case DTK_HEX_8:
    {
        internal::pointInCell<HEX_8, DeviceType>(
            threshold, physical_points, cells, coarse_search_output_cells,
            reference_points, point_in_cell );
        break;
    }
    case DTK_HEX_27:
    {
        internal::pointInCell<HEX_27, DeviceType>(
            threshold, physical_points, cells, coarse_search_output_cells,
            reference_points, point_in_cell );
        break;
    }
    case DTK_PYRAMID_5:
    {
        internal::pointInCell<PYRAMID_5, DeviceType>(
            threshold, physical_points, cells, coarse_search_output_cells,
            reference_points, point_in_cell );
        break;
    }
    case DTK_QUAD_4:
    {
        internal::pointInCell<QUAD_4, DeviceType>(
            threshold, physical_points, cells, coarse_search_output_cells,
            reference_points, point_in_cell );
        break;
    }
    case DTK_QUAD_9:
    {
        internal::pointInCell<QUAD_9, DeviceType>(
            threshold, physical_points, cells, coarse_search_output_cells,
            reference_points, point_in_cell );
        break;
    }
    case DTK_TET_4:
    {
        internal::pointInCell<TET_4, DeviceType>(
            threshold, physical_points, cells, coarse_search_output_cells,
            reference_points, point_in_cell );
        break;
    }
    case DTK_TET_10:
    {
        internal::pointInCell<TET_10, DeviceType>(
            threshold, physical_points, cells, coarse_search_output_cells,
            reference_points, point_in_cell );
        break;
    }
    case DTK_TRI_3:
    {
        internal::pointInCell<TRI_3, DeviceType>(
            threshold, physical_points, cells, coarse_search_output_cells,
            reference_points, point_in_cell );
        break;
    }
    case DTK_TRI_6:
    {
        internal::pointInCell<TRI_6, DeviceType>(
            threshold, physical_points, cells, coarse_search_output_cells,
            reference_points, point_in_cell );
        break;
    }
    case DTK_WEDGE_6:
    {
        internal::pointInCell<WEDGE_6, DeviceType>(
            threshold, physical_points, cells, coarse_search_output_cells,
            reference_points, point_in_cell );
        break;
    }
    case DTK_WEDGE_18:
    {
        internal::pointInCell<WEDGE_18, DeviceType>(
            threshold, physical_points, cells, coarse_search_output_cells,
            reference_points, point_in_cell );
        break;
    }
    default:
    {
//.........这里部分代码省略.........

 // The functor needs to define how much shared memory it requests given a team_size.
 size_t team_shmem_size( int team_size ) const {
   return shared_1d_int::shmem_size(data.extent(1));
 }

TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( MeshGenerator, structured, DeviceType )
{
    MPI_Comm comm = MPI_COMM_WORLD;
    Kokkos::View<DTK_CellTopology *, DeviceType> cell_topologies_view;
    Kokkos::View<unsigned int *, DeviceType> cells;
    Kokkos::View<double **, DeviceType> coordinates;

    // 2D test
    std::string filename = "structured_2d.txt";
    std::vector<std::vector<DataTransferKit::Coordinate>> coordinates_ref;
    std::vector<unsigned int> cells_ref;
    std::tie( coordinates_ref, cells_ref ) = readInputFile( filename );
    // Move mesh according to the rank
    int comm_rank;
    MPI_Comm_rank( comm, &comm_rank );
    std::vector<unsigned int> n_subdivisions = {{4, 3}};
    double offset = n_subdivisions[1] * comm_rank;
    for ( auto &coord : coordinates_ref )
        coord[1] += offset;

    std::tie( cell_topologies_view, cells, coordinates ) =
        buildStructuredMesh<DeviceType>( comm, n_subdivisions );

    // Check view size
    unsigned int n_vertices = coordinates_ref.size();
    unsigned int n_cells = 1;
    for ( auto n_sub : n_subdivisions )
        n_cells *= n_sub;
    TEST_EQUALITY( cell_topologies_view.extent( 0 ), n_cells );
    TEST_EQUALITY( cells.extent( 0 ), cells_ref.size() );
    TEST_EQUALITY( coordinates.extent( 0 ), n_vertices );

    // Check topology
    auto cell_topologies_view_host =
        Kokkos::create_mirror_view( cell_topologies_view );
    Kokkos::deep_copy( cell_topologies_view_host, cell_topologies_view );
    for ( unsigned int i = 0; i < n_cells; ++i )
        TEST_EQUALITY( cell_topologies_view_host( i ), DTK_QUAD_4 );

    // Check cells
    auto cells_host = Kokkos::create_mirror_view( cells );
    Kokkos::deep_copy( cells_host, cells );
    TEST_COMPARE_ARRAYS( cells_host, cells_ref );

    // Check coordinates
    unsigned int dim = 2;
    auto coordinates_host = Kokkos::create_mirror_view( coordinates );
    Kokkos::deep_copy( coordinates_host, coordinates );
    for ( unsigned int i = 0; i < n_vertices; ++i )
        for ( unsigned int j = 0; j < dim; ++j )
            TEST_EQUALITY( coordinates_host( i, j ), coordinates_ref[i][j] );

    // 3D test
    filename = "structured_3d.txt";
    std::tie( coordinates_ref, cells_ref ) = readInputFile( filename );
    // Move mesh according to the rank
    n_subdivisions = {{2, 3, 4}};
    offset = n_subdivisions[2] * comm_rank;
    for ( auto &coord : coordinates_ref )
        coord[2] += offset;

    std::tie( cell_topologies_view, cells, coordinates ) =
        buildStructuredMesh<DeviceType>( comm, n_subdivisions );

    n_vertices = coordinates_ref.size();
    n_cells = 1;
    for ( auto n_sub : n_subdivisions )
        n_cells *= n_sub;

    TEST_EQUALITY( cell_topologies_view.extent( 0 ), n_cells );
    TEST_EQUALITY( cells.extent( 0 ), cells_ref.size() );
    TEST_EQUALITY( coordinates.extent( 0 ), n_vertices );

    // Check topology
    cell_topologies_view_host =
        Kokkos::create_mirror_view( cell_topologies_view );
    Kokkos::deep_copy( cell_topologies_view_host, cell_topologies_view );
    for ( unsigned int i = 0; i < n_cells; ++i )
        TEST_EQUALITY( cell_topologies_view_host( i ), DTK_HEX_8 );

    // Check cells
    cells_host = Kokkos::create_mirror_view( cells );
    Kokkos::deep_copy( cells_host, cells );
    TEST_COMPARE_ARRAYS( cells_host, cells_ref );

    // Check coordinates
    dim = 3;
    coordinates_host = Kokkos::create_mirror_view( coordinates );
    Kokkos::deep_copy( coordinates_host, coordinates );
    for ( unsigned int i = 0; i < n_vertices; ++i )
        for ( unsigned int j = 0; j < dim; ++j )
            TEST_EQUALITY( coordinates_host( i, j ), coordinates_ref[i][j] );
}

TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( MeshGenerator, simplex, DeviceType )
{
    MPI_Comm comm = MPI_COMM_WORLD;

    Kokkos::View<DTK_CellTopology *, DeviceType> cell_topologies_view;
    Kokkos::View<unsigned int *, DeviceType> cells;
    Kokkos::View<double **, DeviceType> coordinates;

    // 2D test
    std::vector<unsigned int> n_subdivisions = {{4, 3}};
    unsigned int n_cells = 2;
    for ( auto n_sub : n_subdivisions )
        n_cells *= n_sub;
    unsigned int constexpr dim_2 = 2;
    unsigned int constexpr n_vertices_per_tri = 3;
    int comm_rank;
    MPI_Comm_rank( comm, &comm_rank );
    double offset = comm_rank * n_subdivisions[1];
    std::vector<std::array<std::array<double, dim_2>, n_vertices_per_tri>>
        tri_mesh_ref( n_cells );
    unsigned int n = 0;
    for ( unsigned int i = 0; i < n_subdivisions[1]; ++i )
        for ( unsigned int j = 0; j < n_subdivisions[0]; ++j )
        {
            tri_mesh_ref[n][0][0] = j;
            tri_mesh_ref[n][0][1] = i + offset;

            tri_mesh_ref[n][1][0] = j + 1;
            tri_mesh_ref[n][1][1] = i + offset;

            tri_mesh_ref[n][2][0] = j;
            tri_mesh_ref[n][2][1] = i + 1 + offset;

            ++n;

            tri_mesh_ref[n][0][0] = j + 1;
            tri_mesh_ref[n][0][1] = i + offset;

            tri_mesh_ref[n][1][0] = j + 1;
            tri_mesh_ref[n][1][1] = i + 1 + offset;

            tri_mesh_ref[n][2][0] = j;
            tri_mesh_ref[n][2][1] = i + 1 + offset;

            ++n;
        }

    std::tie( cell_topologies_view, cells, coordinates ) =
        buildSimplexMesh<DeviceType>( comm, n_subdivisions );
    TEST_EQUALITY( cell_topologies_view.extent( 0 ), n_cells );
    TEST_EQUALITY( cells.extent( 0 ), n_cells * n_vertices_per_tri );

    auto cell_topologies_view_host =
        Kokkos::create_mirror_view( cell_topologies_view );
    Kokkos::deep_copy( cell_topologies_view_host, cell_topologies_view );
    for ( unsigned int i = 0; i < n_cells; ++i )
        TEST_EQUALITY( cell_topologies_view_host( i ), DTK_TRI_3 );

    auto cells_host = Kokkos::create_mirror_view( cells );
    Kokkos::deep_copy( cells_host, cells );
    auto coordinates_host = Kokkos::create_mirror_view( coordinates );
    Kokkos::deep_copy( coordinates_host, coordinates );
    n = 0;
    for ( unsigned int i = 0; i < n_cells; ++i )
    {
        for ( unsigned int j = 0; j < n_vertices_per_tri; ++j )
        {
            for ( unsigned int k = 0; k < dim_2; ++k )
            {
                unsigned int coord_pos = cells_host( n );
                TEST_EQUALITY( coordinates_host( coord_pos, k ),
                               tri_mesh_ref[i][j][k] );
            }

            ++n;
        }
    }

    // 3D test
    n_subdivisions = {{2, 2, 2}};
    n_cells = 5;
    for ( auto n_sub : n_subdivisions )
        n_cells *= n_sub;
    unsigned int constexpr n_vertices_per_tet = 4;
    offset = comm_rank * n_subdivisions[2];

    unsigned int constexpr dim_3 = 3;
    std::vector<std::array<std::array<double, dim_3>, n_vertices_per_tet>>
        tet_mesh_ref( n_cells );
    n = 0;
    for ( unsigned int i = 0; i < n_subdivisions[2]; i += 2 )
        for ( unsigned int j = 0; j < n_subdivisions[1]; ++j )
            for ( unsigned int k = 0; k < n_subdivisions[0]; ++k )
            {
                // First tet
                tet_mesh_ref[n][0][0] = k;
                tet_mesh_ref[n][0][1] = j;
                tet_mesh_ref[n][0][2] = i + offset;

                tet_mesh_ref[n][1][0] = k + 1;
//.........这里部分代码省略.........