Abstracted the profiling points for events and clocks so that they no…

…w consist of AttachPoints and a base profiling class. Tools now use multiple inheritance to get the AttachPoints and tool type base class they need. This was done in preparation for using those AttachPoints in other types of tools. Also added a profiling testsuite to the core testing; profiling testing is not yet comprehensive.

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 noticably 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 a 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)]);
 }