Add watchpoint action class and add set var val action

Author: skuntz

src/sst/core/serialization/objectMap.h

@@ -134,11 +134,6 @@ class ObjectMapComparison
     virtual void        print()           = 0;
     std::string         getName() { return name_; }
 
-#if 0
-    void *              getVar() { 
-        if ( obj_ != nullptr && obj_->isFundamental() ) 
-            return nullptr; //obj_->getAddr(); }
-#endif
     virtual void* getVar() = 0;
 
 protected:
@@ -206,7 +201,7 @@ class ObjectMap
        Function that will get called when this object is deactivated
        (i.e selectParent() is called)
      */
-    virtual void deactivate_callback() {}
+    virtual void deactivate_callback() {} 
 
 private:
     /**
@@ -242,6 +237,13 @@ class ObjectMap
      */
     void setReadOnly(bool state = true) { read_only_ = state; }
 
+    /**
+     Check if value string is valid for this type
+
+     @param value Value to set the object to expressed as a string
+   */
+    virtual bool checkValue(const std::string& UNUSED(value)) { return false; }
+
 
     /**
        Get the name of the variable represented by this ObjectMap.  If
@@ -326,12 +328,6 @@ class ObjectMap
     {
         return nullptr;
     }
-#if 0
-    virtual TraceBuffer* getTraceBuffer(ObjectMap* UNUSED(obj), size_t UNUSED(sz), size_t UNUSED(pdelay)) // Add name
-    {
-        return nullptr;
-    }
-#endif
 
     virtual ObjectBuffer* getObjectBuffer(const std::string& UNUSED(name), size_t UNUSED(sz)) { return nullptr; }
 
@@ -1089,6 +1085,24 @@ class ObjectMapFundamental : public ObjectMap
      */
     virtual void set_impl(const std::string& value) override { *addr_ = SST::Core::from_string<T>(value); }
 
+    virtual bool checkValue(const std::string& value) override {
+        bool ret = false;
+        try {
+            T v = SST::Core::from_string<T>(value);
+            ret = static_cast<bool>(v);
+        }
+        catch (const std::invalid_argument& e) {
+            std::cerr << "Error: Invalid value: " << value << std::endl;
+            return false;
+        }
+        catch (const std::out_of_range& e) {
+            std::cerr << "Error: Value is out of range: " << value << std::endl;
+            return false;
+        }
+        ret = true;
+        return ret;
+    }
+
     /**
        Get the value of the object as a string
      */
@@ -1141,13 +1155,6 @@ class ObjectMapFundamental : public ObjectMap
     {
         return new ObjectMapComparison_impl<T>(name, addr_, op, value);
     }
-#if 0
-    TraceBuffer* getTraceBuffer(ObjectMap* obj, size_t sz, size_t pdelay) override // Add name
-    {
-
-        return new TraceBuffer(obj, sz, pdelay);
-    }
-#endif
 
     ObjectBuffer* getObjectBuffer(const std::string& name, size_t sz) override
     {

src/sst/core/watchPoint.h

@@ -71,13 +71,13 @@ class WatchPoint : public Clock::HandlerBase::AttachPoint, public Event::Handler
                 trigger          = false;
                 if ( invoke ) {
                     setBufferReset();
-                    invokeAction();
+                    wpAction->invokeAction(this);
                 }
             }
             else {
                 printf("    No trace buffer\n");
                 if ( trigger ) {
-                    invokeAction();
+                    wpAction->invokeAction(this);
                 }
             }
         } // if AFTER_EVENT
@@ -100,13 +100,13 @@ class WatchPoint : public Clock::HandlerBase::AttachPoint, public Event::Handler
                 trigger          = false;
                 if ( invoke ) {
                     setBufferReset();
-                    invokeAction();
+                    wpAction->invokeAction(this);
                 }
             }
             else {
                 printf("    No trace buffer\n");
                 if ( trigger ) {
-                    invokeAction();
+                    wpAction->invokeAction(this);
                 }
             }
         } // if AFTER_EVENT
@@ -129,13 +129,13 @@ class WatchPoint : public Clock::HandlerBase::AttachPoint, public Event::Handler
                 trigger          = false;
                 if ( invoke ) {
                     setBufferReset();
-                    invokeAction();
+                    wpAction->invokeAction(this);
                 }
             }
             else {
                 printf("    No trace buffer\n");
                 if ( trigger ) {
-                    invokeAction();
+                    wpAction->invokeAction(this);
                 }
             }
         } // if AFTER_CLOCK
@@ -157,13 +157,13 @@ class WatchPoint : public Clock::HandlerBase::AttachPoint, public Event::Handler
                 trigger          = false;
                 if ( invoke ) {
                     setBufferReset();
-                    invokeAction();
+                    wpAction->invokeAction(this);
                 }
             }
             else {
                 printf("    No trace buffer\n");
                 if ( trigger ) {
-                    invokeAction();
+                    wpAction->invokeAction(this);
                 }
             }
         } // if AFTER_CLOCK
@@ -241,38 +241,108 @@ class WatchPoint : public Clock::HandlerBase::AttachPoint, public Event::Handler
         }
     }
 
+    bool checkReset() { return reset_; }
 
-    enum WPACTION : unsigned { // Watchpoint Action
-        INTERACTIVE  = 0,
-        PRINT_TRACE  = 1,
-        CHECKPOINT   = 2,
-        PRINT_STATUS = 3,
-        HEARTBEAT    = 4,
-        INVALID      = 5
+    class WPAction
+    {
+    public:
+        WPAction() {}
+        virtual ~WPAction() = default;
+
+        virtual std::string actionToString() = 0;
+        virtual void invokeAction(WatchPoint* wp) = 0;
     };
 
-    std::string actionToString(WPACTION wpa)
-    {
+    class InteractiveWPAction : public WPAction {
+    public:
+        InteractiveWPAction() {}
+        virtual ~InteractiveWPAction() = default;
+
+        std::string actionToString() override { return "interactive"; }
 
-        switch ( wpa ) {
-        case INTERACTIVE:
-            return "interactive";
-        case PRINT_TRACE:
-            return "printTrace";
-        case CHECKPOINT:
-            return "checkpoint";
-        case HEARTBEAT:
-            return "heartbeat";
-        case INVALID:
-            return "invalid action";
-        default:
-            return "undefined action";
+        void invokeAction(WatchPoint* wp) override {
+            printf("    SetInteractive\n");
+            wp->setEnterInteractive(); // Trigger action
+            wp->setInteractiveMsg(format_string("Watch point %s buffer", wp->name_.c_str()));
+            // Note that the interactive action is delayed and
+            // we want to be able to print the Trace Buffer there.
+            // So, resetTraceBuffer for this case is in handlers
         }
-    }
+    };
 
-    void setAction(WPACTION actionType) { wpAction = actionType; }
+    class PrintTraceWPAction : public WPAction {
+    public:
+        PrintTraceWPAction() {}
+        virtual ~PrintTraceWPAction() = default;
+
+        std::string actionToString() override { return "printTrace"; }
+
+        void invokeAction(WatchPoint* wp) override {
+            wp->printTrace();
+            if (wp->checkReset()) wp->resetTraceBuffer();
+        }
+    };
+
+    class CheckpointWPAction : public WPAction {
+    public:
+        CheckpointWPAction() {}
+        virtual ~CheckpointWPAction() = default;
+
+        std::string actionToString() override { return "checkpoint"; }
+
+        void invokeAction(WatchPoint* wp) override {
+            wp->setCheckpoint();
+            if (wp->checkReset()) wp->resetTraceBuffer();
+        }
+    };
+
+    class PrintStatusWPAction : public WPAction {
+    public:
+        PrintStatusWPAction() {}
+        virtual ~PrintStatusWPAction() = default;
 
-    void printAction() { std::cout << actionToString(wpAction); }
+        std::string actionToString() override { return "printStatus"; }
+
+        void invokeAction(WatchPoint* wp) override {
+            wp->printStatus();
+            if (wp->checkReset()) wp->resetTraceBuffer();
+        }
+    };
+
+    class SetVarWPAction : public WPAction {
+    public:
+        SetVarWPAction(std::string vname, Core::Serialization::ObjectMap* obj, std::string tval):
+        name_(vname),
+        obj_(obj),
+        valStr_(tval)
+        {}
+
+        virtual ~SetVarWPAction() = default;
+
+        std::string actionToString() override { 
+            return "set " + name_ + " " + valStr_; }
+
+        void invokeAction(WatchPoint* wp) override {
+            try {
+                obj_->set(valStr_);
+            }
+            catch (std::exception& e) {
+                printf("Invalid set var: %s\n", valStr_.c_str());
+                return;
+            }
+
+            if (wp->checkReset()) wp->resetTraceBuffer();
+        }
+
+    private:
+        std::string name_ = "";
+        Core::Serialization::ObjectMap* obj_ = nullptr;
+        std::string valStr_ = "";
+    };
+    
+    void setAction(WPAction* action) { wpAction = action; }
+
+    void printAction() { std::cout << wpAction->actionToString(); }
 
     void addTraceBuffer(Core::Serialization::TraceBuffer* tb) { tb_ = tb; }
 
@@ -313,7 +383,7 @@ class WatchPoint : public Clock::HandlerBase::AttachPoint, public Event::Handler
     unsigned handler  = ALL;
     bool     trigger  = false;
     bool     reset_   = false;
-    WPACTION wpAction = INTERACTIVE;
+    WPAction* wpAction;
 
     void setBufferReset()
     {
@@ -324,38 +394,6 @@ class WatchPoint : public Clock::HandlerBase::AttachPoint, public Event::Handler
         }
     }
 
-    void invokeAction()
-    {
-        switch ( wpAction ) {
-        case INTERACTIVE:
-            printf("    SetInteractive\n");
-            setEnterInteractive(); // Trigger action
-            setInteractiveMsg(format_string("Watch point %s buffer", name_.c_str()));
-            // Note that the interactive action is delayed and
-            // we want to be able to print the Trace Buffer there.
-            // So, resetTraceBuffer for this case is in handlers
-            break;
-        case PRINT_TRACE:
-            tb_->dumpTraceBufferT();
-            if ( reset_ ) resetTraceBuffer();
-            break;
-        case CHECKPOINT:
-            setCheckpoint();
-            if ( reset_ ) resetTraceBuffer();
-            break;
-        case PRINT_STATUS:
-            printStatus();
-            if ( reset_ ) resetTraceBuffer();
-            break;
-        case HEARTBEAT:
-            heartbeat();
-            if ( reset_ ) resetTraceBuffer();
-            break;
-        default:
-            printf("ERROR: invalid watchpoint action\n");
-        }
-    }
-
     void check()
     {
         bool result = false;