MueLu  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
MueLu_Aggregates_kokkos_decl.hpp
Go to the documentation of this file.
1 // @HEADER
2 //
3 // ***********************************************************************
4 //
5 // MueLu: A package for multigrid based preconditioning
6 // Copyright 2012 Sandia Corporation
7 //
8 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9 // the U.S. Government retains certain rights in this software.
10 //
11 // Redistribution and use in source and binary forms, with or without
12 // modification, are permitted provided that the following conditions are
13 // met:
14 //
15 // 1. Redistributions of source code must retain the above copyright
16 // notice, this list of conditions and the following disclaimer.
17 //
18 // 2. Redistributions in binary form must reproduce the above copyright
19 // notice, this list of conditions and the following disclaimer in the
20 // documentation and/or other materials provided with the distribution.
21 //
22 // 3. Neither the name of the Corporation nor the names of the
23 // contributors may be used to endorse or promote products derived from
24 // this software without specific prior written permission.
25 //
26 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 //
38 // Questions? Contact
39 // Jonathan Hu (jhu@sandia.gov)
40 // Andrey Prokopenko (aprokop@sandia.gov)
41 // Ray Tuminaro (rstumin@sandia.gov)
42 // Tobias Wiesner (tawiesn@sandia.gov)
43 //
44 // ***********************************************************************
45 //
46 // @HEADER
47 #ifndef MUELU_AGGREGATES_KOKKOS_DECL_HPP
48 #define MUELU_AGGREGATES_KOKKOS_DECL_HPP
49 
50 #include "MueLu_ConfigDefs.hpp"
51 
52 #include <Kokkos_StaticCrsGraph.hpp>
53 #include <Tpetra_KokkosCompat_ClassicNodeAPI_Wrapper.hpp>
54 
56 
57 #include <Xpetra_Map_fwd.hpp>
58 #include <Xpetra_Vector_fwd.hpp>
60 
61 #include "MueLu_BaseClass.hpp"
62 
63 #include "MueLu_LWGraph_kokkos.hpp"
64 #include "MueLu_IndexManager_kokkos.hpp"
65 
66 #define MUELU_UNAGGREGATED -1 /* indicates that a node is unassigned to */
67  /* any aggregate. */
68 
69 #define MUELU_UNASSIGNED -1 /* indicates a vertex is not yet claimed */
70  /* by a processor during aggregation. */
71  /* Note, it is possible at */
72  /* this stage that some processors may have*/
73  /* claimed their copy of a vertex for one */
74  /* of their aggregates. However, some */
75  /* arbitration still needs to occur. */
76  /* The corresponding procWinner[]'s remain */
77  /* as MUELU_UNASSIGNED until */
78  /* ArbitrateAndCommunicate() is */
79  /* invoked to arbitrate. */
80 
81 /*****************************************************************************
82 
83 ****************************************************************************/
84 
85 namespace MueLu {
86 
102  template <class LocalOrdinal, class GlobalOrdinal, class Node>
104 
105  template <class LocalOrdinal, class GlobalOrdinal, class DeviceType>
106  class Aggregates_kokkos<LocalOrdinal, GlobalOrdinal, Tpetra::KokkosCompat::KokkosDeviceWrapperNode<DeviceType> > : public BaseClass {
107  public:
108  // For some reason we seem intent on having these declared before pulling the short names in
109  // I am not sure why but I will keep things as it is for now
110  // If you need to define a type that depend on a short name please do it further down after
111  // the header has been included!
114  using execution_space = typename DeviceType::execution_space;
115  using node_type = Tpetra::KokkosCompat::KokkosDeviceWrapperNode<DeviceType>;
116  using device_type = DeviceType;
117  using range_type = Kokkos::RangePolicy<local_ordinal_type, execution_space>;
118  using LO_view = Kokkos::View<local_ordinal_type*, device_type>;
119 
120  using aggregates_sizes_type = Kokkos::View<LocalOrdinal*, device_type>;
121 
122  private:
123  // For compatibility
124  typedef node_type Node;
125 #undef MUELU_AGGREGATES_KOKKOS_SHORT
127 
128  public:
129 
130  // Defining types that require the short names included above
131  using local_graph_type = typename LWGraph_kokkos::local_graph_type;
132  using colors_view_type = Kokkos::View<typename local_graph_type::entries_type::data_type,
133  typename local_graph_type::device_type::memory_space>;
134 
143 
149  Aggregates_kokkos(const RCP<const Map>& map);
150 
154  virtual ~Aggregates_kokkos() { }
155 
157 
158 
163 
167  void SetIndexManager(RCP<IndexManager_kokkos> & geoData) { geoData_ = geoData; }
168 
172  colors_view_type& GetGraphColors() { return graphColors_; }
173 
177  void SetGraphColors(colors_view_type graphColors) { graphColors_ = graphColors; }
178 
181  LO GetGraphNumColors() { return graphNumColors_; }
182 
185  void SetGraphNumColors(const LO graphNumColors) { graphNumColors_ = graphNumColors; }
186 
188 
193  void SetNumAggregates(LO nAggregates) { numAggregates_ = nAggregates; }
194 
199  void SetNumGlobalAggregates(GO nGlobalAggregates) { numGlobalAggregates_ = nGlobalAggregates; }
200 
202  KOKKOS_INLINE_FUNCTION LO GetNumAggregates() const {
203  return numAggregates_;
204  }
205 
207  KOKKOS_INLINE_FUNCTION void AggregatesCrossProcessors(const bool& flag) {
208  aggregatesIncludeGhosts_ = flag;
209  }
210 
215  KOKKOS_INLINE_FUNCTION bool AggregatesCrossProcessors() const {
216  return aggregatesIncludeGhosts_;
217  }
218 
223  RCP<LOMultiVector>& GetVertex2AggIdNonConst() { return vertex2AggId_; }
224 
229  RCP<LOVector>& GetProcWinnerNonConst() { return procWinner_; }
234  const RCP<LOMultiVector>& GetVertex2AggId() const { return vertex2AggId_; }
235 
240  const RCP<LOVector>& GetProcWinner() const { return procWinner_; }
241 
243  KOKKOS_INLINE_FUNCTION
244  bool IsRoot(LO i) const { return isRoot_(i); }
245 
250  KOKKOS_INLINE_FUNCTION
251  void SetIsRoot(LO i, bool value = true) { isRoot_(i) = value; }
252 
253  const RCP<const Map> GetMap() const;
254 
264  typename aggregates_sizes_type::const_type ComputeAggregateSizes(bool forceRecompute = false) const;
265 
266  local_graph_type GetGraph() const;
267 
272  void ComputeNodesInAggregate(LO_view & aggPtr, LO_view & aggNodes, LO_view & unaggregated) const;
273 
275  // If # of global aggregates is unknown, this method does coummunication and internally record the value
276  GO GetNumGlobalAggregatesComputeIfNeeded();
277 
279 
280 
282  std::string description() const;
283 
285  //using MueLu::Describable::describe; // overloading, not hiding
286  void print(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel = verbLevel_default) const;
287 
288  private:
291 
297 
303 
308 
313 
318 
319  Kokkos::View<bool*, device_type> isRoot_;
320 
323 
325  mutable
327 
329  mutable
331  };
332 
333 } //namespace MueLu
334 
335 #define MUELU_AGGREGATES_KOKKOS_SHORT
336 #endif // MUELU_AGGREGATES_KOKKOS_DECL_HPP
MueLu::DefaultLocalOrdinal LocalOrdinal
KOKKOS_INLINE_FUNCTION void AggregatesCrossProcessors(const bool &flag)
Record whether aggregates include DOFs from other processes.
Lightweight MueLu representation of a compressed row storage graph.
KOKKOS_INLINE_FUNCTION bool AggregatesCrossProcessors() const
Return false if and only if no aggregates include DOFs from other processes.
GlobalOrdinal GO
void SetGraphColors(colors_view_type graphColors)
Set a distance 2 coloring of the underlying graph. The coloring is computed and set during Phase1 of ...
LocalOrdinal LO
const RCP< LOMultiVector > & GetVertex2AggId() const
Returns constant vector that maps local node IDs to local aggregates IDs.
MueLu::DefaultGlobalOrdinal GlobalOrdinal
RCP< IndexManager_kokkos > & GetIndexManager()
Get the index manager used by structured aggregation algorithms. This has to be done by the aggregati...
const RCP< LOVector > & GetProcWinner() const
Returns constant vector that maps local node IDs to owning processor IDs.
Base class for MueLu classes.
void SetGraphNumColors(const LO graphNumColors)
Set the number of colors needed by the distance 2 coloring.
RCP< LOVector > & GetProcWinnerNonConst()
Returns nonconsant vector that maps local node IDs to owning processor IDs.
RCP< LOMultiVector > & GetVertex2AggIdNonConst()
Returns a nonconstant vector that maps local node IDs to local aggregates IDs.
Kokkos::View< typename local_graph_type::entries_type::data_type, typename local_graph_type::device_type::memory_space > colors_view_type
KOKKOS_INLINE_FUNCTION bool IsRoot(LO i) const
Returns true if node with given local node id is marked to be a root node.
colors_view_type & GetGraphColors()
Get a distance 2 coloring of the underlying graph. The coloring is computed and set during Phase1 of ...
void SetIndexManager(RCP< IndexManager_kokkos > &geoData)
Set the index manager used by structured aggregation algorithms. This has to be done by the aggregati...
bool aggregatesIncludeGhosts_
Set to false iff aggregates do not include any DOFs belong to other processes.