WIP

skuntz · skuntz · commit 0134bd96a5eb · 2026-01-15T14:39:34.000-06:00
diff --git a/src/sst/core/impl/interactive/simpleDebug.cc b/src/sst/core/impl/interactive/simpleDebug.cc
@@ -38,6 +38,10 @@ std::string   SimpleDebugger::loggingFilePath = "sst-console.out";
 std::string   SimpleDebugger::replayFilePath  = "sst-console.in";
 bool          SimpleDebugger::enLogging       = false;
 bool          SimpleDebugger::confirm         = true;
+ std::atomic<bool> SimpleDebugger::done{ false };
+ std::atomic<unsigned> SimpleDebugger::tid_{ 0 };
+ Core::ThreadSafe::Barrier SimpleDebugger::ic_barrier_;
+
 SimpleDebugger::SimpleDebugger(Params& params) :
     InteractiveConsole()
 {
@@ -209,7 +213,11 @@ SimpleDebugger::SimpleDebugger(Params& params) :
     cmdLineEditor.set_cmd_strings(cmdStrings);
 
     // Callback for directory listing strings
-    cmdLineEditor.set_listing_callback([this](std::list<std::string>& vec) { get_listing_strings(vec); });
+    //cmdLineEditor.set_listing_callback([this](std::list<std::string>& vec) { get_listing_strings(vec); });
+
+    // Thread sync
+    RankInfo num_ranks = getNumRanks();
+    ic_barrier_.resize(num_ranks.thread);
 }
 
 SimpleDebugger::~SimpleDebugger()
@@ -255,10 +263,11 @@ SimpleDebugger::summary()
 int
 SimpleDebugger::execute(const std::string& msg)
 {
-    RankInfo info   = getRank();
+    RankInfo info = getRank();
     RankInfo nRanks = getNumRanks();
+    
     printf("\n---- Rank%d:Thread%d: Entering interactive mode at time %" PRI_SIMTIME " \n", info.rank, info.thread,
-        getCurrentSimCycle());
+            getCurrentSimCycle());
     printf("%s\n", msg.c_str());
 
     // Create a new ObjectMap
@@ -267,47 +276,59 @@ SimpleDebugger::execute(const std::string& msg)
     // Descend into the name_stack
     cd_name_stack();
 
-    done     = false;
+#if 1
+    done.store(false);
+#else
+    done = false;
+#endif
     retState = DONE;
 
     // Select the input source and next command line
-    std::string line;
-    while ( !done ) {
+    //std::string line;
+    static std::string line;
+    bool squashLogging = false;
+    while (!done.load()) {
+
+#if 1
+        //printf("\n---- Rank%d:Thread%d: Enter while loop\n", info.rank, info.thread);
+        if (info.thread == 0) {
+#else
         try {
+#endif
             // User input prompt (except during user command)
-            if ( eStack.size() == 0 ) std::cout << "> " << std::flush;
+            if (eStack.size() == 0) std::cout << "> " << std::flush;
 
             // Logging disable has edge cases for stack push/pop
-            bool squashLogging = false;
+            squashLogging = false;
 
             // User input prompt
             // std::cout << "R" << info.rank << ":T" << info.thread << "> " << std::flush;
 
-            if ( !injectedCommand.str().empty() ) {
+            if (!injectedCommand.str().empty()) {
                 // Injected commands allow sst command line options to cause actions (currently only replay)
                 line = injectedCommand.str();
                 injectedCommand.str("");
                 std::cout << line << std::endl;
             }
-            else if ( eStack.size() > 0 ) {
+            else if (eStack.size() > 0) {
                 // Do no log internals of user defined command
                 squashLogging = true;
                 // Execute next instruction in a user defined command
-                line          = eState.next();
-                if ( eState.ret() ) {
+                line = eState.next();
+                if (eState.ret()) {
                     eState = eStack.top();
                     eStack.pop();
                     // back to normal command entry
-                    if ( eStack.size() == 0 ) cmdHistoryBuf.enable(true);
+                    if (eStack.size() == 0) cmdHistoryBuf.enable(true);
                 }
             }
-            else if ( replayFile.is_open() ) {
+            else if (replayFile.is_open()) {
                 // Replay commands from file
-                if ( std::getline(replayFile, line) ) {
+                if (std::getline(replayFile, line)) {
                     std::cout << line << std::endl;
                 }
                 else {
-                    if ( replayFile.eof() )
+                    if (replayFile.eof())
                         std::cout << "(Finished reading from " << replayFilePath << ")" << std::endl;
                     else
                         std::cout << "An error occured reading from " << replayFilePath << std::endl;
@@ -316,25 +337,42 @@ SimpleDebugger::execute(const std::string& msg)
             }
             else {
                 // Standard Input
-                if ( !std::cin ) std::cin.clear(); // fix corrupted input after process resumed
+                if (!std::cin) std::cin.clear(); // fix corrupted input after process resumed
                 std::cout.flush();
-                if ( autoCompleteEnable && isatty(STDIN_FILENO) )
+                std::cout.flush();
+                if (autoCompleteEnable && isatty(STDIN_FILENO))
                     cmdLineEditor.getline(cmdHistoryBuf.getBuffer(), line);
                 else
                     std::getline(std::cin, line);
             }
 
+#if 1
+        }
+        ic_barrier_.wait();
+        if (info.thread == tid_.load()) {
+            printf("\n---- Rank%d:Thread%d: Dispatch command: %s\n", 
+                info.rank, info.thread, line.c_str());
+#endif
+
             // We have a constructed command line. Ship it
             dispatch_cmd(line);
-
-            // Log commands if enabled and not executing a user defined command
-            if ( enLogging && !squashLogging ) loggingFile << line.c_str() << std::endl;
-            // This prevents logging the 'logging' command
-            if ( loggingFile.is_open() ) enLogging = true;
+#if 1
+        } // end TID command dispatch
+        ic_barrier_.wait();
+        if (info.thread == 0) {
+#endif
+                // Log commands if enabled and not executing a user defined command
+                if (enLogging && !squashLogging) loggingFile << line.c_str() << std::endl;
+                // This prevents logging the 'logging' command
+                if (loggingFile.is_open()) enLogging = true;
+#if 1 // skk
+        } // end if thread 0
+#else
         }
-        catch ( const std::runtime_error& e ) {
+        catch (const std::runtime_error& e) {
             std::cout << "Parsing error. Ignoring " << line << std::endl;
         }
+#endif
     }
     // Save the position on the name_stack, and clear obj_
     save_name_stack();
@@ -605,7 +643,11 @@ SimpleDebugger::cmd_info(std::vector<std::string>& UNUSED(tokens))
         else {
             // Return to syncmanager to print summary for all threads
             retState = SUMMARY; // summary info
+#if 1
+            done.store(true);
+#else
             done     = true;
+#endif
         }
     }
     else {
@@ -648,10 +690,15 @@ SimpleDebugger::cmd_thread(std::vector<std::string>& tokens)
         return false;
     }
 
-    // If not current thread, set retState and done flag
+    // If not current thread, retState and done flag
     if ( threadID != static_cast<int>(info.thread) ) {
+#if 1
+        tid_.store(threadID);
+        // Leave done as false now, just reset IC tid
+#else
         retState = threadID;
         done     = true;
+#endif
     }
     return true;
 }
@@ -703,6 +750,13 @@ SimpleDebugger::get_listing_strings(std::list<std::string>& list)
         list.emplace_back(s.str());
     }
     list.sort();
+#if 1
+    printf("get listing strings\n");
+    for (auto& x : list) {
+        std::cout << x << " ";
+    }
+    std::cout << std::endl;
+#endif
 }
 
 
@@ -951,8 +1005,11 @@ SimpleDebugger::cmd_run(std::vector<std::string>& tokens)
         printf("Too many arguments for 'run <time>'\n");
         return false;
     }
-
+#if 1
+    done.store(true);
+#else
     done = true;
+#endif
     return true;
 }
 
@@ -1927,7 +1984,11 @@ SimpleDebugger::cmd_exit(std::vector<std::string>& UNUSED(tokens))
     else {
         std::cout << "Exiting ObjectExplorer without clearning watchpoints\n";
     }
+#if 1
+    done.store(true);
+#else
     done = true;
+#endif
     return true;
 }
 
@@ -1937,7 +1998,11 @@ bool
 SimpleDebugger::cmd_shutdown(std::vector<std::string>& UNUSED(tokens))
 {
     simulationShutdown();
+#if 1
+    done.store(true);
+#else
     done = true;
+#endif
     printf("Exiting ObjectExplorer and shutting down simulation\n");
     return true;
 }
@@ -2285,4 +2350,6 @@ CommandRegistry::addHelp(std::string key, std::vector<std::string>& vec)
 }
 
 
+
+
 } // namespace SST::IMPL::Interactive
diff --git a/src/sst/core/impl/interactive/simpleDebug.h b/src/sst/core/impl/interactive/simpleDebug.h
@@ -269,7 +269,8 @@ class SimpleDebugger : public SST::InteractiveConsole
     std::deque<std::string> name_stack;
 
     SST::Core::Serialization::ObjectMap* obj_     = nullptr;
-    bool                                 done     = false;
+    //bool                                 done     = false;
+    static std::atomic<bool>                 done;
     int                                  retState = -1; // -1 DONE, -2 SUMMARY, positive number is threadID
 
     void save_name_stack();
@@ -369,6 +370,11 @@ class SimpleDebugger : public SST::InteractiveConsole
     // Verbosity controlled console printing
     uint32_t verbosity = 0;
     void     msg(VERBOSITY_MASK mask, std::string message);
+
+    // Thread Control // skk
+    static std::atomic<unsigned> tid_;
+    //static std::string line;
+    static Core::ThreadSafe::Barrier ic_barrier_;
 };
 
 } // namespace SST::IMPL::Interactive
diff --git a/src/sst/core/simulation.cc b/src/sst/core/simulation.cc
@@ -337,7 +337,7 @@ Simulation_impl::Simulation_impl(
             new CheckpointAction(&config, my_rank, this, timeLord.getTimeConverter(config.checkpoint_sim_period()));
         checkpoint_action_->insertIntoTimeVortex(this);
     }
-    else {
+    else {  // skk Why do we insert checkpoint action for ALL threads with no time?
         checkpoint_action_ = new CheckpointAction(&config, my_rank, this, nullptr);
         checkpoint_action_->insertIntoTimeVortex(this);
     }
@@ -997,6 +997,11 @@ Simulation_impl::setup_interactive_mode()
 void
 Simulation_impl::run()
 {
+#if 1 //SKK
+
+    sim_output.output("RUN: Rank: %d, Thread: %d\n", my_rank.rank, my_rank.thread);
+
+#endif
 #if SST_PERFORMANCE_INSTRUMENTING
     std::string filename = "rank_" + std::to_string(my_rank.rank);
     filename += "_thread_" + std::to_string(my_rank.thread);
diff --git a/src/sst/core/simulation_impl.h b/src/sst/core/simulation_impl.h
@@ -511,7 +511,7 @@ class Simulation_impl
     clockMap_t              clockMap;
     static Exit*            m_exit;
     SimulatorHeartbeat*     m_heartbeat = nullptr;
-    CheckpointAction*       checkpoint_action_;
+    CheckpointAction*       checkpoint_action_;  // skk all threads share ckpt action?
     static std::string      checkpoint_directory_;
     bool                    endSim = false;
     bool                    independent; // true if no links leave thread (i.e. no syncs required)
@@ -525,7 +525,7 @@ class Simulation_impl
     std::string             interactive_type_  = "";
     std::string             interactive_start_ = "";
     std::string             replay_file_       = "";
-    InteractiveConsole*     interactive_       = nullptr;
+    InteractiveConsole*     interactive_       = nullptr; // skk all threads share IC
     bool                    enter_interactive_ = false;
     std::string             interactive_msg_;
     SimTime_t               stop_at_ = 0;
diff --git a/src/sst/core/sync/syncManager.cc b/src/sst/core/sync/syncManager.cc
@@ -458,9 +458,15 @@ SyncManager::handleInteractiveConsole()
             ic_barrier_.wait();
 #endif
             // 4) Tj: Invoke IC for current thread, with ability to change to new thread
+
+#if 1
+            int result = sim_->interactive_->execute(sim_->interactive_msg_);
+            handleShutdown(); // Check if console issued shutdown command
+#else
             unsigned int tid      = current_ic_thread_.load();
             int          ic_state = 0;
             while ( ic_state != InteractiveConsole::ICretcode::DONE ) {
+                
                 if ( (rank_.thread == tid) && (sim_->interactive_ != nullptr) ) {
                     // Invoke IC for the thread and capture return state
                     int result = sim_->interactive_->execute(sim_->interactive_msg_);
@@ -474,6 +480,7 @@ SyncManager::handleInteractiveConsole()
                     }
                 }
                 ic_barrier_.wait();
+
                 handleShutdown(); // Check if console issued shutdown command
 
                 tid      = current_ic_thread_.load();
@@ -494,6 +501,7 @@ SyncManager::handleInteractiveConsole()
                     current_ic_state_.store(0);
                 } // if state == SUMMARY, print thread info summary
             }
+#endif
 
             // 5) When done, clear interactive mask and enter interactive flags for next round
             if ( rank_.thread == 0 ) {
