#410: Dependent Epochs rewritten

src/vt/epoch/epoch.h

@@ -115,7 +115,7 @@ static constexpr BitCountType const epoch_category_num_bits = 2;
  */
 enum struct eEpochCategory : int8_t {
   NoCategoryEpoch       = 0x0,
-  InsertEpoch           = 0x1,
+  DependentEpoch        = 0x1,
   DijkstraScholtenEpoch = 0x2
 };
 

src/vt/epoch/epoch_manip.cc

@@ -148,6 +148,29 @@ EpochWindow* EpochManip::getTerminatedWindow(EpochType epoch) {
   return BitPackerType::boolGetField<field,size,ImplType>(*epoch);
 }
 
+/*static*/ bool EpochManip::isDS(EpochType epoch) {
+  using T = typename std::underlying_type<epoch::eEpochCategory>::type;
+  if (isRooted(epoch)) {
+    auto const ds_bit = epoch::eEpochCategory::DijkstraScholtenEpoch;
+    auto const cat = category(epoch);
+    bool const is_ds = static_cast<T>(cat) & static_cast<T>(ds_bit);
+    return is_ds;
+  } else {
+    return false;
+  }
+}
+
+/*static*/ bool EpochManip::isDep(EpochType epoch) {
+  using T = typename std::underlying_type<epoch::eEpochCategory>::type;
+  if (epoch == no_epoch or epoch == term::any_epoch_sentinel) {
+    return false;
+  }
+  auto const dep_bit = epoch::eEpochCategory::DependentEpoch;
+  auto const cat = epoch::EpochManip::category(epoch);
+  bool const is_dep = static_cast<T>(cat) & static_cast<T>(dep_bit);
+  return is_dep;
+}
+
 /*static*/ eEpochCategory EpochManip::category(EpochType const& epoch) {
   return BitPackerType::getField<
     eEpochRoot::rEpochCategory, epoch_category_num_bits, eEpochCategory
@@ -190,6 +213,14 @@ void EpochManip::setCategory(EpochType& epoch, eEpochCategory const cat) {
   >(*epoch,cat);
 }
 
+/*static*/ eEpochCategory EpochManip::makeCat(
+  eEpochCategory c1, eEpochCategory c2
+) {
+  using T = typename std::underlying_type<eEpochCategory>::type;
+  auto ret = static_cast<T>(c1) | static_cast<T>(c2);
+  return static_cast<eEpochCategory>(ret);
+}
+
 /*static*/
 void EpochManip::setNode(EpochType& epoch, NodeType const node) {
   vtAssert(isRooted(epoch), "Must be rooted to manipulate the node");

src/vt/epoch/epoch_manip.h

@@ -89,6 +89,24 @@ struct EpochManip : runtime::component::Component<EpochManip> {
    */
   static bool isRooted(EpochType const& epoch);
 
+  /**
+   * \brief Gets whether an epoch is DS or onot
+   *
+   * \param[in] epoch the epoch
+   *
+   * \return whether it is DS
+   */
+  static bool isDS(EpochType epoch);
+
+  /**
+   * \brief Gets whether an epoch is dependent or onot
+   *
+   * \param[in] epoch the epoch
+   *
+   * \return whether it is dependent
+   */
+  static bool isDep(EpochType epoch);
+
   /**
    * \brief Gets the \c eEpochCategory of a given epoch
    *
@@ -152,6 +170,14 @@ struct EpochManip : runtime::component::Component<EpochManip> {
    */
   static void setSeq(EpochType& epoch, EpochType::ImplType const seq);
 
+  /**
+   * \brief Combine eEpochCategory elements
+   *
+   * \param[in] c1 category 1
+   * \param[in] c2 category 2
+   */
+  static eEpochCategory makeCat(eEpochCategory c1, eEpochCategory c2);
+
   /*
    * General (stateless) methods for creating a epoch with certain properties
    * based on a current sequence number

src/vt/messaging/active.cc

@@ -934,12 +934,13 @@ void ActiveMessenger::prepareActiveMsgToRun(
   using MsgType = ShortMessage;
   auto msg = base.to<MsgType>().get();
 
-  auto const is_term = envelopeIsTerm(msg->env);
-  auto const is_bcast = envelopeIsBcast(msg->env);
-  auto const dest = envelopeGetDest(msg->env);
-  auto const handler = envelopeGetHandler(msg->env);
-  auto const epoch = envelopeIsEpochType(msg->env) ?
+  auto const is_term   = envelopeIsTerm(msg->env);
+  auto const is_bcast  = envelopeIsBcast(msg->env);
+  auto const dest      = envelopeGetDest(msg->env);
+  auto const handler   = envelopeGetHandler(msg->env);
+  auto const epoch     = envelopeIsEpochType(msg->env) ?
     envelopeGetEpoch(msg->env) : term::any_epoch_sentinel;
+
   auto const from_node = is_bcast ? dest : in_from_node;
 
   if (!is_term || vt_check_enabled(print_term_msgs)) {
@@ -963,6 +964,13 @@ void ActiveMessenger::prepareActiveMsgToRun(
   if (is_obj) {
     objgroup::dispatchObjGroup(base, handler, from_node, cont);
   } else {
+    if (epoch != term::any_epoch_sentinel and epoch::EpochManip::isDep(epoch)) {
+      if (not theTerm()->epochReleased(epoch)) {
+        pending_epoch_msgs_[epoch].emplace_back(base, from_node);
+        return;
+      }
+    }
+
     runnable::makeRunnable(base, not is_term, handler, from_node)
       .withContinuation(cont)
       .withTDEpochFromMsg(is_term)
@@ -981,6 +989,17 @@ void ActiveMessenger::prepareActiveMsgToRun(
   }
 }
 
+void ActiveMessenger::releaseEpochMsgs(EpochType epoch) {
+  auto iter = pending_epoch_msgs_.find(epoch);
+  if (iter != pending_epoch_msgs_.end()) {
+    auto msgs = std::move(iter->second);
+    pending_epoch_msgs_.erase(iter);
+    for (auto&& m : msgs) {
+      prepareActiveMsgToRun(m.buffered_msg, m.from_node, true, m.cont);
+    }
+  }
+}
+
 bool ActiveMessenger::tryProcessIncomingActiveMsg() {
   CountType num_probe_bytes;
   MPI_Status stat;

src/vt/messaging/active.h

@@ -268,7 +268,7 @@ struct BufferedActiveMsg {
 
   BufferedActiveMsg(
     MessageType const& in_buffered_msg, NodeType const& in_from_node,
-    ActionType in_cont
+    ActionType in_cont = nullptr
   ) : buffered_msg(in_buffered_msg), from_node(in_from_node), cont(in_cont)
   { }
 
@@ -327,6 +327,8 @@ struct ActiveMessenger : runtime::component::PollableComponent<ActiveMessenger>
   using SendFnType           = std::function<SendInfo(PtrLenPairType,NodeType,TagType)>;
   using UserSendFnType       = std::function<void(SendFnType)>;
   using ContainerPendingType = std::unordered_map<TagType,PendingRecvType>;
+  using MsgContType          = std::list<BufferedMsgType>;
+  using EpochWaitType        = std::unordered_map<EpochType, MsgContType>;
   using ReadyHanTagType      = std::tuple<HandlerType, TagType>;
   using HandlerManagerType   = HandlerManager;
   using PendingSendType      = PendingSend;
@@ -1650,6 +1652,13 @@ struct ActiveMessenger : runtime::component::PollableComponent<ActiveMessenger>
   # endif
   }
 
+  /*
+   * \brief Deliver messages that are now released with a dependent epoch
+   *
+   * \param[in] epoch the epoch to release
+   */
+  void releaseEpochMsgs(EpochType epoch);
+
 private:
   /**
    * \internal \brief Allocate a new, unused tag.
@@ -1764,6 +1773,7 @@ struct ActiveMessenger : runtime::component::PollableComponent<ActiveMessenger>
   elm::ElementIDStruct bare_handler_dummy_elm_id_for_lb_data_ = {};
   elm::ElementLBData bare_handler_lb_data_;
   MPI_Comm comm_ = MPI_COMM_NULL;
+  EpochWaitType pending_epoch_msgs_                           = {};
 };
 
 }} // end namespace vt::messaging