Tpetra parallel linear algebra  Version of the Day
Tpetra_DistObject_def.hpp
Go to the documentation of this file.
1 // @HEADER
2 // ***********************************************************************
3 //
4 // Tpetra: Templated Linear Algebra Services Package
5 // Copyright (2008) Sandia Corporation
6 //
7 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
8 // the U.S. Government retains certain rights in this software.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // ************************************************************************
38 // @HEADER
39 
40 #ifndef TPETRA_DISTOBJECT_DEF_HPP
41 #define TPETRA_DISTOBJECT_DEF_HPP
42 
50 
51 #include "Tpetra_Distributor.hpp"
52 #include "Tpetra_Details_reallocDualViewIfNeeded.hpp"
53 #include "Tpetra_Details_Behavior.hpp"
54 #include "Tpetra_Details_checkGlobalError.hpp"
55 #include "Tpetra_Details_Profiling.hpp"
56 #include "Tpetra_Util.hpp" // Details::createPrefix
57 #include "Teuchos_CommHelpers.hpp"
58 #include "Teuchos_TypeNameTraits.hpp"
59 #include <typeinfo>
60 #include <memory>
61 #include <sstream>
62 
63 namespace Tpetra {
64 
65  namespace { // (anonymous)
66  template<class DeviceType, class IndexType = size_t>
67  struct SumFunctor {
68  SumFunctor (const Kokkos::View<const size_t*, DeviceType>& viewToSum) :
69  viewToSum_ (viewToSum) {}
70  KOKKOS_INLINE_FUNCTION void operator() (const IndexType i, size_t& lclSum) const {
71  lclSum += viewToSum_(i);
72  }
73  Kokkos::View<const size_t*, DeviceType> viewToSum_;
74  };
75 
76  template<class DeviceType, class IndexType = size_t>
77  size_t
78  countTotalImportPackets (const Kokkos::View<const size_t*, DeviceType>& numImportPacketsPerLID)
79  {
80  using Kokkos::parallel_reduce;
81  typedef DeviceType DT;
82  typedef typename DT::execution_space DES;
83  typedef Kokkos::RangePolicy<DES, IndexType> range_type;
84 
85  const IndexType numOut = numImportPacketsPerLID.extent (0);
86  size_t totalImportPackets = 0;
87  parallel_reduce ("Count import packets",
88  range_type (0, numOut),
89  SumFunctor<DeviceType, IndexType> (numImportPacketsPerLID),
90  totalImportPackets);
91  return totalImportPackets;
92  }
93  } // namespace (anonymous)
94 
95 
96  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
97  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
98  DistObject (const Teuchos::RCP<const map_type>& map) :
99  map_ (map)
100  {
101 #ifdef HAVE_TPETRA_TRANSFER_TIMERS
102  using Teuchos::RCP;
103  using Teuchos::Time;
104  using Teuchos::TimeMonitor;
105 
106  RCP<Time> doXferTimer =
107  TimeMonitor::lookupCounter ("Tpetra::DistObject::doTransfer");
108  if (doXferTimer.is_null ()) {
109  doXferTimer =
110  TimeMonitor::getNewCounter ("Tpetra::DistObject::doTransfer");
111  }
112  doXferTimer_ = doXferTimer;
113 
114  RCP<Time> copyAndPermuteTimer =
115  TimeMonitor::lookupCounter ("Tpetra::DistObject::copyAndPermute");
116  if (copyAndPermuteTimer.is_null ()) {
117  copyAndPermuteTimer =
118  TimeMonitor::getNewCounter ("Tpetra::DistObject::copyAndPermute");
119  }
120  copyAndPermuteTimer_ = copyAndPermuteTimer;
121 
122  RCP<Time> packAndPrepareTimer =
123  TimeMonitor::lookupCounter ("Tpetra::DistObject::packAndPrepare");
124  if (packAndPrepareTimer.is_null ()) {
125  packAndPrepareTimer =
126  TimeMonitor::getNewCounter ("Tpetra::DistObject::packAndPrepare");
127  }
128  packAndPrepareTimer_ = packAndPrepareTimer;
129 
130  RCP<Time> doPostsAndWaitsTimer =
131  TimeMonitor::lookupCounter ("Tpetra::DistObject::doPostsAndWaits");
132  if (doPostsAndWaitsTimer.is_null ()) {
133  doPostsAndWaitsTimer =
134  TimeMonitor::getNewCounter ("Tpetra::DistObject::doPostsAndWaits");
135  }
136  doPostsAndWaitsTimer_ = doPostsAndWaitsTimer;
137 
138  RCP<Time> unpackAndCombineTimer =
139  TimeMonitor::lookupCounter ("Tpetra::DistObject::unpackAndCombine");
140  if (unpackAndCombineTimer.is_null ()) {
141  unpackAndCombineTimer =
142  TimeMonitor::getNewCounter ("Tpetra::DistObject::unpackAndCombine");
143  }
144  unpackAndCombineTimer_ = unpackAndCombineTimer;
145 #endif // HAVE_TPETRA_TRANSFER_TIMERS
146  }
147 
148  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
149  std::string
150  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
151  description () const
152  {
153  using Teuchos::TypeNameTraits;
154 
155  std::ostringstream os;
156  os << "\"Tpetra::DistObject\": {"
157  << "Packet: " << TypeNameTraits<packet_type>::name ()
158  << ", LocalOrdinal: " << TypeNameTraits<local_ordinal_type>::name ()
159  << ", GlobalOrdinal: " << TypeNameTraits<global_ordinal_type>::name ()
160  << ", Node: " << TypeNameTraits<Node>::name ();
161  if (this->getObjectLabel () != "") {
162  os << "Label: \"" << this->getObjectLabel () << "\"";
163  }
164  os << "}";
165  return os.str ();
166  }
167 
168  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
169  void
170  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
171  describe (Teuchos::FancyOStream &out,
172  const Teuchos::EVerbosityLevel verbLevel) const
173  {
174  using Teuchos::rcpFromRef;
175  using Teuchos::TypeNameTraits;
176  using std::endl;
177  const Teuchos::EVerbosityLevel vl = (verbLevel == Teuchos::VERB_DEFAULT) ?
178  Teuchos::VERB_LOW : verbLevel;
179  Teuchos::RCP<const Teuchos::Comm<int> > comm = this->getMap ()->getComm ();
180  const int myRank = comm.is_null () ? 0 : comm->getRank ();
181  const int numProcs = comm.is_null () ? 1 : comm->getSize ();
182 
183  if (vl != Teuchos::VERB_NONE) {
184  Teuchos::OSTab tab0 (out);
185  if (myRank == 0) {
186  out << "\"Tpetra::DistObject\":" << endl;
187  }
188  Teuchos::OSTab tab1 (out);
189  if (myRank == 0) {
190  out << "Template parameters:" << endl;
191  {
192  Teuchos::OSTab tab2 (out);
193  out << "Packet: " << TypeNameTraits<packet_type>::name () << endl
194  << "LocalOrdinal: " << TypeNameTraits<local_ordinal_type>::name () << endl
195  << "GlobalOrdinal: " << TypeNameTraits<global_ordinal_type>::name () << endl
196  << "Node: " << TypeNameTraits<node_type>::name () << endl;
197  }
198  if (this->getObjectLabel () != "") {
199  out << "Label: \"" << this->getObjectLabel () << "\"" << endl;
200  }
201  } // if myRank == 0
202 
203  // Describe the Map.
204  {
205  if (myRank == 0) {
206  out << "Map:" << endl;
207  }
208  Teuchos::OSTab tab2 (out);
209  map_->describe (out, vl);
210  }
211 
212  // At verbosity > VERB_LOW, each process prints something.
213  if (vl > Teuchos::VERB_LOW) {
214  for (int p = 0; p < numProcs; ++p) {
215  if (myRank == p) {
216  out << "Process " << myRank << ":" << endl;
217  Teuchos::OSTab tab2 (out);
218  out << "Export buffer size (in packets): "
219  << exports_.extent (0)
220  << endl
221  << "Import buffer size (in packets): "
222  << imports_.extent (0)
223  << endl;
224  }
225  if (! comm.is_null ()) {
226  comm->barrier (); // give output time to finish
227  comm->barrier ();
228  comm->barrier ();
229  }
230  } // for each process rank p
231  } // if vl > VERB_LOW
232  } // if vl != VERB_NONE
233  }
234 
235  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
236  void
237  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
238  removeEmptyProcessesInPlace (const Teuchos::RCP<const map_type>& /* newMap */)
239  {
240  TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
241  "Tpetra::DistObject::removeEmptyProcessesInPlace: Not implemented");
242  }
243 
244  /* These are provided in base DistObject template
245  template<class DistObjectType>
246  void
247  removeEmptyProcessesInPlace (Teuchos::RCP<DistObjectType>& input,
248  const Teuchos::RCP<const Map<typename DistObjectType::local_ordinal_type,
249  typename DistObjectType::global_ordinal_type,
250  typename DistObjectType::node_type> >& newMap)
251  {
252  input->removeEmptyProcessesInPlace (newMap);
253  if (newMap.is_null ()) { // my process is excluded
254  input = Teuchos::null;
255  }
256  }
257 
258  template<class DistObjectType>
259  void
260  removeEmptyProcessesInPlace (Teuchos::RCP<DistObjectType>& input)
261  {
262  using Teuchos::RCP;
263  typedef typename DistObjectType::local_ordinal_type LO;
264  typedef typename DistObjectType::global_ordinal_type GO;
265  typedef typename DistObjectType::node_type NT;
266  typedef Map<LO, GO, NT> map_type;
267 
268  RCP<const map_type> newMap = input->getMap ()->removeEmptyProcesses ();
269  removeEmptyProcessesInPlace<DistObjectType> (input, newMap);
270  }
271  */
272 
273  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
274  void
275  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
276  doImport (const SrcDistObject& source,
277  const Import<LocalOrdinal, GlobalOrdinal, Node>& importer,
278  const CombineMode CM,
279  const bool restrictedMode)
280  {
281  using Details::Behavior;
282  using std::endl;
283  const char modeString[] = "doImport (forward mode)";
284 
285  // mfh 18 Oct 2017: Set TPETRA_VERBOSE to true for copious debug
286  // output to std::cerr on every MPI process. This is unwise for
287  // runs with large numbers of MPI processes.
288  const bool verbose = Behavior::verbose("DistObject");
289  std::unique_ptr<std::string> prefix;
290  if (verbose) {
291  prefix = this->createPrefix("DistObject", modeString);
292  std::ostringstream os;
293  os << *prefix << "Start" << endl;
294  std::cerr << os.str ();
295  }
296  this->beginImport(source, importer, CM, restrictedMode);
297  this->endImport(source, importer, CM, restrictedMode);
298  if (verbose) {
299  std::ostringstream os;
300  os << *prefix << "Done" << endl;
301  std::cerr << os.str ();
302  }
303  }
304 
305  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
306  void
307  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
308  doExport (const SrcDistObject& source,
309  const Export<LocalOrdinal, GlobalOrdinal, Node>& exporter,
310  const CombineMode CM,
311  const bool restrictedMode)
312  {
313  using Details::Behavior;
314  using std::endl;
315  const char modeString[] = "doExport (forward mode)";
316 
317  // mfh 18 Oct 2017: Set TPETRA_VERBOSE to true for copious debug
318  // output to std::cerr on every MPI process. This is unwise for
319  // runs with large numbers of MPI processes.
320  const bool verbose = Behavior::verbose("DistObject");
321  std::unique_ptr<std::string> prefix;
322  if (verbose) {
323  prefix = this->createPrefix("DistObject", modeString);
324  std::ostringstream os;
325  os << *prefix << "Start" << endl;
326  std::cerr << os.str ();
327  }
328  this->beginExport(source, exporter, CM, restrictedMode);
329  this->endExport(source, exporter, CM, restrictedMode);
330  if (verbose) {
331  std::ostringstream os;
332  os << *prefix << "Done" << endl;
333  std::cerr << os.str ();
334  }
335  }
336 
337  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
338  void
339  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
340  doImport (const SrcDistObject& source,
341  const Export<LocalOrdinal, GlobalOrdinal, Node>& exporter,
342  const CombineMode CM,
343  const bool restrictedMode)
344  {
345  using Details::Behavior;
346  using std::endl;
347  const char modeString[] = "doImport (reverse mode)";
348 
349  // mfh 18 Oct 2017: Set TPETRA_VERBOSE to true for copious debug
350  // output to std::cerr on every MPI process. This is unwise for
351  // runs with large numbers of MPI processes.
352  const bool verbose = Behavior::verbose("DistObject");
353  std::unique_ptr<std::string> prefix;
354  if (verbose) {
355  prefix = this->createPrefix("DistObject", modeString);
356  std::ostringstream os;
357  os << *prefix << "Start" << endl;
358  std::cerr << os.str ();
359  }
360  this->beginImport(source, exporter, CM, restrictedMode);
361  this->endImport(source, exporter, CM, restrictedMode);
362  if (verbose) {
363  std::ostringstream os;
364  os << *prefix << "Done" << endl;
365  std::cerr << os.str ();
366  }
367  }
368 
369  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
370  void
371  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
372  doExport (const SrcDistObject& source,
373  const Import<LocalOrdinal, GlobalOrdinal, Node> & importer,
374  const CombineMode CM,
375  const bool restrictedMode)
376  {
377  using Details::Behavior;
378  using std::endl;
379  const char modeString[] = "doExport (reverse mode)";
380 
381  // mfh 18 Oct 2017: Set TPETRA_VERBOSE to true for copious debug
382  // output to std::cerr on every MPI process. This is unwise for
383  // runs with large numbers of MPI processes.
384  const bool verbose = Behavior::verbose("DistObject");
385  std::unique_ptr<std::string> prefix;
386  if (verbose) {
387  prefix = this->createPrefix("DistObject", modeString);
388  std::ostringstream os;
389  os << *prefix << "Start" << endl;
390  std::cerr << os.str ();
391  }
392  this->beginExport(source, importer, CM, restrictedMode);
393  this->endExport(source, importer, CM, restrictedMode);
394  if (verbose) {
395  std::ostringstream os;
396  os << *prefix << "Done" << endl;
397  std::cerr << os.str ();
398  }
399  }
400 
401  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
402  void
403  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
404  beginImport(const SrcDistObject& source,
405  const Import<LocalOrdinal, GlobalOrdinal, Node>& importer,
406  const CombineMode CM,
407  const bool restrictedMode)
408  {
409  using Details::Behavior;
410  using std::endl;
411  const char modeString[] = "doImport (forward mode)";
412 
413  // mfh 18 Oct 2017: Set TPETRA_VERBOSE to true for copious debug
414  // output to std::cerr on every MPI process. This is unwise for
415  // runs with large numbers of MPI processes.
416  const bool verbose = Behavior::verbose("DistObject");
417  std::unique_ptr<std::string> prefix;
418  if (verbose) {
419  prefix = this->createPrefix("DistObject", modeString);
420  std::ostringstream os;
421  os << *prefix << "Start" << endl;
422  std::cerr << os.str ();
423  }
424  this->beginTransfer(source, importer, modeString, DoForward, CM, restrictedMode);
425  if (verbose) {
426  std::ostringstream os;
427  os << *prefix << "Done" << endl;
428  std::cerr << os.str ();
429  }
430  }
431 
432  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
433  void
434  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
435  beginExport(const SrcDistObject& source,
436  const Export<LocalOrdinal, GlobalOrdinal, Node>& exporter,
437  const CombineMode CM,
438  const bool restrictedMode)
439  {
440  using Details::Behavior;
441  using std::endl;
442  const char modeString[] = "doExport (forward mode)";
443 
444  // mfh 18 Oct 2017: Set TPETRA_VERBOSE to true for copious debug
445  // output to std::cerr on every MPI process. This is unwise for
446  // runs with large numbers of MPI processes.
447  const bool verbose = Behavior::verbose("DistObject");
448  std::unique_ptr<std::string> prefix;
449  if (verbose) {
450  prefix = this->createPrefix("DistObject", modeString);
451  std::ostringstream os;
452  os << *prefix << "Start" << endl;
453  std::cerr << os.str ();
454  }
455  this->beginTransfer(source, exporter, modeString, DoForward, CM, restrictedMode);
456  if (verbose) {
457  std::ostringstream os;
458  os << *prefix << "Done" << endl;
459  std::cerr << os.str ();
460  }
461  }
462 
463  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
464  void
465  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
466  beginImport(const SrcDistObject& source,
467  const Export<LocalOrdinal, GlobalOrdinal, Node>& exporter,
468  const CombineMode CM,
469  const bool restrictedMode)
470  {
471  using Details::Behavior;
472  using std::endl;
473  const char modeString[] = "doImport (reverse mode)";
474 
475  // mfh 18 Oct 2017: Set TPETRA_VERBOSE to true for copious debug
476  // output to std::cerr on every MPI process. This is unwise for
477  // runs with large numbers of MPI processes.
478  const bool verbose = Behavior::verbose("DistObject");
479  std::unique_ptr<std::string> prefix;
480  if (verbose) {
481  prefix = this->createPrefix("DistObject", modeString);
482  std::ostringstream os;
483  os << *prefix << "Start" << endl;
484  std::cerr << os.str ();
485  }
486  this->beginTransfer(source, exporter, modeString, DoReverse, CM, restrictedMode);
487  if (verbose) {
488  std::ostringstream os;
489  os << *prefix << "Done" << endl;
490  std::cerr << os.str ();
491  }
492  }
493 
494  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
495  void
496  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
497  beginExport(const SrcDistObject& source,
498  const Import<LocalOrdinal, GlobalOrdinal, Node> & importer,
499  const CombineMode CM,
500  const bool restrictedMode)
501  {
502  using Details::Behavior;
503  using std::endl;
504  const char modeString[] = "doExport (reverse mode)";
505 
506  // mfh 18 Oct 2017: Set TPETRA_VERBOSE to true for copious debug
507  // output to std::cerr on every MPI process. This is unwise for
508  // runs with large numbers of MPI processes.
509  const bool verbose = Behavior::verbose("DistObject");
510  std::unique_ptr<std::string> prefix;
511  if (verbose) {
512  prefix = this->createPrefix("DistObject", modeString);
513  std::ostringstream os;
514  os << *prefix << "Start" << endl;
515  std::cerr << os.str ();
516  }
517  this->beginTransfer(source, importer, modeString, DoReverse, CM, restrictedMode);
518  if (verbose) {
519  std::ostringstream os;
520  os << *prefix << "Done" << endl;
521  std::cerr << os.str ();
522  }
523  }
524 
525  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
526  void
527  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
528  endImport(const SrcDistObject& source,
529  const Import<LocalOrdinal, GlobalOrdinal, Node>& importer,
530  const CombineMode CM,
531  const bool restrictedMode)
532  {
533  using Details::Behavior;
534  using std::endl;
535  const char modeString[] = "doImport (forward mode)";
536 
537  // mfh 18 Oct 2017: Set TPETRA_VERBOSE to true for copious debug
538  // output to std::cerr on every MPI process. This is unwise for
539  // runs with large numbers of MPI processes.
540  const bool verbose = Behavior::verbose("DistObject");
541  std::unique_ptr<std::string> prefix;
542  if (verbose) {
543  prefix = this->createPrefix("DistObject", modeString);
544  std::ostringstream os;
545  os << *prefix << "Start" << endl;
546  std::cerr << os.str ();
547  }
548  this->endTransfer(source, importer, modeString, DoForward, CM, restrictedMode);
549  if (verbose) {
550  std::ostringstream os;
551  os << *prefix << "Done" << endl;
552  std::cerr << os.str ();
553  }
554  }
555 
556  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
557  void
558  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
559  endExport(const SrcDistObject& source,
560  const Export<LocalOrdinal, GlobalOrdinal, Node>& exporter,
561  const CombineMode CM,
562  const bool restrictedMode)
563  {
564  using Details::Behavior;
565  using std::endl;
566  const char modeString[] = "doExport (forward mode)";
567 
568  // mfh 18 Oct 2017: Set TPETRA_VERBOSE to true for copious debug
569  // output to std::cerr on every MPI process. This is unwise for
570  // runs with large numbers of MPI processes.
571  const bool verbose = Behavior::verbose("DistObject");
572  std::unique_ptr<std::string> prefix;
573  if (verbose) {
574  prefix = this->createPrefix("DistObject", modeString);
575  std::ostringstream os;
576  os << *prefix << "Start" << endl;
577  std::cerr << os.str ();
578  }
579  this->endTransfer(source, exporter, modeString, DoForward, CM, restrictedMode);
580  if (verbose) {
581  std::ostringstream os;
582  os << *prefix << "Done" << endl;
583  std::cerr << os.str ();
584  }
585  }
586 
587  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
588  void
589  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
590  endImport(const SrcDistObject& source,
591  const Export<LocalOrdinal, GlobalOrdinal, Node>& exporter,
592  const CombineMode CM,
593  const bool restrictedMode)
594  {
595  using Details::Behavior;
596  using std::endl;
597  const char modeString[] = "doImport (reverse mode)";
598 
599  // mfh 18 Oct 2017: Set TPETRA_VERBOSE to true for copious debug
600  // output to std::cerr on every MPI process. This is unwise for
601  // runs with large numbers of MPI processes.
602  const bool verbose = Behavior::verbose("DistObject");
603  std::unique_ptr<std::string> prefix;
604  if (verbose) {
605  prefix = this->createPrefix("DistObject", modeString);
606  std::ostringstream os;
607  os << *prefix << "Start" << endl;
608  std::cerr << os.str ();
609  }
610  this->endTransfer(source, exporter, modeString, DoReverse, CM, restrictedMode);
611  if (verbose) {
612  std::ostringstream os;
613  os << *prefix << "Done" << endl;
614  std::cerr << os.str ();
615  }
616  }
617 
618  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
619  void
620  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
621  endExport(const SrcDistObject& source,
622  const Import<LocalOrdinal, GlobalOrdinal, Node> & importer,
623  const CombineMode CM,
624  const bool restrictedMode)
625  {
626  using Details::Behavior;
627  using std::endl;
628  const char modeString[] = "doExport (reverse mode)";
629 
630  // mfh 18 Oct 2017: Set TPETRA_VERBOSE to true for copious debug
631  // output to std::cerr on every MPI process. This is unwise for
632  // runs with large numbers of MPI processes.
633  const bool verbose = Behavior::verbose("DistObject");
634  std::unique_ptr<std::string> prefix;
635  if (verbose) {
636  prefix = this->createPrefix("DistObject", modeString);
637  std::ostringstream os;
638  os << *prefix << "Start" << endl;
639  std::cerr << os.str ();
640  }
641  this->endTransfer(source, importer, modeString, DoReverse, CM, restrictedMode);
642  if (verbose) {
643  std::ostringstream os;
644  os << *prefix << "Done" << endl;
645  std::cerr << os.str ();
646  }
647  }
648 
649  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
650  bool
651  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
652  isDistributed () const {
653  return map_->isDistributed ();
654  }
655 
656  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
657  size_t
658  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
659  constantNumberOfPackets () const {
660  return 0; // default implementation; subclasses may override
661  }
662 
663  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
664  void
665  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
666  doTransfer (const SrcDistObject& src,
667  const ::Tpetra::Details::Transfer<local_ordinal_type, global_ordinal_type, node_type>& transfer,
668  const char modeString[],
669  const ReverseOption revOp,
670  const CombineMode CM,
671  bool restrictedMode)
672  {
673  beginTransfer(src, transfer, modeString, revOp, CM, restrictedMode);
674  endTransfer(src, transfer, modeString, revOp, CM, restrictedMode);
675  }
676 
677  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
678  bool
679  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
680  reallocImportsIfNeeded (const size_t newSize,
681  const bool verbose,
682  const std::string* prefix,
683  const bool /*remoteLIDsContiguous*/,
684  const CombineMode /*CM*/)
685  {
686  if (verbose) {
687  std::ostringstream os;
688  os << *prefix << "Realloc (if needed) imports_ from "
689  << imports_.extent (0) << " to " << newSize << std::endl;
690  std::cerr << os.str ();
691  }
692  using ::Tpetra::Details::reallocDualViewIfNeeded;
693  const bool reallocated =
694  reallocDualViewIfNeeded (this->imports_, newSize, "imports");
695  if (verbose) {
696  std::ostringstream os;
697  os << *prefix << "Finished realloc'ing imports_" << std::endl;
698  std::cerr << os.str ();
699  }
700  return reallocated;
701  }
702 
703  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
704  bool
705  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
706  reallocArraysForNumPacketsPerLid (const size_t numExportLIDs,
707  const size_t numImportLIDs)
708  {
709  using Details::Behavior;
710  using ::Tpetra::Details::dualViewStatusToString;
711  using ::Tpetra::Details::reallocDualViewIfNeeded;
712  using std::endl;
713  // If an array is already allocated, and if is at least
714  // tooBigFactor times bigger than it needs to be, free it and
715  // reallocate to the size we need, in order to save space.
716  // Otherwise, take subviews to reduce allocation size.
717  constexpr size_t tooBigFactor = 10;
718 
719  const bool verbose = Behavior::verbose("DistObject");
720  std::unique_ptr<std::string> prefix;
721  if (verbose) {
722  prefix = this->createPrefix("DistObject",
723  "reallocArraysForNumPacketsPerLid");
724  std::ostringstream os;
725  os << *prefix
726  << "numExportLIDs: " << numExportLIDs
727  << ", numImportLIDs: " << numImportLIDs
728  << endl;
729  os << *prefix << "DualView status before:" << endl
730  << *prefix
731  << dualViewStatusToString (this->numExportPacketsPerLID_,
732  "numExportPacketsPerLID_")
733  << endl
734  << *prefix
735  << dualViewStatusToString (this->numImportPacketsPerLID_,
736  "numImportPacketsPerLID_")
737  << endl;
738  std::cerr << os.str ();
739  }
740 
741  // Reallocate numExportPacketsPerLID_ if needed.
742  const bool firstReallocated =
743  reallocDualViewIfNeeded (this->numExportPacketsPerLID_,
744  numExportLIDs,
745  "numExportPacketsPerLID",
746  tooBigFactor,
747  true); // need fence before, if realloc'ing
748 
749  // If we reallocated above, then we fenced after that
750  // reallocation. This means that we don't need to fence again,
751  // before the next reallocation.
752  const bool needFenceBeforeNextAlloc = ! firstReallocated;
753  const bool secondReallocated =
754  reallocDualViewIfNeeded (this->numImportPacketsPerLID_,
755  numImportLIDs,
756  "numImportPacketsPerLID",
757  tooBigFactor,
758  needFenceBeforeNextAlloc);
759 
760  if (verbose) {
761  std::ostringstream os;
762  os << *prefix << "DualView status after:" << endl
763  << *prefix << dualViewStatusToString (this->numExportPacketsPerLID_,
764  "numExportPacketsPerLID_")
765  << endl
766  << *prefix << dualViewStatusToString (this->numImportPacketsPerLID_,
767  "numImportPacketsPerLID_")
768  << endl;
769  std::cerr << os.str ();
770  }
771 
772  return firstReallocated || secondReallocated;
773  }
774 
775  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
776  void
777  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
778  beginTransfer(const SrcDistObject& src,
779  const ::Tpetra::Details::Transfer<local_ordinal_type, global_ordinal_type, node_type>& transfer,
780  const char modeString[],
781  const ReverseOption revOp,
782  const CombineMode CM,
783  bool restrictedMode)
784  {
785  using Details::Behavior;
786  using ::Tpetra::Details::dualViewStatusToString;
787  using ::Tpetra::Details::getArrayViewFromDualView;
788  using Details::ProfilingRegion;
789  using Kokkos::Compat::getArrayView;
790  using Kokkos::Compat::getConstArrayView;
791  using Kokkos::Compat::getKokkosViewDeepCopy;
792  using Kokkos::Compat::create_const_view;
793  using std::endl;
794  using Details::getDualViewCopyFromArrayView;
795  using Details::ProfilingRegion;
796  const char funcName[] = "Tpetra::DistObject::doTransfer";
797 
798  ProfilingRegion region_doTransfer(funcName);
799  const bool verbose = Behavior::verbose("DistObject");
800  std::shared_ptr<std::string> prefix;
801  if (verbose) {
802  std::ostringstream os;
803  prefix = this->createPrefix("DistObject", "doTransfer");
804  os << *prefix << "Source type: " << Teuchos::typeName(src)
805  << ", Target type: " << Teuchos::typeName(*this) << endl;
806  std::cerr << os.str();
807  }
808 
809  // "Restricted Mode" does two things:
810  // 1) Skips copyAndPermute
811  // 2) Allows the "target" Map of the transfer to be a subset of
812  // the Map of *this, in a "locallyFitted" sense.
813  //
814  // This cannot be used if #2 is not true, OR there are permutes.
815  // Source Maps still need to match
816 
817  // mfh 18 Oct 2017: Set TPETRA_DEBUG to true to enable extra debug
818  // checks. These may communicate more.
819  const bool debug = Behavior::debug("DistObject");
820  if (debug) {
821  if (! restrictedMode && revOp == DoForward) {
822  const bool myMapSameAsTransferTgtMap =
823  this->getMap ()->isSameAs (* (transfer.getTargetMap ()));
824  TEUCHOS_TEST_FOR_EXCEPTION
825  (! myMapSameAsTransferTgtMap, std::invalid_argument,
826  "Tpetra::DistObject::" << modeString << ": For forward-mode "
827  "communication, the target DistObject's Map must be the same "
828  "(in the sense of Tpetra::Map::isSameAs) as the input "
829  "Export/Import object's target Map.");
830  }
831  else if (! restrictedMode && revOp == DoReverse) {
832  const bool myMapSameAsTransferSrcMap =
833  this->getMap ()->isSameAs (* (transfer.getSourceMap ()));
834  TEUCHOS_TEST_FOR_EXCEPTION
835  (! myMapSameAsTransferSrcMap, std::invalid_argument,
836  "Tpetra::DistObject::" << modeString << ": For reverse-mode "
837  "communication, the target DistObject's Map must be the same "
838  "(in the sense of Tpetra::Map::isSameAs) as the input "
839  "Export/Import object's source Map.");
840  }
841  else if (restrictedMode && revOp == DoForward) {
842  const bool myMapLocallyFittedTransferTgtMap =
843  this->getMap ()->isLocallyFitted (* (transfer.getTargetMap ()));
844  TEUCHOS_TEST_FOR_EXCEPTION
845  (! myMapLocallyFittedTransferTgtMap , std::invalid_argument,
846  "Tpetra::DistObject::" << modeString << ": For forward-mode "
847  "communication using restricted mode, Export/Import object's "
848  "target Map must be locally fitted (in the sense of "
849  "Tpetra::Map::isLocallyFitted) to target DistObject's Map.");
850  }
851  else { // if (restrictedMode && revOp == DoReverse)
852  const bool myMapLocallyFittedTransferSrcMap =
853  this->getMap ()->isLocallyFitted (* (transfer.getSourceMap ()));
854  TEUCHOS_TEST_FOR_EXCEPTION
855  (! myMapLocallyFittedTransferSrcMap, std::invalid_argument,
856  "Tpetra::DistObject::" << modeString << ": For reverse-mode "
857  "communication using restricted mode, Export/Import object's "
858  "source Map must be locally fitted (in the sense of "
859  "Tpetra::Map::isLocallyFitted) to target DistObject's Map.");
860  }
861 
862  // SrcDistObject need not even _have_ Maps. However, if the
863  // source object is a DistObject, it has a Map, and we may
864  // compare that Map with the Transfer's Maps.
865  const this_type* srcDistObj = dynamic_cast<const this_type*> (&src);
866  if (srcDistObj != nullptr) {
867  if (revOp == DoForward) {
868  const bool srcMapSameAsImportSrcMap =
869  srcDistObj->getMap ()->isSameAs (* (transfer.getSourceMap ()));
870  TEUCHOS_TEST_FOR_EXCEPTION
871  (! srcMapSameAsImportSrcMap, std::invalid_argument,
872  "Tpetra::DistObject::" << modeString << ": For forward-mode "
873  "communication, the source DistObject's Map must be the same "
874  "as the input Export/Import object's source Map.");
875  }
876  else { // revOp == DoReverse
877  const bool srcMapSameAsImportTgtMap =
878  srcDistObj->getMap ()->isSameAs (* (transfer.getTargetMap ()));
879  TEUCHOS_TEST_FOR_EXCEPTION
880  (! srcMapSameAsImportTgtMap, std::invalid_argument,
881  "Tpetra::DistObject::" << modeString << ": For reverse-mode "
882  "communication, the source DistObject's Map must be the same "
883  "as the input Export/Import object's target Map.");
884  }
885  }
886  }
887 
888  const size_t numSameIDs = transfer.getNumSameIDs ();
889  Distributor& distor = transfer.getDistributor ();
890  const Details::DistributorPlan& distributorPlan = (revOp == DoForward) ? distor.getPlan() : *distor.getPlan().getReversePlan();
891 
892  TEUCHOS_TEST_FOR_EXCEPTION
893  (debug && restrictedMode &&
894  (transfer.getPermuteToLIDs_dv().extent(0) != 0 ||
895  transfer.getPermuteFromLIDs_dv().extent(0) != 0),
896  std::invalid_argument,
897  "Tpetra::DistObject::" << modeString << ": Transfer object "
898  "cannot have permutes in restricted mode.");
899 
900  // Do we need all communication buffers to live on host?
901  const bool commOnHost = ! Behavior::assumeMpiIsCudaAware ();
902  if (verbose) {
903  std::ostringstream os;
904  os << *prefix << "doTransfer: Use new interface; "
905  "commOnHost=" << (commOnHost ? "true" : "false") << endl;
906  std::cerr << os.str ();
907  }
908 
909  using const_lo_dv_type =
910  Kokkos::DualView<const local_ordinal_type*, buffer_device_type>;
911  const_lo_dv_type permuteToLIDs = (revOp == DoForward) ?
912  transfer.getPermuteToLIDs_dv () :
913  transfer.getPermuteFromLIDs_dv ();
914  const_lo_dv_type permuteFromLIDs = (revOp == DoForward) ?
915  transfer.getPermuteFromLIDs_dv () :
916  transfer.getPermuteToLIDs_dv ();
917  const_lo_dv_type remoteLIDs = (revOp == DoForward) ?
918  transfer.getRemoteLIDs_dv () :
919  transfer.getExportLIDs_dv ();
920  const_lo_dv_type exportLIDs = (revOp == DoForward) ?
921  transfer.getExportLIDs_dv () :
922  transfer.getRemoteLIDs_dv ();
923  const bool canTryAliasing = (revOp == DoForward) ?
924  transfer.areRemoteLIDsContiguous() :
925  transfer.areExportLIDsContiguous();
926  // const bool canTryAliasing = false;
927 
928  ProfilingRegion region_dTN(funcName);
929 #ifdef HAVE_TPETRA_TRANSFER_TIMERS
930  // FIXME (mfh 04 Feb 2019) Deprecate Teuchos::TimeMonitor in favor
931  // of Kokkos profiling.
932  Teuchos::TimeMonitor doXferMon (*doXferTimer_);
933 #endif // HAVE_TPETRA_TRANSFER_TIMERS
934 
935  if (verbose) {
936  std::ostringstream os;
937  os << *prefix << "Input arguments:" << endl
938  << *prefix << " combineMode: " << combineModeToString (CM) << endl
939  << *prefix << " numSameIDs: " << numSameIDs << endl
940  << *prefix << " "
941  << dualViewStatusToString (permuteToLIDs, "permuteToLIDs") << endl
942  << *prefix << " "
943  << dualViewStatusToString (permuteFromLIDs, "permuteFromLIDs") << endl
944  << *prefix << " "
945  << dualViewStatusToString (remoteLIDs, "remoteLIDs") << endl
946  << *prefix << " "
947  << dualViewStatusToString (exportLIDs, "exportLIDs") << endl
948  << *prefix << " revOp: Do" << (revOp == DoReverse ? "Reverse" : "Forward") << endl
949  << *prefix << " commOnHost: " << (commOnHost ? "true" : "false") << endl;
950  std::cerr << os.str ();
951  }
952 
953  {
954  ProfilingRegion region_cs ("Tpetra::DistObject::doTransferNew::checkSizes");
955  if (verbose) {
956  std::ostringstream os;
957  os << *prefix << "1. checkSizes" << endl;
958  std::cerr << os.str ();
959  }
960  const bool checkSizesResult = this->checkSizes (src);
961  TEUCHOS_TEST_FOR_EXCEPTION
962  (! checkSizesResult, std::invalid_argument,
963  "Tpetra::DistObject::doTransfer: checkSizes() indicates that the "
964  "destination object is not a legal target for redistribution from the "
965  "source object. This probably means that they do not have the same "
966  "dimensions. For example, MultiVectors must have the same number of "
967  "rows and columns.");
968  }
969 
970  // NOTE (mfh 26 Apr 2016) Chris Baker's implementation understood
971  // that if CM == INSERT || CM == REPLACE, the target object could
972  // be write only. We don't optimize for that here.
973 
974  if (!restrictedMode && numSameIDs + permuteToLIDs.extent (0) != 0) {
975  // There is at least one GID to copy or permute.
976  if (verbose) {
977  std::ostringstream os;
978  os << *prefix << "2. copyAndPermute" << endl;
979  std::cerr << os.str ();
980  }
981  ProfilingRegion region_cp
982  ("Tpetra::DistObject::doTransferNew::copyAndPermute");
983 #ifdef HAVE_TPETRA_TRANSFER_TIMERS
984  // FIXME (mfh 04 Feb 2019) Deprecate Teuchos::TimeMonitor in favor
985  // of Kokkos profiling.
986  Teuchos::TimeMonitor copyAndPermuteMon (*copyAndPermuteTimer_);
987 #endif // HAVE_TPETRA_TRANSFER_TIMERS
988 
989  if (numSameIDs + permuteToLIDs.extent (0) != 0) {
990  // There is at least one GID to copy or permute.
991  if (verbose) {
992  std::ostringstream os;
993  os << *prefix << "2. copyAndPermute" << endl;
994  std::cerr << os.str ();
995  }
996  this->copyAndPermute (src, numSameIDs, permuteToLIDs,
997  permuteFromLIDs, CM);
998  if (verbose) {
999  std::ostringstream os;
1000  os << *prefix << "After copyAndPermute:" << endl
1001  << *prefix << " "
1002  << dualViewStatusToString (permuteToLIDs, "permuteToLIDs")
1003  << endl
1004  << *prefix << " "
1005  << dualViewStatusToString (permuteFromLIDs, "permuteFromLIDs")
1006  << endl;
1007  std::cerr << os.str ();
1008  }
1009  }
1010  }
1011 
1012  // The method may return zero even if the implementation actually
1013  // does have a constant number of packets per LID. However, if it
1014  // returns nonzero, we may use this information to avoid
1015  // (re)allocating num{Ex,Im}portPacketsPerLID_. packAndPrepare()
1016  // will set this to its final value.
1017  //
1018  // We only need this if CM != ZERO, but it has to be lifted out of
1019  // that scope because there are multiple tests for CM != ZERO.
1020  size_t constantNumPackets = this->constantNumberOfPackets ();
1021  if (verbose) {
1022  std::ostringstream os;
1023  os << *prefix << "constantNumPackets=" << constantNumPackets << endl;
1024  std::cerr << os.str ();
1025  }
1026 
1027  // We only need to pack communication buffers if the combine mode
1028  // is not ZERO. A "ZERO combine mode" means that the results are
1029  // the same as if we had received all zeros, and added them to the
1030  // existing values. That means we don't need to communicate.
1031  if (CM != ZERO) {
1032  if (constantNumPackets == 0) {
1033  if (verbose) {
1034  std::ostringstream os;
1035  os << *prefix << "3. (Re)allocate num{Ex,Im}portPacketsPerLID"
1036  << endl;
1037  std::cerr << os.str ();
1038  }
1039  // This only reallocates if necessary, that is, if the sizes
1040  // don't match.
1041  this->reallocArraysForNumPacketsPerLid (exportLIDs.extent (0),
1042  remoteLIDs.extent (0));
1043  }
1044 
1045  if (verbose) {
1046  std::ostringstream os;
1047  os << *prefix << "4. packAndPrepare: before, "
1048  << dualViewStatusToString (this->exports_, "exports_")
1049  << endl;
1050  std::cerr << os.str ();
1051  }
1052 
1053  doPackAndPrepare(src, exportLIDs, constantNumPackets);
1054  if (commOnHost) {
1055  this->exports_.sync_host();
1056  }
1057  else {
1058  this->exports_.sync_device();
1059  }
1060 
1061  if (verbose) {
1062  std::ostringstream os;
1063  os << *prefix << "5.1. After packAndPrepare, "
1064  << dualViewStatusToString (this->exports_, "exports_")
1065  << endl;
1066  std::cerr << os.str ();
1067  }
1068  } // if (CM != ZERO)
1069 
1070  // We only need to send data if the combine mode is not ZERO.
1071  if (CM != ZERO) {
1072  if (constantNumPackets != 0) {
1073  // There are a constant number of packets per element. We
1074  // already know (from the number of "remote" (incoming)
1075  // elements) how many incoming elements we expect, so we can
1076  // resize the buffer accordingly.
1077  const size_t rbufLen = remoteLIDs.extent (0) * constantNumPackets;
1078  reallocImportsIfNeeded (rbufLen, verbose, prefix.get (), canTryAliasing, CM);
1079  }
1080 
1081  // Do we need to do communication (via doPostsAndWaits)?
1082  bool needCommunication = true;
1083 
1084  // This may be NULL. It will be used below.
1085  const this_type* srcDistObj = dynamic_cast<const this_type*> (&src);
1086 
1087  if (revOp == DoReverse && ! this->isDistributed ()) {
1088  needCommunication = false;
1089  }
1090  // FIXME (mfh 30 Jun 2013): Checking whether the source object
1091  // is distributed requires a cast to DistObject. If it's not a
1092  // DistObject, then I'm not quite sure what to do. Perhaps it
1093  // would be more appropriate for SrcDistObject to have an
1094  // isDistributed() method. For now, I'll just assume that we
1095  // need to do communication unless the cast succeeds and the
1096  // source is not distributed.
1097  else if (revOp == DoForward && srcDistObj != NULL &&
1098  ! srcDistObj->isDistributed ()) {
1099  needCommunication = false;
1100  }
1101 
1102  if (! needCommunication) {
1103  if (verbose) {
1104  std::ostringstream os;
1105  os << *prefix << "Comm not needed; skipping" << endl;
1106  std::cerr << os.str ();
1107  }
1108  }
1109  else {
1110  ProfilingRegion region_dpw
1111  ("Tpetra::DistObject::doTransferNew::doPostsAndWaits");
1112 #ifdef HAVE_TPETRA_TRANSFER_TIMERS
1113  // FIXME (mfh 04 Feb 2019) Deprecate Teuchos::TimeMonitor in
1114  // favor of Kokkos profiling.
1115  Teuchos::TimeMonitor doPostsAndWaitsMon (*doPostsAndWaitsTimer_);
1116 #endif // HAVE_TPETRA_TRANSFER_TIMERS
1117 
1118  if (verbose) {
1119  std::ostringstream os;
1120  os << *prefix << "7.0. "
1121  << (revOp == DoReverse ? "Reverse" : "Forward")
1122  << " mode" << endl;
1123  std::cerr << os.str ();
1124  }
1125 
1126  doPosts(distributorPlan, constantNumPackets, commOnHost, prefix, canTryAliasing, CM);
1127  } // if (needCommunication)
1128  } // if (CM != ZERO)
1129  }
1130 
1131  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
1132  void
1133  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
1134  endTransfer(const SrcDistObject& src,
1135  const ::Tpetra::Details::Transfer<local_ordinal_type, global_ordinal_type, node_type>& transfer,
1136  const char modeString[],
1137  const ReverseOption revOp,
1138  const CombineMode CM,
1139  bool restrictedMode)
1140  {
1141  using Details::Behavior;
1142  using ::Tpetra::Details::dualViewStatusToString;
1143  using ::Tpetra::Details::getArrayViewFromDualView;
1144  using Details::ProfilingRegion;
1145  using Kokkos::Compat::getArrayView;
1146  using Kokkos::Compat::getConstArrayView;
1147  using Kokkos::Compat::getKokkosViewDeepCopy;
1148  using Kokkos::Compat::create_const_view;
1149  using std::endl;
1150  using Details::getDualViewCopyFromArrayView;
1151  using Details::ProfilingRegion;
1152  const char funcName[] = "Tpetra::DistObject::doTransfer";
1153 
1154  ProfilingRegion region_doTransfer(funcName);
1155  const bool verbose = Behavior::verbose("DistObject");
1156  std::shared_ptr<std::string> prefix;
1157  if (verbose) {
1158  std::ostringstream os;
1159  prefix = this->createPrefix("DistObject", "doTransfer");
1160  os << *prefix << "Source type: " << Teuchos::typeName(src)
1161  << ", Target type: " << Teuchos::typeName(*this) << endl;
1162  std::cerr << os.str();
1163  }
1164 
1165  // "Restricted Mode" does two things:
1166  // 1) Skips copyAndPermute
1167  // 2) Allows the "target" Map of the transfer to be a subset of
1168  // the Map of *this, in a "locallyFitted" sense.
1169  //
1170  // This cannot be used if #2 is not true, OR there are permutes.
1171  // Source Maps still need to match
1172 
1173  // mfh 18 Oct 2017: Set TPETRA_DEBUG to true to enable extra debug
1174  // checks. These may communicate more.
1175  const bool debug = Behavior::debug("DistObject");
1176  if (debug) {
1177  if (! restrictedMode && revOp == DoForward) {
1178  const bool myMapSameAsTransferTgtMap =
1179  this->getMap ()->isSameAs (* (transfer.getTargetMap ()));
1180  TEUCHOS_TEST_FOR_EXCEPTION
1181  (! myMapSameAsTransferTgtMap, std::invalid_argument,
1182  "Tpetra::DistObject::" << modeString << ": For forward-mode "
1183  "communication, the target DistObject's Map must be the same "
1184  "(in the sense of Tpetra::Map::isSameAs) as the input "
1185  "Export/Import object's target Map.");
1186  }
1187  else if (! restrictedMode && revOp == DoReverse) {
1188  const bool myMapSameAsTransferSrcMap =
1189  this->getMap ()->isSameAs (* (transfer.getSourceMap ()));
1190  TEUCHOS_TEST_FOR_EXCEPTION
1191  (! myMapSameAsTransferSrcMap, std::invalid_argument,
1192  "Tpetra::DistObject::" << modeString << ": For reverse-mode "
1193  "communication, the target DistObject's Map must be the same "
1194  "(in the sense of Tpetra::Map::isSameAs) as the input "
1195  "Export/Import object's source Map.");
1196  }
1197  else if (restrictedMode && revOp == DoForward) {
1198  const bool myMapLocallyFittedTransferTgtMap =
1199  this->getMap ()->isLocallyFitted (* (transfer.getTargetMap ()));
1200  TEUCHOS_TEST_FOR_EXCEPTION
1201  (! myMapLocallyFittedTransferTgtMap , std::invalid_argument,
1202  "Tpetra::DistObject::" << modeString << ": For forward-mode "
1203  "communication using restricted mode, Export/Import object's "
1204  "target Map must be locally fitted (in the sense of "
1205  "Tpetra::Map::isLocallyFitted) to target DistObject's Map.");
1206  }
1207  else { // if (restrictedMode && revOp == DoReverse)
1208  const bool myMapLocallyFittedTransferSrcMap =
1209  this->getMap ()->isLocallyFitted (* (transfer.getSourceMap ()));
1210  TEUCHOS_TEST_FOR_EXCEPTION
1211  (! myMapLocallyFittedTransferSrcMap, std::invalid_argument,
1212  "Tpetra::DistObject::" << modeString << ": For reverse-mode "
1213  "communication using restricted mode, Export/Import object's "
1214  "source Map must be locally fitted (in the sense of "
1215  "Tpetra::Map::isLocallyFitted) to target DistObject's Map.");
1216  }
1217 
1218  // SrcDistObject need not even _have_ Maps. However, if the
1219  // source object is a DistObject, it has a Map, and we may
1220  // compare that Map with the Transfer's Maps.
1221  const this_type* srcDistObj = dynamic_cast<const this_type*> (&src);
1222  if (srcDistObj != nullptr) {
1223  if (revOp == DoForward) {
1224  const bool srcMapSameAsImportSrcMap =
1225  srcDistObj->getMap ()->isSameAs (* (transfer.getSourceMap ()));
1226  TEUCHOS_TEST_FOR_EXCEPTION
1227  (! srcMapSameAsImportSrcMap, std::invalid_argument,
1228  "Tpetra::DistObject::" << modeString << ": For forward-mode "
1229  "communication, the source DistObject's Map must be the same "
1230  "as the input Export/Import object's source Map.");
1231  }
1232  else { // revOp == DoReverse
1233  const bool srcMapSameAsImportTgtMap =
1234  srcDistObj->getMap ()->isSameAs (* (transfer.getTargetMap ()));
1235  TEUCHOS_TEST_FOR_EXCEPTION
1236  (! srcMapSameAsImportTgtMap, std::invalid_argument,
1237  "Tpetra::DistObject::" << modeString << ": For reverse-mode "
1238  "communication, the source DistObject's Map must be the same "
1239  "as the input Export/Import object's target Map.");
1240  }
1241  }
1242  }
1243 
1244  Distributor& distor = transfer.getDistributor ();
1245  const Details::DistributorPlan& distributorPlan = (revOp == DoForward) ? distor.getPlan() : *distor.getPlan().getReversePlan();
1246 
1247  TEUCHOS_TEST_FOR_EXCEPTION
1248  (debug && restrictedMode &&
1249  (transfer.getPermuteToLIDs_dv().extent(0) != 0 ||
1250  transfer.getPermuteFromLIDs_dv().extent(0) != 0),
1251  std::invalid_argument,
1252  "Tpetra::DistObject::" << modeString << ": Transfer object "
1253  "cannot have permutes in restricted mode.");
1254 
1255  // Do we need all communication buffers to live on host?
1256  const bool commOnHost = ! Behavior::assumeMpiIsCudaAware ();
1257  if (verbose) {
1258  std::ostringstream os;
1259  os << *prefix << "doTransfer: Use new interface; "
1260  "commOnHost=" << (commOnHost ? "true" : "false") << endl;
1261  std::cerr << os.str ();
1262  }
1263 
1264  using const_lo_dv_type =
1265  Kokkos::DualView<const local_ordinal_type*, buffer_device_type>;
1266  const_lo_dv_type permuteToLIDs = (revOp == DoForward) ?
1267  transfer.getPermuteToLIDs_dv () :
1268  transfer.getPermuteFromLIDs_dv ();
1269  const_lo_dv_type permuteFromLIDs = (revOp == DoForward) ?
1270  transfer.getPermuteFromLIDs_dv () :
1271  transfer.getPermuteToLIDs_dv ();
1272  const_lo_dv_type remoteLIDs = (revOp == DoForward) ?
1273  transfer.getRemoteLIDs_dv () :
1274  transfer.getExportLIDs_dv ();
1275  const_lo_dv_type exportLIDs = (revOp == DoForward) ?
1276  transfer.getExportLIDs_dv () :
1277  transfer.getRemoteLIDs_dv ();
1278  const bool canTryAliasing = (revOp == DoForward) ?
1279  transfer.areRemoteLIDsContiguous() :
1280  transfer.areExportLIDsContiguous();
1281 
1282  size_t constantNumPackets = this->constantNumberOfPackets ();
1283 
1284  // We only need to send data if the combine mode is not ZERO.
1285  if (CM != ZERO) {
1286  if (constantNumPackets != 0) {
1287  // There are a constant number of packets per element. We
1288  // already know (from the number of "remote" (incoming)
1289  // elements) how many incoming elements we expect, so we can
1290  // resize the buffer accordingly.
1291  const size_t rbufLen = remoteLIDs.extent (0) * constantNumPackets;
1292  reallocImportsIfNeeded (rbufLen, verbose, prefix.get (), canTryAliasing, CM);
1293  }
1294 
1295  // Do we need to do communication (via doPostsAndWaits)?
1296  bool needCommunication = true;
1297 
1298  // This may be NULL. It will be used below.
1299  const this_type* srcDistObj = dynamic_cast<const this_type*> (&src);
1300 
1301  if (revOp == DoReverse && ! this->isDistributed ()) {
1302  needCommunication = false;
1303  }
1304  // FIXME (mfh 30 Jun 2013): Checking whether the source object
1305  // is distributed requires a cast to DistObject. If it's not a
1306  // DistObject, then I'm not quite sure what to do. Perhaps it
1307  // would be more appropriate for SrcDistObject to have an
1308  // isDistributed() method. For now, I'll just assume that we
1309  // need to do communication unless the cast succeeds and the
1310  // source is not distributed.
1311  else if (revOp == DoForward && srcDistObj != NULL &&
1312  ! srcDistObj->isDistributed ()) {
1313  needCommunication = false;
1314  }
1315 
1316  if (! needCommunication) {
1317  if (verbose) {
1318  std::ostringstream os;
1319  os << *prefix << "Comm not needed; skipping" << endl;
1320  std::cerr << os.str ();
1321  }
1322  }
1323  else {
1324  distributorActor_.doWaits(distributorPlan);
1325 
1326  if (verbose) {
1327  std::ostringstream os;
1328  os << *prefix << "8. unpackAndCombine" << endl;
1329  std::cerr << os.str ();
1330  }
1331  doUnpackAndCombine(remoteLIDs, constantNumPackets, CM);
1332  } // if (needCommunication)
1333  } // if (CM != ZERO)
1334 
1335  if (verbose) {
1336  std::ostringstream os;
1337  os << *prefix << "9. Done!" << endl;
1338  std::cerr << os.str ();
1339  }
1340 
1341  if (verbose) {
1342  std::ostringstream os;
1343  os << *prefix << "Tpetra::DistObject::doTransfer: Done!" << endl;
1344  std::cerr << os.str ();
1345  }
1346  }
1347 
1348  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
1349  void
1350  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
1351  doPosts(const Details::DistributorPlan& distributorPlan,
1352  size_t constantNumPackets,
1353  bool commOnHost,
1354  std::shared_ptr<std::string> prefix,
1355  const bool canTryAliasing,
1356  const CombineMode CM)
1357  {
1358  using ::Tpetra::Details::dualViewStatusToString;
1359  using ::Tpetra::Details::getArrayViewFromDualView;
1360  using Kokkos::Compat::create_const_view;
1361  using std::endl;
1362 
1363  const bool verbose = Details::Behavior::verbose("DistObject");
1364 
1365  if (constantNumPackets == 0) { // variable num packets per LID
1366  if (verbose) {
1367  std::ostringstream os;
1368  os << *prefix << "7.1. Variable # packets / LID: first comm "
1369  << "(commOnHost = " << (commOnHost ? "true" : "false") << ")"
1370  << endl;
1371  std::cerr << os.str ();
1372  }
1373  size_t totalImportPackets = 0;
1374  if (commOnHost) {
1375  if (this->numExportPacketsPerLID_.need_sync_host ()) {
1376  this->numExportPacketsPerLID_.sync_host ();
1377  }
1378  if (this->numImportPacketsPerLID_.need_sync_host ()) {
1379  this->numImportPacketsPerLID_.sync_host ();
1380  }
1381  this->numImportPacketsPerLID_.modify_host (); // out arg
1382  auto numExp_h =
1383  create_const_view (this->numExportPacketsPerLID_.view_host ());
1384  auto numImp_h = this->numImportPacketsPerLID_.view_host ();
1385 
1386  // MPI communication happens here.
1387  if (verbose) {
1388  std::ostringstream os;
1389  os << *prefix << "Call doPostsAndWaits"
1390  << endl;
1391  std::cerr << os.str ();
1392  }
1393  distributorActor_.doPostsAndWaits(distributorPlan, numExp_h, 1, numImp_h);
1394 
1395  if (verbose) {
1396  std::ostringstream os;
1397  os << *prefix << "Count totalImportPackets" << std::endl;
1398  std::cerr << os.str ();
1399  }
1400  using the_dev_type = typename decltype (numImp_h)::device_type;
1401  totalImportPackets = countTotalImportPackets<the_dev_type> (numImp_h);
1402  }
1403  else { // ! commOnHost
1404  this->numExportPacketsPerLID_.sync_device ();
1405  this->numImportPacketsPerLID_.sync_device ();
1406  this->numImportPacketsPerLID_.modify_device (); // out arg
1407  auto numExp_d = create_const_view
1408  (this->numExportPacketsPerLID_.view_device ());
1409  auto numImp_d = this->numImportPacketsPerLID_.view_device ();
1410 
1411  // MPI communication happens here.
1412  if (verbose) {
1413  std::ostringstream os;
1414  os << *prefix << "Call doPostsAndWaits"
1415  << endl;
1416  std::cerr << os.str ();
1417  }
1418  distributorActor_.doPostsAndWaits(distributorPlan, numExp_d, 1, numImp_d);
1419 
1420  if (verbose) {
1421  std::ostringstream os;
1422  os << *prefix << "Count totalImportPackets" << std::endl;
1423  std::cerr << os.str ();
1424  }
1425  using the_dev_type = typename decltype (numImp_d)::device_type;
1426  totalImportPackets = countTotalImportPackets<the_dev_type> (numImp_d);
1427  }
1428 
1429  if (verbose) {
1430  std::ostringstream os;
1431  os << *prefix << "totalImportPackets=" << totalImportPackets << endl;
1432  std::cerr << os.str ();
1433  }
1434  this->reallocImportsIfNeeded (totalImportPackets, verbose,
1435  prefix.get (), canTryAliasing, CM);
1436  if (verbose) {
1437  std::ostringstream os;
1438  os << *prefix << "7.3. Second comm" << std::endl;
1439  std::cerr << os.str ();
1440  }
1441 
1442  // mfh 04 Feb 2019: Distributor expects the "num packets per
1443  // LID" arrays on host, so that it can issue MPI sends and
1444  // receives correctly.
1445  this->numExportPacketsPerLID_.sync_host ();
1446  this->numImportPacketsPerLID_.sync_host ();
1447 
1448  // NOTE (mfh 25 Apr 2016, 01 Aug 2017) doPostsAndWaits and
1449  // doReversePostsAndWaits currently want
1450  // numExportPacketsPerLID and numImportPacketsPerLID as
1451  // Teuchos::ArrayView, rather than as Kokkos::View.
1452  //
1453  // NOTE (mfh 04 Feb 2019) This does NOT copy from host to
1454  // device. The above syncs might.
1455  auto numExportPacketsPerLID_av =
1456  getArrayViewFromDualView (this->numExportPacketsPerLID_);
1457  auto numImportPacketsPerLID_av =
1458  getArrayViewFromDualView (this->numImportPacketsPerLID_);
1459 
1460  // imports_ is for output only, so we don't need to sync it
1461  // before marking it as modified. However, in order to
1462  // prevent spurious debug-mode errors (e.g., "modified on
1463  // both device and host"), we first need to clear its
1464  // "modified" flags.
1465  this->imports_.clear_sync_state ();
1466 
1467  if (verbose) {
1468  std::ostringstream os;
1469  os << *prefix << "Comm on "
1470  << (commOnHost ? "host" : "device")
1471  << "; call doPosts" << endl;
1472  std::cerr << os.str ();
1473  }
1474 
1475  if (commOnHost) {
1476  this->imports_.modify_host ();
1477  distributorActor_.doPosts
1478  (distributorPlan,
1479  create_const_view (this->exports_.view_host ()),
1480  numExportPacketsPerLID_av,
1481  this->imports_.view_host (),
1482  numImportPacketsPerLID_av);
1483  }
1484  else { // pack on device
1485  Kokkos::fence(); // for UVM
1486  this->imports_.modify_device ();
1487  distributorActor_.doPosts
1488  (distributorPlan,
1489  create_const_view (this->exports_.view_device ()),
1490  numExportPacketsPerLID_av,
1491  this->imports_.view_device (),
1492  numImportPacketsPerLID_av);
1493  }
1494  }
1495  else { // constant number of packets per LID
1496  if (verbose) {
1497  std::ostringstream os;
1498  os << *prefix << "7.1. Const # packets per LID: " << endl
1499  << *prefix << " "
1500  << dualViewStatusToString (this->exports_, "exports_")
1501  << endl
1502  << *prefix << " "
1503  << dualViewStatusToString (this->exports_, "imports_")
1504  << endl;
1505  std::cerr << os.str ();
1506  }
1507  // imports_ is for output only, so we don't need to sync it
1508  // before marking it as modified. However, in order to
1509  // prevent spurious debug-mode errors (e.g., "modified on
1510  // both device and host"), we first need to clear its
1511  // "modified" flags.
1512  this->imports_.clear_sync_state ();
1513 
1514  if (verbose) {
1515  std::ostringstream os;
1516  os << *prefix << "7.2. Comm on "
1517  << (commOnHost ? "host" : "device")
1518  << "; call doPosts" << endl;
1519  std::cerr << os.str ();
1520  }
1521  if (commOnHost) {
1522  this->imports_.modify_host ();
1523  distributorActor_.doPosts
1524  (distributorPlan,
1525  create_const_view (this->exports_.view_host ()),
1526  constantNumPackets,
1527  this->imports_.view_host ());
1528  }
1529  else { // pack on device
1530  Kokkos::fence(); // for UVM
1531  this->imports_.modify_device ();
1532  distributorActor_.doPosts
1533  (distributorPlan,
1534  create_const_view (this->exports_.view_device ()),
1535  constantNumPackets,
1536  this->imports_.view_device ());
1537  } // commOnHost
1538  } // constant or variable num packets per LID
1539  }
1540 
1541  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
1542  void
1543  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
1544  doPackAndPrepare(const SrcDistObject& src,
1545  const Kokkos::DualView<const local_ordinal_type*, buffer_device_type>& exportLIDs,
1546  size_t& constantNumPackets)
1547  {
1548  using Details::ProfilingRegion;
1549  using std::endl;
1550  const bool debug = Details::Behavior::debug("DistObject");
1551 
1552  ProfilingRegion region_pp
1553  ("Tpetra::DistObject::doTransferNew::packAndPrepare");
1554 #ifdef HAVE_TPETRA_TRANSFER_TIMERS
1555  // FIXME (mfh 04 Feb 2019) Deprecate Teuchos::TimeMonitor in
1556  // favor of Kokkos profiling.
1557  Teuchos::TimeMonitor packAndPrepareMon (*packAndPrepareTimer_);
1558 #endif // HAVE_TPETRA_TRANSFER_TIMERS
1559 
1560  // Ask the source to pack data. Also ask it whether there are
1561  // a constant number of packets per element
1562  // (constantNumPackets is an output argument). If there are,
1563  // constantNumPackets will come back nonzero. Otherwise, the
1564  // source will fill the numExportPacketsPerLID_ array.
1565 
1566  // FIXME (mfh 18 Oct 2017) if (! commOnHost), sync to device?
1567  // Alternately, make packAndPrepare take a "commOnHost"
1568  // argument to tell it where to leave the data?
1569  //
1570  // NOTE (mfh 04 Feb 2019) Subclasses of DistObject should have
1571  // the freedom to pack and unpack either on host or device.
1572  // We should prefer sync'ing only on demand. Thus, we can
1573  // answer the above question: packAndPrepare should not
1574  // take a commOnHost argument, and doTransferNew should sync
1575  // where needed, if needed.
1576  if (debug) {
1577  std::ostringstream lclErrStrm;
1578  bool lclSuccess = false;
1579  try {
1580  this->packAndPrepare (src, exportLIDs, this->exports_,
1581  this->numExportPacketsPerLID_,
1582  constantNumPackets);
1583  lclSuccess = true;
1584  }
1585  catch (std::exception& e) {
1586  lclErrStrm << "packAndPrepare threw an exception: "
1587  << endl << e.what();
1588  }
1589  catch (...) {
1590  lclErrStrm << "packAndPrepare threw an exception "
1591  "not a subclass of std::exception.";
1592  }
1593  const char gblErrMsgHeader[] = "Tpetra::DistObject "
1594  "threw an exception in packAndPrepare on "
1595  "one or more processes in the DistObject's communicator.";
1596  auto comm = getMap()->getComm();
1597  Details::checkGlobalError(std::cerr, lclSuccess,
1598  lclErrStrm.str().c_str(),
1599  gblErrMsgHeader, *comm);
1600  }
1601  else {
1602  this->packAndPrepare (src, exportLIDs, this->exports_,
1603  this->numExportPacketsPerLID_,
1604  constantNumPackets);
1605  }
1606  }
1607 
1608  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
1609  void
1610  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
1611  doUnpackAndCombine(const Kokkos::DualView<const local_ordinal_type*, buffer_device_type>& remoteLIDs,
1612  size_t constantNumPackets,
1613  CombineMode CM)
1614  {
1615  using Details::ProfilingRegion;
1616  using std::endl;
1617  const bool debug = Details::Behavior::debug("DistObject");
1618 
1619  ProfilingRegion region_uc
1620  ("Tpetra::DistObject::doTransferNew::unpackAndCombine");
1621 #ifdef HAVE_TPETRA_TRANSFER_TIMERS
1622  // FIXME (mfh 04 Feb 2019) Deprecate Teuchos::TimeMonitor in
1623  // favor of Kokkos profiling.
1624  Teuchos::TimeMonitor unpackAndCombineMon (*unpackAndCombineTimer_);
1625 #endif // HAVE_TPETRA_TRANSFER_TIMERS
1626 
1627  if (debug) {
1628  std::ostringstream lclErrStrm;
1629  bool lclSuccess = false;
1630  try {
1631  this->unpackAndCombine (remoteLIDs, this->imports_,
1632  this->numImportPacketsPerLID_,
1633  constantNumPackets, CM);
1634  lclSuccess = true;
1635  }
1636  catch (std::exception& e) {
1637  lclErrStrm << "unpackAndCombine threw an exception: "
1638  << endl << e.what();
1639  }
1640  catch (...) {
1641  lclErrStrm << "unpackAndCombine threw an exception "
1642  "not a subclass of std::exception.";
1643  }
1644  const char gblErrMsgHeader[] = "Tpetra::DistObject "
1645  "threw an exception in unpackAndCombine on "
1646  "one or more processes in the DistObject's communicator.";
1647  auto comm = getMap()->getComm();
1648  Details::checkGlobalError(std::cerr, lclSuccess,
1649  lclErrStrm.str().c_str(),
1650  gblErrMsgHeader, *comm);
1651  }
1652  else {
1653  this->unpackAndCombine (remoteLIDs, this->imports_,
1654  this->numImportPacketsPerLID_,
1655  constantNumPackets, CM);
1656  }
1657  }
1658 
1659  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
1660  void
1661  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
1662  copyAndPermute
1663  (const SrcDistObject&,
1664  const size_t,
1665  const Kokkos::DualView<
1666  const local_ordinal_type*,
1667  buffer_device_type>&,
1668  const Kokkos::DualView<
1669  const local_ordinal_type*,
1670  buffer_device_type>&,
1671  const CombineMode CM)
1672  {}
1673 
1674  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
1675  void
1676  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
1677  packAndPrepare
1678  (const SrcDistObject&,
1679  const Kokkos::DualView<
1680  const local_ordinal_type*,
1681  buffer_device_type>&,
1682  Kokkos::DualView<
1683  packet_type*,
1684  buffer_device_type>&,
1685  Kokkos::DualView<
1686  size_t*,
1687  buffer_device_type>,
1688  size_t&)
1689  {}
1690 
1691  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
1692  void
1693  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
1694  unpackAndCombine
1695  (const Kokkos::DualView<
1696  const local_ordinal_type*,
1697  buffer_device_type>& /* importLIDs */,
1698  Kokkos::DualView<
1699  packet_type*,
1700  buffer_device_type> /* imports */,
1701  Kokkos::DualView<
1702  size_t*,
1703  buffer_device_type> /* numPacketsPerLID */,
1704  const size_t /* constantNumPackets */,
1705  const CombineMode /* combineMode */)
1706  {}
1707 
1708 
1709  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
1710  void
1711  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
1712  print (std::ostream& os) const
1713  {
1714  using Teuchos::FancyOStream;
1715  using Teuchos::getFancyOStream;
1716  using Teuchos::RCP;
1717  using Teuchos::rcpFromRef;
1718  using std::endl;
1719 
1720  RCP<FancyOStream> out = getFancyOStream (rcpFromRef (os));
1721  this->describe (*out, Teuchos::VERB_DEFAULT);
1722  }
1723 
1724  template <class Packet, class LocalOrdinal, class GlobalOrdinal, class Node>
1725  std::unique_ptr<std::string>
1726  DistObject<Packet, LocalOrdinal, GlobalOrdinal, Node>::
1727  createPrefix(const char className[],
1728  const char methodName[]) const
1729  {
1730  auto map = this->getMap();
1731  auto comm = map.is_null() ? Teuchos::null : map->getComm();
1732  return Details::createPrefix(
1733  comm.getRawPtr(), className, methodName);
1734  }
1735 
1736  template<class DistObjectType>
1737  void
1738  removeEmptyProcessesInPlace(
1739  Teuchos::RCP<DistObjectType>& input,
1740  const Teuchos::RCP<const Map<
1741  typename DistObjectType::local_ordinal_type,
1742  typename DistObjectType::global_ordinal_type,
1743  typename DistObjectType::node_type>>& newMap)
1744  {
1745  input->removeEmptyProcessesInPlace (newMap);
1746  if (newMap.is_null ()) { // my process is excluded
1747  input = Teuchos::null;
1748  }
1749  }
1750 
1751  template<class DistObjectType>
1752  void
1753  removeEmptyProcessesInPlace (Teuchos::RCP<DistObjectType>& input)
1754  {
1755  auto newMap = input->getMap ()->removeEmptyProcesses ();
1756  removeEmptyProcessesInPlace<DistObjectType> (input, newMap);
1757  }
1758 
1759 // Explicit instantiation macro for general DistObject.
1760 #define TPETRA_DISTOBJECT_INSTANT(SCALAR, LO, GO, NODE) \
1761  template class DistObject< SCALAR , LO , GO , NODE >;
1762 
1763 // Explicit instantiation macro for DistObject<char, ...>.
1764 // The "SLGN" stuff above doesn't work for Packet=char.
1765 #define TPETRA_DISTOBJECT_INSTANT_CHAR(LO, GO, NODE) \
1766  template class DistObject< char , LO , GO , NODE >;
1767 
1768 } // namespace Tpetra
1769 
1770 #endif // TPETRA_DISTOBJECT_DEF_HPP
Tpetra_Details_Behavior.hpp
Declaration of Tpetra::Details::Behavior, a class that describes Tpetra's behavior.
Tpetra_Details_Profiling.hpp
Declaration of Tpetra::Details::Profiling, a scope guard for Kokkos Profiling.
Tpetra_Details_reallocDualViewIfNeeded.hpp
Declaration and definition of Tpetra::Details::reallocDualViewIfNeeded, an implementation detail of T...
Tpetra::Details::UnpackAndCombineCrsGraphImpl::unpackAndCombine
void unpackAndCombine(const RowView &row_ptrs_beg, const RowView &row_ptrs_end, IndicesView &indices, const Kokkos::View< const GlobalOrdinal *, BufferDevice, Kokkos::MemoryUnmanaged > &imports, const Kokkos::View< const size_t *, BufferDevice, Kokkos::MemoryUnmanaged > &num_packets_per_lid, const Kokkos::View< const LocalOrdinal *, BufferDevice, Kokkos::MemoryUnmanaged > &import_lids, const typename CrsGraph< LocalOrdinal, GlobalOrdinal, Node >::padding_type &padding, const bool unpack_pids, const int myRank, const bool verbose)
Perform the unpack operation for the graph.
Definition: Tpetra_Details_unpackCrsGraphAndCombine_def.hpp:301
Tpetra_Util.hpp
Stand-alone utility functions and macros.
Tpetra::Details::Behavior
Description of Tpetra's behavior.
Definition: Tpetra_Details_Behavior.hpp:122
Tpetra::Details::Behavior::debug
static bool debug()
Whether Tpetra is in debug mode.
Definition: Tpetra_Details_Behavior.cpp:302
Tpetra::Details::Behavior::verbose
static bool verbose()
Whether Tpetra is in verbose mode.
Definition: Tpetra_Details_Behavior.cpp:315
Tpetra::DistObject
Base class for distributed Tpetra objects that support data redistribution.
Definition: Tpetra_DistObject_decl.hpp:324
Tpetra::DistObject::describe
virtual void describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel=Teuchos::Describable::verbLevel_default) const
Print a descriptiion of this object to the given output stream.
Definition: Tpetra_DistObject_def.hpp:171
Tpetra::DistObject::reallocImportsIfNeeded
virtual bool reallocImportsIfNeeded(const size_t newSize, const bool verbose, const std::string *prefix, const bool remoteLIDsContiguous=false, const CombineMode CM=INSERT)
Reallocate imports_ if needed.
Definition: Tpetra_DistObject_def.hpp:680
Tpetra::DistObject::reallocArraysForNumPacketsPerLid
virtual bool reallocArraysForNumPacketsPerLid(const size_t numExportLIDs, const size_t numImportLIDs)
Reallocate numExportPacketsPerLID_ and/or numImportPacketsPerLID_, if necessary.
Definition: Tpetra_DistObject_def.hpp:706
Tpetra::DistObject::doImport
void doImport(const SrcDistObject &source, const Import< LocalOrdinal, GlobalOrdinal, Node > &importer, const CombineMode CM, const bool restrictedMode=false)
Import data into this object using an Import object ("forward mode").
Definition: Tpetra_DistObject_def.hpp:276
Tpetra::DistObject::beginTransfer
void beginTransfer(const SrcDistObject &src, const ::Tpetra::Details::Transfer< local_ordinal_type, global_ordinal_type, node_type > &transfer, const char modeString[], const ReverseOption revOp, const CombineMode CM, const bool restrictedMode)
Implementation detail of doTransfer.
Definition: Tpetra_DistObject_def.hpp:778
Tpetra::DistObject::DistObject
DistObject(const Teuchos::RCP< const map_type > &map)
Constructor.
Definition: Tpetra_DistObject_def.hpp:98
Tpetra::DistObject::packAndPrepare
virtual void packAndPrepare(const SrcDistObject &source, const Kokkos::DualView< const local_ordinal_type *, buffer_device_type > &exportLIDs, Kokkos::DualView< packet_type *, buffer_device_type > &exports, Kokkos::DualView< size_t *, buffer_device_type > numPacketsPerLID, size_t &constantNumPackets)
Pack data and metadata for communication (sends).
Definition: Tpetra_DistObject_def.hpp:1678
Tpetra::DistObject::buffer_device_type
Kokkos::Device< typename device_type::execution_space, buffer_memory_space > buffer_device_type
Kokkos::Device specialization for communication buffers.
Definition: Tpetra_DistObject_decl.hpp:766
Tpetra::DistObject::local_ordinal_type
LocalOrdinal local_ordinal_type
The type of local indices.
Definition: Tpetra_DistObject_decl.hpp:335
Tpetra::DistObject::doTransfer
virtual void doTransfer(const SrcDistObject &src, const ::Tpetra::Details::Transfer< local_ordinal_type, global_ordinal_type, node_type > &transfer, const char modeString[], const ReverseOption revOp, const CombineMode CM, const bool restrictedMode)
Redistribute data across (MPI) processes.
Definition: Tpetra_DistObject_def.hpp:666
Tpetra::DistObject::print
void print(std::ostream &os) const
Print this object to the given output stream.
Definition: Tpetra_DistObject_def.hpp:1712
Tpetra::DistObject::unpackAndCombine
virtual void unpackAndCombine(const Kokkos::DualView< const local_ordinal_type *, buffer_device_type > &importLIDs, Kokkos::DualView< packet_type *, buffer_device_type > imports, Kokkos::DualView< size_t *, buffer_device_type > numPacketsPerLID, const size_t constantNumPackets, const CombineMode combineMode)
Perform any unpacking and combining after communication.
Definition: Tpetra_DistObject_def.hpp:1695
Tpetra::DistObject::packet_type
typename ::Kokkos::Details::ArithTraits< Packet >::val_type packet_type
The type of each datum being sent or received in an Import or Export.
Definition: Tpetra_DistObject_decl.hpp:333
Tpetra::DistObject::copyAndPermute
virtual void copyAndPermute(const SrcDistObject &source, const size_t numSameIDs, const Kokkos::DualView< const local_ordinal_type *, buffer_device_type > &permuteToLIDs, const Kokkos::DualView< const local_ordinal_type *, buffer_device_type > &permuteFromLIDs, const CombineMode CM)
Perform copies and permutations that are local to the calling (MPI) process.
Definition: Tpetra_DistObject_def.hpp:1663
Tpetra::DistObject< Scalar, LO, GO, Node >::ReverseOption
ReverseOption
Whether the data transfer should be performed in forward or reverse mode.
Definition: Tpetra_DistObject_decl.hpp:679
Tpetra::DistObject::constantNumberOfPackets
virtual size_t constantNumberOfPackets() const
Whether the implementation's instance promises always to have a constant number of packets per LID (l...
Definition: Tpetra_DistObject_def.hpp:659
Tpetra::DistObject::doExport
void doExport(const SrcDistObject &source, const Export< LocalOrdinal, GlobalOrdinal, Node > &exporter, const CombineMode CM, const bool restrictedMode=false)
Export data into this object using an Export object ("forward mode").
Definition: Tpetra_DistObject_def.hpp:308
Tpetra::DistObject::description
virtual std::string description() const
One-line descriptiion of this object.
Definition: Tpetra_DistObject_def.hpp:151
Tpetra::DistObject::removeEmptyProcessesInPlace
virtual void removeEmptyProcessesInPlace(const Teuchos::RCP< const map_type > &newMap)
Remove processes which contain no entries in this object's Map.
Definition: Tpetra_DistObject_def.hpp:238
Tpetra::DistObject::isDistributed
bool isDistributed() const
Whether this is a globally distributed object.
Definition: Tpetra_DistObject_def.hpp:652
Tpetra::Export
Communication plan for data redistribution from a (possibly) multiply-owned to a uniquely-owned distr...
Definition: Tpetra_Export_decl.hpp:124
Tpetra::Import
Communication plan for data redistribution from a uniquely-owned to a (possibly) multiply-owned distr...
Definition: Tpetra_Import_decl.hpp:116
Tpetra::SrcDistObject
Abstract base class for objects that can be the source of an Import or Export operation.
Definition: Tpetra_SrcDistObject.hpp:89
Tpetra::Details::createPrefix
std::unique_ptr< std::string > createPrefix(const int myRank, const char prefix[])
Create string prefix for each line of verbose output.
Definition: Tpetra_Util.cpp:101
Tpetra::Details::getDualViewCopyFromArrayView
Kokkos::DualView< T *, DT > getDualViewCopyFromArrayView(const Teuchos::ArrayView< const T > &x_av, const char label[], const bool leaveOnHost)
Get a 1-D Kokkos::DualView which is a deep copy of the input Teuchos::ArrayView (which views host mem...
Definition: Tpetra_Util.hpp:982
Tpetra::Details::dualViewStatusToString
std::string dualViewStatusToString(const DualViewType &dv, const char name[])
Return the status of the given Kokkos::DualView, as a human-readable string.
Definition: Tpetra_Util.hpp:1012
Tpetra::Details::reallocDualViewIfNeeded
bool reallocDualViewIfNeeded(Kokkos::DualView< ValueType *, DeviceType > &dv, const size_t newSize, const char newLabel[], const size_t tooBigFactor=2, const bool needFenceBeforeRealloc=true)
Reallocate the DualView in/out argument, if needed.
Definition: Tpetra_Details_reallocDualViewIfNeeded.hpp:83
Tpetra::Details::getArrayViewFromDualView
Teuchos::ArrayView< typename DualViewType::t_dev::value_type > getArrayViewFromDualView(const DualViewType &x)
Get a Teuchos::ArrayView which views the host Kokkos::View of the input 1-D Kokkos::DualView.
Definition: Tpetra_Util.hpp:944
Tpetra
Namespace Tpetra contains the class and methods constituting the Tpetra library.
Tpetra::removeEmptyProcessesInPlace
void removeEmptyProcessesInPlace(Teuchos::RCP< DistObjectType > &input, const Teuchos::RCP< const Map< typename DistObjectType::local_ordinal_type, typename DistObjectType::global_ordinal_type, typename DistObjectType::node_type > > &newMap)
Remove processes which contain no elements in this object's Map.
Tpetra::combineModeToString
std::string combineModeToString(const CombineMode combineMode)
Human-readable string representation of the given CombineMode.
Definition: Tpetra_CombineMode.cpp:93
Tpetra::CombineMode
CombineMode
Rule for combining data in an Import or Export.
Definition: Tpetra_CombineMode.hpp:97
Tpetra::ZERO
@ ZERO
Replace old values with zero.
Definition: Tpetra_CombineMode.hpp:102
Generated by doxygen 1.9.1