Implement hierarhial unpacking

Author: tjfulle

packages/tpetra/core/src/Tpetra_CrsMatrix_def.hpp

@@ -4747,9 +4747,7 @@ namespace Tpetra {
     // Read parameters from the input ParameterList.
     //
     {
-      Details::ProfilingRegion region(
-	"Tpetra::CrsMatrix::fillCompete",
-	"ParameterList");
+      Details::ProfilingRegion region_fc("Tpetra::CrsMatrix::fillCompete", "ParameterList");
 
       // If true, the caller promises that no process did nonlocal
       // changes since the last call to fillComplete.
@@ -4798,9 +4796,7 @@ namespace Tpetra {
       }
     }
     if (this->isStaticGraph ()) {
-      Details::ProfilingRegion region(
-	"Tpetra::CrsMatrix::fillCompete",
-	"isStaticGraph");
+      Details::ProfilingRegion region_isg("Tpetra::CrsMatrix::fillCompete", "isStaticGraph");
       // FIXME (mfh 14 Nov 2016) In order to fix #843, I enable the
       // checks below only in debug mode.  It would be nicer to do a
       // local check, then propagate the error state in a deferred
@@ -4850,9 +4846,7 @@ namespace Tpetra {
       this->fillLocalMatrix (params);
     }
     else {
-      Details::ProfilingRegion region(
-	"Tpetra::CrsMatrix::fillCompete",
-	"isNotStaticGraph");
+      Details::ProfilingRegion region_insg("Tpetra::CrsMatrix::fillCompete", "isNotStaticGraph");
       // Set the graph's domain and range Maps.  This will clear the
       // Import if the domain Map has changed (is a different
       // pointer), and the Export if the range Map has changed (is a
@@ -4906,9 +4900,9 @@ namespace Tpetra {
     }
 
     {
-      Details::ProfilingRegion region(
-	"Tpetra::CrsMatrix::fillCompete",
-	"callComputeGlobalConstamnts");
+      Details::ProfilingRegion region_ccgc(
+        "Tpetra::CrsMatrix::fillCompete", "callComputeGlobalConstamnts"
+      );
       const bool callComputeGlobalConstants = params.get () == nullptr ||
 	params->get ("compute global constants", true);
       if (callComputeGlobalConstants) {
@@ -4920,9 +4914,9 @@ namespace Tpetra {
 
     this->fillComplete_ = true; // Now we're fill complete!
     {
-      Details::ProfilingRegion region(
-	"Tpetra::CrsMatrix::fillCompete",
-	"checkInternalState");
+      Details::ProfilingRegion region_cis(
+        "Tpetra::CrsMatrix::fillCompete", "checkInternalState"
+      );
       this->checkInternalState ();
     }
   }

packages/tpetra/core/src/Tpetra_Details_Behavior.cpp

@@ -189,12 +189,16 @@ namespace { // (anonymous)
     else {
       // This could throw invalid_argument or out_of_range.
       // Go ahead and let it do so.
-      const long long val = std::stoll(stringToUpper(varVal));
-      TEUCHOS_TEST_FOR_EXCEPTION
-        (val < static_cast<long long>(0), std::out_of_range,
-         prefix << "Environment variable \""
-         << environmentVariableName << "\" is supposed to be a size, "
-         "but it has a negative integer value " << val << ".");
+      long long val = std::stoll(stringToUpper(varVal));
+      if (val < static_cast<long long>(0)) {
+        // If negative - user has requested threshold be lifted
+        return std::numeric_limits<size_t>::max();
+      }
+//      TEUCHOS_TEST_FOR_EXCEPTION
+//        (val < static_cast<long long>(0), std::out_of_range,
+//         prefix << "Environment variable \""
+//         << environmentVariableName << "\" is supposed to be a size, "
+//         "but it has a negative integer value " << val << ".");
       if (sizeof(long long) > sizeof(size_t)) {
         // It's hard to test this code, but I want to try writing it
         // at least, in case we ever have to run on 32-bit machines or
@@ -284,6 +288,10 @@ namespace { // (anonymous)
 #endif // TPETRA_ASSUME_CUDA_AWARE_MPI
   }
 
+  constexpr bool hierarchicalUnpackDefault () {
+    return true;
+  }
+
 } // namespace (anonymous)
 
 bool Behavior::debug ()
@@ -459,6 +467,28 @@ bool Behavior::timing (const char name[])
                                                         envVarName,
                                                         defaultValue);
 }
+
+void Behavior::enable_timing() {
+  BehaviorDetails::timingDisabled_ = false;
+}
+
+void Behavior::disable_timing() {
+  BehaviorDetails::timingDisabled_ = true;
+}
+
+bool Behavior::hierarchicalUnpack ()
+{
+  constexpr char envVarName[] = "TPETRA_HIERARCHICAL_UNPACK";
+  constexpr bool defaultValue = hierarchicalUnpackDefault();
+
+  static bool value_ = defaultValue;
+  static bool initialized_ = false;
+  return idempotentlyGetEnvironmentVariableAsBool (value_,
+                                                   initialized_,
+                                                   envVarName,
+                                                   defaultValue);
+}
+
 } // namespace Details
 } // namespace Tpetra
 

packages/tpetra/core/src/Tpetra_Details_Behavior.hpp

@@ -168,6 +168,12 @@ class Behavior {
   ///        "CrsGraph::insertLocalIndices".
   static bool timing (const char name[]);
 
+  /// \brief Disable timing, programatically
+  static void disable_timing();
+
+  /// \brief Enable timing, programatically
+  static void enable_timing();
+
   /// \brief Whether to assume that MPI is CUDA aware.
   ///
   /// An MPI implementation is "CUDA aware" if it can accept CUDA
@@ -216,13 +222,16 @@ class Behavior {
 
   /// \brief the threshold for transitioning from device to host
   ///
-  /// If the number of elements in the multivector does not exceed this 
+  /// If the number of elements in the multivector does not exceed this
   /// threshold and the data is on host, then run the calculation on
   /// host.  Otherwise, run on device.
   /// By default this is 10000, but may be altered by the environment
   /// variable TPETRA_VECTOR_DEVICE_THRESHOLD
   static size_t multivectorKernelLocationThreshold ();
 
+  /// \brief Unpack rows of a matrix using hierarchical unpacking
+  static bool hierarchicalUnpack ();
+
   /// \brief Use Teuchos::Timer in Tpetra::ProfilingRegion
   ///
   /// This is disabled by default.  You may control this at run time via the

packages/tpetra/core/src/Tpetra_Details_packCrsMatrix_def.hpp

@@ -935,15 +935,14 @@ packCrsMatrix (const CrsMatrix<ST, LO, GO, NT>& sourceMatrix,
 
 template<typename ST, typename LO, typename GO, typename NT>
 void
-packCrsMatrixNew (const CrsMatrix<ST, LO, GO, NT>& sourceMatrix,
-                  Kokkos::DualView<char*,
-                    typename DistObject<char, LO, GO, NT>::buffer_device_type>& exports,
-                  const Kokkos::DualView<size_t*,
-                    typename DistObject<char, LO, GO, NT>::buffer_device_type>& numPacketsPerLID,
-                  const Kokkos::DualView<const LO*,
-                    typename DistObject<char, LO, GO, NT>::buffer_device_type>& exportLIDs,
-                  size_t& constantNumPackets,
-                  Distributor& distor)
+packCrsMatrixNew(
+  const CrsMatrix<ST, LO, GO, NT>& sourceMatrix,
+  Kokkos::DualView<char*, typename DistObject<char, LO, GO, NT>::buffer_device_type>& exports,
+  const Kokkos::DualView<size_t*, typename DistObject<char, LO, GO, NT>::buffer_device_type>& numPacketsPerLID,
+  const Kokkos::DualView<const LO*, typename DistObject<char, LO, GO, NT>::buffer_device_type>& exportLIDs,
+  size_t& constantNumPackets,
+  Distributor& distor
+)
 {
   using device_type = typename CrsMatrix<ST, LO, GO, NT>::device_type;
   using buffer_device_type = typename DistObject<char, LO, GO, NT>::buffer_device_type;