introduce shared_depth to mapping options

By analogy with private_depth, introduce a "shared_depth" mapping option
to control the schedule depth at which the promotion to shared memory is
performed.  This value is optional.  If it is not provided, but the
shared memory promotion is requested, then perform the promotion at
depth equal to the number of block-mapped loops.  This is a pragmatic
choice to keep the original behavior if the new option is not provided,
in particular for benchmarks with hardcoded options until we re-run the
autotuning.

Author: ftynse

tc/core/cuda/cuda_mapping_options.cc

@@ -294,6 +294,11 @@ CudaMappingOptions& CudaMappingOptions::privateDepth(uint32_t depth) {
   return *this;
 }
 
+CudaMappingOptions& CudaMappingOptions::sharedDepth(uint32_t depth) {
+  ownedProto_.set_shared_depth(depth);
+  return *this;
+}
+
 CudaMappingOptions& CudaMappingOptions::mapToThreads(
     const std::string& commaSeparatedSizes) {
   auto sizes = parseCommaSeparatedIntegers<uint64_t>(commaSeparatedSizes);

tc/core/cuda/cuda_mapping_options.h

@@ -196,6 +196,7 @@ class CudaMappingOptions {
   CudaMappingOptions& unrollCopyShared(bool b);
   CudaMappingOptions& useReadOnlyCache(bool b);
   CudaMappingOptions& privateDepth(uint32_t depth);
+  CudaMappingOptions& sharedDepth(uint32_t depth);
   ///@}
 
   /// Static constructors for predefined strategies.

tc/core/cuda/cuda_mapping_options_cpp_printer.cc

@@ -39,6 +39,7 @@ CudaMappingOptionsCppPrinter& operator<<(
         "maxSharedMemory", cudaOptions.proto().max_shared_memory());
   }
   prn.printValueOption("privateDepth", cudaOptions.proto().private_depth());
+  prn.printValueOption("sharedDepth", cudaOptions.proto().shared_depth());
   prn.endStmt();
   return prn;
 }

tc/core/polyhedral/cuda/mapped_scop.cc

@@ -1049,8 +1049,9 @@ std::unique_ptr<MappedScop> MappedScop::makeWithOuterBlockInnerThreadStrategy(
   LOG_IF(INFO, FLAGS_debug_tc_mapper) << "After mapping to blocks:" << std::endl
                                       << *mappedScop->schedule();
 
-  // 8. Promote to shared memory below the loops mapped to blocks.
-  // This may split the outer band, so find the new outer band after promotion.
+  // 8. Promote to shared memory.
+  // If shared promotion depth is specified in the mapping options, use the
+  // specified value.  Otherwise, promote below the loops mapped to blocks.
   if (cudaOptions.proto().use_shared_memory()) {
     size_t sharedMemorySize = cudaOptions.proto().has_max_shared_memory()
         ? cudaOptions.proto().max_shared_memory()
@@ -1069,19 +1070,21 @@ std::unique_ptr<MappedScop> MappedScop::makeWithOuterBlockInnerThreadStrategy(
       sharedMemorySize -= reductionMemoryRequirement;
     }
 
-    auto band = outerBand->as<ScheduleTreeBand>();
-    LOG_IF(WARNING, FLAGS_debug_tc_mapper && band->nMember() == 0)
-        << "Aborting memory promotion because outer band has 0 members (NYI)";
-    if (band->nMember() > 0 && sharedMemorySize > 0) {
+    if (sharedMemorySize > 0) {
       LOG_IF(
           WARNING,
           cudaOptions.proto().unroll_copy_shared() &&
               !generic.proto.has_unroll())
           << "requested to unroll copies to shared memory without providing the unroll size";
 
+      auto depth = cudaOptions.proto().has_shared_depth()
+          ? cudaOptions.proto().shared_depth()
+          : std::min(
+                outerBand->as<ScheduleTreeBand>()->nOuterCoincident(),
+                mappedScop->numBlocks.view.size());
       promoteToSharedAtDepth(
           *mappedScop,
-          std::min(band->nOuterCoincident(), mappedScop->numBlocks.view.size()),
+          depth,
           sharedMemorySize,
           cudaOptions.proto().unroll_copy_shared() &&
               generic.proto.has_unroll());

tc/proto/mapping_options.proto

@@ -72,6 +72,8 @@ message CudaMappingOptionsProto {
   required bool use_readonly_cache = 8;
   // Depth of promotion to private memory, ignored if use_private_memory is false.
   optional uint32 private_depth = 9;
+  // Depth of promotion to shared memory, ignored if use_shared_memory is false.
+  optional uint32 shared_depth = 10;
 }
 
 message CpuMappingOptionsProto {