Link id update (#1569)

* Modernize sst_types.h and add bit_util namespace for functions and variables used to manipulate bits in the various IDs used in the core.

* Remove order field from ConfigLink and change remaining variable names to add a trailing underscore per the coding standards.

* 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.

* Changed the exchange of link pointers from using names to using link IDs.  Also removed the std::map currently used for the exchange and replaced it with std::vector.  The vector is sorted and compared item by item to the data sent from the remote rank removing the need to do a bunch of lookups in the map.  This saves both memory and compute time.

* Change Link ID exchange to directly serialized data into send buffer and deserialize a link at a time to save memory.  Also switch to non-blocking send/recv to avoid deadlocks.

Author: feldergast

src/sst/core/impl/partitioners/simplepart.cc

@@ -235,7 +235,7 @@ SimplePartitioner::performPartition(PartitionGraph* graph)
                 // ConfigLink* theLink = (*linkItr);
                 PartitionLink& theLink = linkMap[*linkItr];
                 compConnectMap->insert(
-                    std::pair<ComponentId_t, SimTime_t>(theLink.component[1], theLink.getMinLatency()));
+                    std::pair<ComponentId_t, SimTime_t>(theLink.component_[1], theLink.getMinLatency()));
             }
         }
 

src/sst/core/link.cc

@@ -80,7 +80,7 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer
     // Need a pointer to my simulation object
     Simulation_impl* sim = Simulation_impl::getSimulation();
 
-    // In order to uniquely identify links on restart, we need to
+    // For restarts that use the same parallelism, we need to
     // track the rank of the link and its pair link.  For regular
     // links, they are the same, but for sync link pairs, the pair
     // link will be on a different rank.  For self links, this
@@ -109,55 +109,24 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer
 
         SST_SER(type);
 
-        /*
-          Unique Identifiers
-
-          For non-selflinks, we need to be able to create a unique
-          identifier so we can connect the pairs on restart.  The
-          unique identifiers are created using the MPI rank and point
-          of the link cast as a uintptr_t.
-
-          For regular links, we only store the rank once since both
-          links in the pair are on the same rank.
-
-          For SYNC links, the local link only knows the remote link by
-          it's pair link, so we will use that pointer for the unique
-          ID.
-
-          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);
 
-            uintptr_t ptr;
-            if ( type == SYNC )
-                ptr = reinterpret_cast<uintptr_t>(s->pair_link);
-            else
-                ptr = reinterpret_cast<uintptr_t>(s);
-
-            SST_SER(ptr);
-
             if ( type == SYNC ) {
-                // The unique ID for the remote links is constructed from
-                // the rank of the remote pair link and its pointer on
-                // that rank.  The remote pointer is stored in
-                // delivery_info and we can get the remote rank from the
-                // sync queue.
+                // Get rank for pair
                 SyncQueue* q = dynamic_cast<SyncQueue*>(s->send_queue);
                 pair_rank    = q->getToRank();
                 SST_SER(pair_rank);
-                SST_SER(s->delivery_info);
-            }
-            else {
-                // Unique ID for my pair link is my rank and pair_link
-                // pointer.  Rank is already stored, just store pair
-                // pointer
-                uintptr_t pair_ptr = reinterpret_cast<uintptr_t>(s->pair_link);
-                SST_SER(pair_ptr);
             }
         } // 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 +186,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);
+                }
             }
         }
 
@@ -265,35 +241,28 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer
         */
         bool is_orig_sync = (type == 3);
 
-        /*
-          Unique identifiers
-
-          Get the ranks and tags for this link and its pair link
-        */
         RankInfo my_restart_rank   = sim->getRank();
         RankInfo pair_restart_rank = my_restart_rank;
 
-        uintptr_t my_tag;
-        uintptr_t pair_tag;
 
         if ( type == SYNC || type == REG ) {
             SST_SER(my_rank);
-            SST_SER(my_tag);
 
             if ( type == SYNC )
                 SST_SER(pair_rank);
             else
                 pair_rank = my_rank;
-
-            SST_SER(pair_tag);
         }
 
 
+        LinkId_t link_id;
+        SST_SER(link_id);
+
         /*
           Determine current sync state
         */
         if ( type != SELF ) {
-            pair_restart_rank = sim->getRankForLinkOnRestart(pair_rank, pair_tag);
+            pair_restart_rank = sim->getRankForLinkOnRestart(pair_rank, link_id);
 
             // If pair_restart_rank.rank == UNASSIGNED, then we have
             // the same paritioning as the checkpoint and the ranks
@@ -303,6 +272,7 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer
 
         bool is_restart_sync = (my_restart_rank != pair_restart_rank);
 
+
         /*
           Create or get link from tracker
 
@@ -315,14 +285,12 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer
             ser.unpacker().report_new_pointer(reinterpret_cast<uintptr_t>(s));
         }
         else {
-            auto&                     link_tracker   = sim->link_restart_tracking;
-            std::pair<int, uintptr_t> my_unique_id   = std::make_pair(my_rank.rank, my_tag);
-            std::pair<int, uintptr_t> pair_unique_id = std::make_pair(pair_rank.rank, pair_tag);
+            auto& link_tracker = sim->link_restart_tracking;
 
-            if ( !is_restart_sync && link_tracker.count(my_unique_id) ) {
+            if ( !is_restart_sync && link_tracker.count(link_id) ) {
                 // Get my link and erase it from the map
-                s = link_tracker[my_unique_id];
-                link_tracker.erase(my_unique_id);
+                s = link_tracker[link_id];
+                link_tracker.erase(link_id);
             }
             else {
                 // Create a link pair and set s to the left link
@@ -335,10 +303,12 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer
                 s->pair_link->setLatency(0);
 
                 // Put my pair link in the tracking map
-                link_tracker[pair_unique_id] = s->pair_link;
+                link_tracker[link_id] = s->pair_link;
             }
         }
 
+        s->id = link_id;
+
         /*
           Get the metadata for the link
         */
@@ -401,13 +371,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 +394,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
@@ -440,17 +415,15 @@ SST::Core::Serialization::serialize_impl<Link*>::operator()(Link*& s, serializer
             s->pair_link->tag  = s->tag;
 
             s->pair_link->defaultTimeBase = 1;
+            s->pair_link->id              = s->getId();
 
-            // Need to register with the SyncManager, but first
-            // need to create a unique name
-            std::string    uname = s->createUniqueGlobalLinkName(my_rank, my_tag, pair_rank, pair_tag);
-            ActivityQueue* sync_q =
-                sim->syncManager->registerLink(pair_restart_rank, my_restart_rank, uname, s->pair_link);
-            s->send_queue = sync_q;
+            // Need to register with the SyncManager
+            ActivityQueue* sync_q = sim->syncManager->registerLink(pair_restart_rank, my_restart_rank, s->pair_link);
+            s->send_queue         = sync_q;
         }
     } break;
     case serializer::MAP:
-        // TODO: Implement Link mapping mode
+        // No current plans to make Links mappable
         break;
     }
 }
@@ -477,7 +450,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 +459,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 +472,7 @@ Link::Link() :
     current_time(Simulation_impl::getSimulation()->currentSimCycle),
     type(UNINITIALIZED),
     mode(INIT),
-    tag(type_max<uint32_t>),
-    attached_tools(nullptr)
+    tag(bit_util::type_max<uint32_t>)
 {}
 
 Link::~Link()
@@ -514,7 +486,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 +655,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 +813,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;