Merge pull request #1189 from sstsimulator/devel

Automatically Merged using SST Master Branch Merger

Author: sst-autotester

src/sst/core/Makefile.am

@@ -216,7 +216,6 @@ sst_core_sources = \
 	unitAlgebra.cc \
 	module.cc \
 	realtime.cc \
-	ssthandler.cc \
 	sstpart.cc \
 	timeVortex.cc \
 	serialization/objectMap.cc \

src/sst/core/baseComponent.cc

@@ -129,7 +129,7 @@ BaseComponent::registerClock_impl(TimeConverter* tc, Clock::HandlerBase* handler
     for ( auto* tool : tools ) {
         ClockHandlerMetaData mdata(my_info->getID(), getName(), getType());
         // Add the receive profiler to the handler
-        handler->addProfileTool(tool, mdata);
+        handler->attachTool(tool, mdata);
     }
 
     // if regAll is true set tc as the default for the component and
@@ -295,10 +295,10 @@ BaseComponent::configureLink(const std::string& name, TimeConverter* time_base,
                 EventHandlerMetaData mdata(my_info->getID(), getName(), getType(), name);
 
                 // Add the receive profiler to the handler
-                if ( tool->profileReceives() ) handler->addProfileTool(tool, mdata);
+                if ( tool->profileReceives() ) handler->attachTool(tool, mdata);
 
                 // Add the send profiler to the link
-                if ( tool->profileSends() ) tmp->addProfileTool(tool, mdata);
+                if ( tool->profileSends() ) tmp->attachTool(tool, mdata);
             }
         }
         if ( nullptr != time_base )

src/sst/core/clock.h

@@ -120,7 +120,7 @@ class Clock : public Action
 };
 
 
-class ClockHandlerMetaData : public HandlerMetaData
+class ClockHandlerMetaData : public AttachPointMetaData
 {
 public:
     const ComponentId_t comp_id;

src/sst/core/event.h

@@ -217,7 +217,7 @@ class EmptyEvent : public Event
     ImplementSerializable(SST::EmptyEvent)
 };
 
-class EventHandlerMetaData : public HandlerMetaData
+class EventHandlerMetaData : public AttachPointMetaData
 {
 public:
     const ComponentId_t comp_id;

src/sst/core/link.cc

@@ -461,28 +461,6 @@ class NullEvent : public Event
 };
 
 
-class LinkSendProfileToolList
-{
-public:
-    LinkSendProfileToolList() {}
-
-    inline void eventSent(Event* ev)
-    {
-        for ( auto& x : tools ) {
-            x.first->eventSent(x.second, ev);
-        }
-    }
-
-    void addProfileTool(SST::Profile::EventHandlerProfileTool* tool, const EventHandlerMetaData& mdata)
-    {
-        auto key = tool->registerHandler(mdata);
-        tools.push_back(std::make_pair(tool, key));
-    }
-
-private:
-    std::vector<std::pair<SST::Profile::EventHandlerProfileTool*, uintptr_t>> tools;
-};
-
 Link::Link(LinkId_t tag) :
     send_queue(nullptr),
     delivery_info(0),
@@ -631,7 +609,7 @@ Link::replaceFunctor(Event::HandlerBase* functor)
     type = HANDLER;
     if ( pair_link->delivery_info ) {
         auto* handler = reinterpret_cast<Event::HandlerBase*>(pair_link->delivery_info);
-        functor->transferProfilingInfo(handler);
+        functor->transferAttachedToolInfo(handler);
         delete handler;
     }
     pair_link->delivery_info = reinterpret_cast<uintptr_t>(functor);
@@ -663,7 +641,13 @@ Link::send_impl(SimTime_t delay, Event* event)
     event->addRecvComponent(pair_link->comp, pair_link->ctype, pair_link->port);
 #endif
 
-    if ( profile_tools ) profile_tools->eventSent(event);
+    if ( profile_tools ) {
+        for ( auto& x : *profile_tools ) {
+            x.first->eventSent(x.second, event);
+            // Check to see if the event was deleted.  If so, return.
+            if ( nullptr == event ) return;
+        }
+    }
     send_queue->insert(event);
 }
 
@@ -803,10 +787,11 @@ Link::createUniqueGlobalLinkName(RankInfo local_rank, uintptr_t local_ptr, RankI
 }
 
 void
-Link::addProfileTool(SST::Profile::EventHandlerProfileTool* tool, const EventHandlerMetaData& mdata)
+Link::attachTool(AttachPoint* tool, const AttachPointMetaData& mdata)
 {
-    if ( !profile_tools ) profile_tools = new LinkSendProfileToolList();
-    profile_tools->addProfileTool(tool, mdata);
+    if ( !profile_tools ) profile_tools = new ToolList();
+    auto key = tool->registerLinkAttachTool(mdata);
+    profile_tools->push_back(std::make_pair(tool, key));
 }
 
 

src/sst/core/link.h

@@ -28,7 +28,6 @@ class LinkPair;
 class Simulation_impl;
 
 class UnitAlgebra;
-class LinkSendProfileToolList;
 
 namespace Profile {
 class EventHandlerProfileTool;
@@ -56,6 +55,43 @@ class alignas(64) Link
     friend class SST::Core::Serialization::serialize_impl<Link*>;
 
 public:
+    /**
+       Attach point for inspecting, modifying or dropping events
+       sent on the Link.
+
+       NOTE: Using the Link::AttachPoint will noticeably affect the
+       performance of sending events on Links and it is recommended
+       that, if possible, Event::HandlerBase::AttachPoint or
+       Event::HandlerBase::InterceptPoint be used instead.
+     */
+    class AttachPoint
+    {
+    public:
+        /**
+           Function that will be called when an attach point is
+           registered with the tool implementing the attach point.
+           The metadata passed in will be dependent on what type of
+           tool this is attached to.  The uintptr_t returned from this
+           function will be passed into the eventSent() function.
+
+           @param mdata Metadata to be passed into the tool
+
+           @return Opaque key that will be passed back into
+           eventSent() to identify the source of the call
+         */
+        virtual uintptr_t registerLinkAttachTool(const AttachPointMetaData& mdata) = 0;
+
+        /**
+           Function that will be called when an event is sent on a
+           link with registered attach points.  If ev is set to
+           nullptr, then the event will not be delivered and the tool
+           should delete the original event.
+
+           @param key Opaque key returned from registerLinkAttachTool()
+         */
+        virtual void eventSent(uintptr_t key, Event*& ev) = 0;
+    };
+
     friend class LinkPair;
     friend class RankSync;
     friend class ThreadSync;
@@ -285,10 +321,11 @@ class alignas(64) Link
     createUniqueGlobalLinkName(RankInfo local_rank, uintptr_t local_ptr, RankInfo remote_rank, uintptr_t remote_ptr);
 
 
-    void addProfileTool(SST::Profile::EventHandlerProfileTool* tool, const EventHandlerMetaData& mdata);
+    void attachTool(AttachPoint* tool, const AttachPointMetaData& mdata);
 
 
-    LinkSendProfileToolList* profile_tools;
+    using ToolList = std::vector<std::pair<AttachPoint*, uintptr_t>>;
+    ToolList* profile_tools;
 
 
 #ifdef __SST_DEBUG_EVENT_TRACKING__

src/sst/core/profile/clockHandlerProfileTool.cc

@@ -23,7 +23,7 @@ namespace SST {
 namespace Profile {
 
 
-ClockHandlerProfileTool::ClockHandlerProfileTool(const std::string& name, Params& params) : HandlerProfileToolAPI(name)
+ClockHandlerProfileTool::ClockHandlerProfileTool(const std::string& name, Params& params) : ProfileTool(name)
 {
     std::string level = params.find<std::string>("level", "type");
     if ( level == "global" )
@@ -41,7 +41,7 @@ ClockHandlerProfileTool::ClockHandlerProfileTool(const std::string& name, Params
 }
 
 std::string
-ClockHandlerProfileTool::getKeyForHandler(const HandlerMetaData& mdata)
+ClockHandlerProfileTool::getKeyForHandler(const AttachPointMetaData& mdata)
 {
     const ClockHandlerMetaData& data = dynamic_cast<const ClockHandlerMetaData&>(mdata);
 
@@ -71,13 +71,13 @@ ClockHandlerProfileToolCount::ClockHandlerProfileToolCount(const std::string& na
 {}
 
 uintptr_t
-ClockHandlerProfileToolCount::registerHandler(const HandlerMetaData& mdata)
+ClockHandlerProfileToolCount::registerHandler(const AttachPointMetaData& mdata)
 {
     return reinterpret_cast<uintptr_t>(&counts_[getKeyForHandler(mdata)]);
 }
 
 void
-ClockHandlerProfileToolCount::handlerStart(uintptr_t key)
+ClockHandlerProfileToolCount::beforeHandler(uintptr_t key, const Cycle_t& UNUSED(cycle))
 {
     (*reinterpret_cast<uint64_t*>(key))++;
 }
@@ -101,7 +101,7 @@ ClockHandlerProfileToolTime<T>::ClockHandlerProfileToolTime(const std::string& n
 
 template <typename T>
 uintptr_t
-ClockHandlerProfileToolTime<T>::registerHandler(const HandlerMetaData& mdata)
+ClockHandlerProfileToolTime<T>::registerHandler(const AttachPointMetaData& mdata)
 {
     return reinterpret_cast<uintptr_t>(&times_[getKeyForHandler(mdata)]);
 }

src/sst/core/profile/clockHandlerProfileTool.h

@@ -26,10 +26,10 @@ namespace SST {
 namespace Profile {
 
 
-class ClockHandlerProfileTool : public HandlerProfileToolAPI
+class ClockHandlerProfileTool : public ProfileTool, public Clock::HandlerBase::AttachPoint
 {
 public:
-    SST_ELI_REGISTER_PROFILETOOL_DERIVED_API(SST::Profile::ClockHandlerProfileTool, SST::HandlerProfileToolAPI, Params&)
+    SST_ELI_REGISTER_PROFILETOOL_DERIVED_API(SST::Profile::ClockHandlerProfileTool, SST::Profile::ProfileTool, Params&)
 
     SST_ELI_DOCUMENT_PARAMS(
         { "level", "Level at which to track profile (global, type, component, subcomponent)", "type" },
@@ -39,8 +39,13 @@ class ClockHandlerProfileTool : public HandlerProfileToolAPI
 
     ClockHandlerProfileTool(const std::string& name, Params& params);
 
+    // Default implementations of attach point functions for profile
+    // tools that don't use them
+    void beforeHandler(uintptr_t UNUSED(key), const Cycle_t& UNUSED(cycle)) override {}
+    void afterHandler(uintptr_t UNUSED(key), const bool& UNUSED(remove)) override {}
+
 protected:
-    std::string getKeyForHandler(const HandlerMetaData& mdata);
+    std::string getKeyForHandler(const AttachPointMetaData& mdata);
 
     Profile_Level profile_level_;
 };
@@ -66,9 +71,9 @@ class ClockHandlerProfileToolCount : public ClockHandlerProfileTool
 
     virtual ~ClockHandlerProfileToolCount() {}
 
-    uintptr_t registerHandler(const HandlerMetaData& mdata) override;
+    uintptr_t registerHandler(const AttachPointMetaData& mdata) override;
 
-    void handlerStart(uintptr_t key) override;
+    void beforeHandler(uintptr_t key, const Cycle_t& cycle) override;
 
     void outputData(FILE* fp) override;
 
@@ -96,11 +101,11 @@ class ClockHandlerProfileToolTime : public ClockHandlerProfileTool
 
     virtual ~ClockHandlerProfileToolTime() {}
 
-    uintptr_t registerHandler(const HandlerMetaData& mdata) override;
+    uintptr_t registerHandler(const AttachPointMetaData& mdata) override;
 
-    void handlerStart(uintptr_t UNUSED(key)) override { start_time_ = T::now(); }
+    void beforeHandler(uintptr_t UNUSED(key), const Cycle_t& UNUSED(cycle)) override { start_time_ = T::now(); }
 
-    void handlerEnd(uintptr_t key) override
+    void afterHandler(uintptr_t key, const bool& UNUSED(remove)) override
     {
         auto          total_time = T::now() - start_time_;
         clock_data_t* entry      = reinterpret_cast<clock_data_t*>(key);

src/sst/core/profile/eventHandlerProfileTool.cc

@@ -23,7 +23,7 @@ namespace SST {
 namespace Profile {
 
 
-EventHandlerProfileTool::EventHandlerProfileTool(const std::string& name, Params& params) : HandlerProfileToolAPI(name)
+EventHandlerProfileTool::EventHandlerProfileTool(const std::string& name, Params& params) : ProfileTool(name)
 {
     std::string level = params.find<std::string>("level", "type");
     if ( level == "global" )
@@ -46,7 +46,7 @@ EventHandlerProfileTool::EventHandlerProfileTool(const std::string& name, Params
 }
 
 std::string
-EventHandlerProfileTool::getKeyForHandler(const HandlerMetaData& mdata)
+EventHandlerProfileTool::getKeyForHandler(const AttachPointMetaData& mdata)
 {
     const EventHandlerMetaData& data = dynamic_cast<const EventHandlerMetaData&>(mdata);
 
@@ -78,19 +78,25 @@ EventHandlerProfileToolCount::EventHandlerProfileToolCount(const std::string& na
 {}
 
 uintptr_t
-EventHandlerProfileToolCount::registerHandler(const HandlerMetaData& mdata)
+EventHandlerProfileToolCount::registerHandler(const AttachPointMetaData& mdata)
+{
+    return reinterpret_cast<uintptr_t>(&counts_[getKeyForHandler(mdata)]);
+}
+
+uintptr_t
+EventHandlerProfileToolCount::registerLinkAttachTool(const AttachPointMetaData& mdata)
 {
     return reinterpret_cast<uintptr_t>(&counts_[getKeyForHandler(mdata)]);
 }
 
 void
-EventHandlerProfileToolCount::handlerStart(uintptr_t key)
+EventHandlerProfileToolCount::beforeHandler(uintptr_t key, const Event* UNUSED(event))
 {
     reinterpret_cast<event_data_t*>(key)->recv_count++;
 }
 
 void
-EventHandlerProfileToolCount::eventSent(uintptr_t key, Event* UNUSED(ev))
+EventHandlerProfileToolCount::eventSent(uintptr_t key, Event*& UNUSED(ev))
 {
     reinterpret_cast<event_data_t*>(key)->send_count++;
 }
@@ -120,7 +126,14 @@ EventHandlerProfileToolTime<T>::EventHandlerProfileToolTime(const std::string& n
 
 template <typename T>
 uintptr_t
-EventHandlerProfileToolTime<T>::registerHandler(const HandlerMetaData& mdata)
+EventHandlerProfileToolTime<T>::registerHandler(const AttachPointMetaData& mdata)
+{
+    return reinterpret_cast<uintptr_t>(&times_[getKeyForHandler(mdata)]);
+}
+
+template <typename T>
+uintptr_t
+EventHandlerProfileToolTime<T>::registerLinkAttachTool(const AttachPointMetaData& mdata)
 {
     return reinterpret_cast<uintptr_t>(&times_[getKeyForHandler(mdata)]);
 }