Change LinkId_t to be 64-bits, make it globally unique, and store the ID in the Link object. This added an extra exchange between ConfigGraphs created on different ranks during a parallel load.

Author: feldergast

src/sst/core/link.cc

@@ -127,6 +127,7 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer
           For self links, no rank info is stored since we don't need
           to create a unique ID
         */
+
         if ( type == SYNC || type == REG ) {
             SST_SER(my_rank);
 
@@ -158,6 +159,13 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer
             }
         } // if ( type == SYNC || type == REG )
 
+
+        // Serialize the ID for the Link
+        if ( !s->has_tool_list )
+            SST_SER(s->id);
+        else
+            SST_SER((*s->attached_tools)[0].second);
+
         /*
           Store the metadata for this link
         */
@@ -217,24 +225,31 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer
 
         // Determine how many serializable tools there are
         Link::ToolList tools;
-        if ( s->attached_tools ) {
-            for ( auto x : *s->attached_tools ) {
-                if ( dynamic_cast<SST::Core::Serialization::serializable*>(x.first) ) {
-                    tools.push_back(x);
+
+        if ( s->has_tool_list ) {
+            for ( auto x = ++s->attached_tools->begin(); x != s->attached_tools->end(); ++x ) {
+                if ( dynamic_cast<SST::Core::Serialization::serializable*>(x->first) ) {
+                    tools.push_back(*x);
                 }
             }
         }
         size_t tool_count = tools.size();
-        SST_SER(tool_count);
-        if ( tool_count > 0 ) {
-            // Serialize each tool, then call
-            // serializeEventAttachPointKey() to serialize any data
-            // associated with the key
-            for ( auto x : tools ) {
-                SST::Core::Serialization::serializable* obj =
-                    dynamic_cast<SST::Core::Serialization::serializable*>(x.first);
-                SST_SER(obj);
-                x.first->serializeEventAttachPointKey(ser, x.second);
+
+        // Need to determine if we'll have any tools attached on restart. We only have tools when tool_count > 0
+        bool restart_tools = (tool_count > 0);
+        SST_SER(restart_tools);
+
+        if ( restart_tools ) {
+            SST_SER(tool_count);
+            if ( tool_count > 0 ) {
+                // Serialize each tool, then call serializeEventAttachPointKey() to serialize any data associated with
+                // the key
+                for ( auto x : tools ) {
+                    SST::Core::Serialization::serializable* obj =
+                        dynamic_cast<SST::Core::Serialization::serializable*>(x.first);
+                    SST_SER(obj);
+                    x.first->serializeEventAttachPointKey(ser, x.second);
+                }
             }
         }
 
@@ -339,6 +354,8 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer
             }
         }
 
+        SST_SER(s->id);
+
         /*
           Get the metadata for the link
         */
@@ -401,13 +418,20 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer
             s->pair_link->latency += latency;
         }
 
-        /*
-          Restore attached tools
-        */
-        size_t tool_count;
-        SST_SER(tool_count);
-        if ( tool_count > 0 ) {
-            s->attached_tools = new Link::ToolList();
+        SST_SER(s->has_tool_list);
+
+        if ( s->has_tool_list ) {
+            /*
+              Restore attached tools
+            */
+            size_t tool_count;
+            SST_SER(tool_count);
+
+            // If has_tool_list is true, then tool_count is greater than 0
+            Link::ToolList* tools = new Link::ToolList();
+            tools->emplace_back(nullptr, s->id);
+            s->attached_tools = tools;
+            s->has_tool_list  = true;
             for ( size_t i = 0; i < tool_count; ++i ) {
                 SST::Core::Serialization::serializable* tool;
                 uintptr_t                               key;
@@ -417,9 +441,7 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer
                 s->attached_tools->emplace_back(ap, key);
             }
         }
-        else {
-            s->attached_tools = nullptr;
-        }
+
 
         /*
           Deserialize the events targetting this link
@@ -477,7 +499,7 @@ class NullEvent : public Event
 };
 
 
-Link::Link(LinkId_t tag) :
+Link::Link(LinkId_t id) :
     send_queue(nullptr),
     delivery_info(0),
     defaultTimeBase(0),
@@ -486,8 +508,8 @@ Link::Link(LinkId_t tag) :
     current_time(Simulation_impl::getSimulation()->currentSimCycle),
     type(UNINITIALIZED),
     mode(INIT),
-    tag(tag),
-    attached_tools(nullptr)
+    tag(0),
+    id(id)
 {}
 
 Link::Link() :
@@ -499,8 +521,7 @@ Link::Link() :
     current_time(Simulation_impl::getSimulation()->currentSimCycle),
     type(UNINITIALIZED),
     mode(INIT),
-    tag(bit_util::type_max<uint32_t>),
-    attached_tools(nullptr)
+    tag(bit_util::type_max<uint32_t>)
 {}
 
 Link::~Link()
@@ -514,7 +535,7 @@ Link::~Link()
         if ( SYNC == pair_link->type ) delete pair_link;
     }
 
-    if ( attached_tools ) delete attached_tools;
+    if ( has_tool_list ) delete attached_tools;
 }
 
 void
@@ -683,9 +704,10 @@ Link::send_impl(SimTime_t delay, Event* event)
     event->addRecvComponent(pair_link->comp, pair_link->ctype, pair_link->port);
 #endif
 
-    if ( attached_tools ) {
-        for ( auto& x : *attached_tools ) {
-            x.first->eventSent(x.second, event);
+    if ( has_tool_list ) {
+        // First entry just holds the Link id, so we can skip it
+        for ( auto x = ++attached_tools->begin(); x != attached_tools->end(); ++x ) {
+            x->first->eventSent(x->second, event);
             // Check to see if the event was deleted.  If so, return.
             if ( nullptr == event ) return;
         }
@@ -840,17 +862,23 @@ Link::createUniqueGlobalLinkName(RankInfo local_rank, uintptr_t local_ptr, RankI
 void
 Link::attachTool(AttachPoint* tool, const AttachPointMetaData& mdata)
 {
-    if ( !attached_tools ) attached_tools = new ToolList();
+    if ( !has_tool_list ) {
+        auto tools = new ToolList();
+        tools->emplace_back(nullptr, id);
+        attached_tools = tools;
+        has_tool_list  = true;
+    }
     auto key = tool->registerLinkAttachTool(mdata);
-    attached_tools->push_back(std::make_pair(tool, key));
+    attached_tools->emplace_back(tool, key);
 }
 
 void
 Link::detachTool(AttachPoint* tool)
 {
-    if ( !attached_tools ) return;
+    if ( !has_tool_list ) return;
 
-    for ( auto x = attached_tools->begin(); x != attached_tools->end(); ++x ) {
+    // First entry just holds the Link id, so we can skip it
+    for ( auto x = ++attached_tools->begin(); x != attached_tools->end(); ++x ) {
         if ( x->first == tool ) {
             attached_tools->erase(x);
             break;

src/sst/core/link.h

@@ -56,7 +56,7 @@ class SST::Core::Serialization::serialize_impl<Link*>
 class alignas(64) Link
 {
     enum Type_t : uint16_t { POLL, HANDLER, SYNC, UNINITIALIZED };
-    enum Mode_t : uint16_t { INIT, RUN, COMPLETE };
+    enum Mode_t : uint8_t { INIT, RUN, COMPLETE };
 
     friend class SST::Core::Serialization::serialize_impl<Link*>;
 
@@ -280,7 +280,13 @@ class alignas(64) Link
 
        @return the unique ID for this Link
     */
-    LinkId_t getId() { return tag; }
+    LinkId_t getId()
+    {
+        if ( has_tool_list )
+            return (*attached_tools)[0].second;
+        else
+            return id;
+    }
 
     /**
        Return the default timebase for this Link
@@ -418,6 +424,7 @@ class alignas(64) Link
     SimTime_t& current_time;
     Type_t     type;
     Mode_t     mode;
+    bool       has_tool_list = false;
     uint32_t   tag;
 
     /**
@@ -433,8 +440,6 @@ class alignas(64) Link
     */
     explicit Link(LinkId_t id);
 
-    Link(const Link& l);
-
     /**
        Specifies that this Link has no callback, and is poll-based only
     */
@@ -458,7 +463,44 @@ class alignas(64) Link
 
 
     using ToolList = std::vector<std::pair<AttachPoint*, uintptr_t>>;
-    ToolList* attached_tools;
+
+    /**
+       We need to keep the Link object to 64-bits so we need to keep the ID and the attached tools in the same 8-bytes.
+       This will normally hold the 64-bit id for the link, but if we have attached tools, then the id for the Link will
+       be stored in the first entry of the attached_tools list.
+
+       The has_tool_list member variable stores which data is currently stored in this union.  If has_tool_list is true,
+       then the union's attached_tools variable is currently active.  Otherwise, it is storing the Link id.
+    */
+    union {
+        /**
+           The Link id is a globally unique id.  For serial loads, the ids start at 1 and increment for each new Link.
+
+           On a parallel load, the top 32-bits is filled with the MPI rank and the bottom 32-bits start at 1 and
+           increment for each new rank.  The ids for links that cross a rank boundary need to be reconciled so that the
+           Link objects on both ranks agree on the ID.  This is done by having the "lower" rank send the Link name and
+           it's id for the Link to the "higher" rank, which will then use that id for the Link. "Higher" and "lower" are
+           determined in a way that hopefully spreads out the MPI traffic across all the ranks and isn't just a direct
+           greater/less than comparison. It is determined as follows:
+
+           1 - A rank is lower than the N/2 ranks after it, wrapping around to 0 when needed.
+
+           2 - A rank is higher than the N/2 ranks before it, wrapping around to N-1 when needed.
+
+          The id is used in several places:
+          - When exchanging Link pointers to put in the delivery_info field
+          - As the global name for connecting links on a restart from checkpoint
+
+        */
+        LinkId_t id;
+
+        /**
+           This stores any tools connected to the Link::AttachPoint.  The first entry in the list will always contain
+           the Link id since the pointer to the attached_tools list is now using that memory location.
+         */
+        ToolList* attached_tools;
+    };
+
 
     /**
        Manually set the default time base

src/sst/core/linkPair.h

@@ -24,44 +24,29 @@ class LinkPair
 {
 public:
     /** Create a new LinkPair.  This is used when the endpoints are in the same partition.
-     * @param order Value used to enforce the link order.
-     */
-    explicit LinkPair(LinkId_t order) :
-        left(new Link(order)),
-        right(new Link(order))
-    {
-        my_id = order;
 
+        @param id ID of the link
+    */
+    explicit LinkPair(LinkId_t id) :
+        left(new Link(id)),
+        right(new Link(id))
+    {
         left->pair_link  = right;
         right->pair_link = left;
     }
 
     /** Create a new LinkPair.  This is used on restart.
-     * @param order Value used to enforce the link order.
-     */
+
+        @param order Value used to enforce the link order.
+    */
     LinkPair() :
         left(new Link()),
         right(new Link())
     {
-        my_id = -1;
-
         left->pair_link  = right;
         right->pair_link = left;
     }
 
-    /** Create a new LinkPair.  This is used when the endpoints are in different partitions.
-     * @param order Value used to enforce the link order.
-     * @param remote_tag Used to look up the correct link on the other side.
-     */
-    LinkPair(LinkId_t order, LinkId_t remote_tag) :
-        left(new Link(remote_tag)),
-        right(new Link(order))
-    {
-        my_id = order;
-
-        left->pair_link  = right;
-        right->pair_link = left;
-    }
 
     virtual ~LinkPair() {}
 
@@ -78,8 +63,6 @@ class LinkPair
 private:
     Link* left;
     Link* right;
-
-    LinkId_t my_id;
 };
 
 } // namespace SST