Tidying

src/Insight/InsightWorker.cpp

@@ -4,7 +4,6 @@
 #include <QObject>
 #include <QTimer>
 
-#include "src/Application.hpp"
 #include "InsightWorker.hpp"
 #include "src/Logger/Logger.hpp"
 #include "src/Helpers/Thread.hpp"
@@ -58,7 +57,30 @@ void InsightWorker::requestPinStateUpdate(
 }
 
 void InsightWorker::onTargetStoppedEvent(EventPointer<TargetExecutionStopped> event) {
-    auto resumedEvent = this->eventListener->waitForEvent<TargetExecutionResumed>(std::chrono::milliseconds(650));
+    /*
+     * When we report a target halt to Insight, Insight will immediately seek more data from the target (such as GPIO
+     * pin states). This can be problematic for cases where the target had halted due to a conditional breakpoint.
+     *
+     * For conditional breakpoints, a software breakpoint is employed to halt target execution and give the debug
+     * client an opportunity to check the condition. In cases where the condition is not met, the client will
+     * immediately request for execution to be resumed. It's important that Insight does not get in the way of this
+     * process, as it could end up slowing things down significantly.
+     *
+     * For the above reason, we don't want to report any target halts to Insight, unless we can be sure that the client
+     * isn't going to immediately resume execution upon checking the condition.
+     *
+     * We do this by providing a time window for the TargetExecutionResumed event. If the event is triggered within
+     * that time window, we won't report the target halt to Insight, thus preventing Insight from needlessly seeking
+     * data from the target and slowing things down.
+     *
+     * This isn't the best approach, TBH, as it introduces a delay to Insight's response to the target halting. The
+     * problem is, we cannot differentiate a conditional breakpoint with a software breakpoint, so this seems to be the
+     * only way. It would be nice if the debug client gave us some form of indication of whether the breakpoint is a
+     * conditional one.
+     */
+    auto resumedEvent = this->eventListener->waitForEvent<TargetExecutionResumed>(
+        std::chrono::milliseconds(650)
+    );
 
     if (!resumedEvent.has_value()) {
         emit this->targetStateUpdated(TargetState::STOPPED);