From b81b51790e0c76d45ad4a57029f6085de13e508e Mon Sep 17 00:00:00 2001 From: Nav Date: Sun, 12 Sep 2021 23:25:34 +0100 Subject: [PATCH] Improved register written event --- src/EventManager/EventManager.cpp | 12 ++++++ src/EventManager/EventManager.hpp | 8 ++++ .../Events/RegistersWrittenToTarget.hpp | 2 +- src/Insight/InsightWorker/InsightWorker.cpp | 2 +- src/Insight/InsightWorker/InsightWorker.hpp | 2 +- .../TargetRegistersPaneWidget.cpp | 26 +----------- .../TargetRegistersPaneWidget.hpp | 1 - src/TargetController/TargetController.cpp | 40 +++++++++++++------ 8 files changed, 51 insertions(+), 42 deletions(-) diff --git a/src/EventManager/EventManager.cpp b/src/EventManager/EventManager.cpp index 09323b9c..2f37377c 100644 --- a/src/EventManager/EventManager.cpp +++ b/src/EventManager/EventManager.cpp @@ -21,3 +21,15 @@ void EventManager::triggerEvent(const std::shared_ptr& even } } } + +bool EventManager::isEventTypeListenedFor(Events::EventType eventType) { + auto registerListenersLock = std::unique_lock(this->registerListenerMutex); + + for(auto const& [listenerId, listener] : this->registeredListeners) { + if (listener->isEventTypeRegistered(eventType)) { + return true; + } + } + + return false; +} diff --git a/src/EventManager/EventManager.hpp b/src/EventManager/EventManager.hpp index 3c18a4dd..a5cc8471 100644 --- a/src/EventManager/EventManager.hpp +++ b/src/EventManager/EventManager.hpp @@ -54,5 +54,13 @@ namespace Bloom * @param event */ void triggerEvent(const Events::SharedGenericEventPointer& event); + + /** + * Checks if any registered listener is listening for a particular event type. + * + * @param eventType + * @return + */ + bool isEventTypeListenedFor(Events::EventType eventType); }; } diff --git a/src/EventManager/Events/RegistersWrittenToTarget.hpp b/src/EventManager/Events/RegistersWrittenToTarget.hpp index b6bbae9a..d8f071db 100644 --- a/src/EventManager/Events/RegistersWrittenToTarget.hpp +++ b/src/EventManager/Events/RegistersWrittenToTarget.hpp @@ -13,7 +13,7 @@ namespace Bloom::Events static inline EventType type = EventType::REGISTERS_WRITTEN_TO_TARGET; static inline const std::string name = "RegistersWrittenToTarget"; - Targets::TargetRegisterDescriptors descriptors; + Targets::TargetRegisters registers; [[nodiscard]] EventType getType() const override { return RegistersWrittenToTarget::type; diff --git a/src/Insight/InsightWorker/InsightWorker.cpp b/src/Insight/InsightWorker/InsightWorker.cpp index b2102a8e..5b447cb4 100644 --- a/src/Insight/InsightWorker/InsightWorker.cpp +++ b/src/Insight/InsightWorker/InsightWorker.cpp @@ -122,7 +122,7 @@ void InsightWorker::onTargetIoPortsUpdatedEvent(const Events::TargetIoPortsUpdat } void InsightWorker::onTargetRegistersWrittenEvent(const Events::RegistersWrittenToTarget& event) { - emit this->targetRegistersWritten(event.descriptors); + emit this->targetRegistersWritten(event.registers); } void InsightWorker::onTargetControllerStateReportedEvent(const Events::TargetControllerStateReported& event) { diff --git a/src/Insight/InsightWorker/InsightWorker.hpp b/src/Insight/InsightWorker/InsightWorker.hpp index 6a01fb5d..99ac7b44 100644 --- a/src/Insight/InsightWorker/InsightWorker.hpp +++ b/src/Insight/InsightWorker/InsightWorker.hpp @@ -66,6 +66,6 @@ namespace Bloom void targetIoPortsUpdated(); void targetControllerSuspended(); void targetControllerResumed(const Bloom::Targets::TargetDescriptor& targetDescriptor); - void targetRegistersWritten(const Bloom::Targets::TargetRegisterDescriptors& descriptors); + void targetRegistersWritten(const Bloom::Targets::TargetRegisters& targetRegisters); }; } diff --git a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegistersPane/TargetRegistersPaneWidget.cpp b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegistersPane/TargetRegistersPaneWidget.cpp index fb96bf15..3665670f 100644 --- a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegistersPane/TargetRegistersPaneWidget.cpp +++ b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegistersPane/TargetRegistersPaneWidget.cpp @@ -117,7 +117,7 @@ TargetRegistersPaneWidget::TargetRegistersPaneWidget( &insightWorker, &InsightWorker::targetRegistersWritten, this, - &TargetRegistersPaneWidget::onRegistersWritten + &TargetRegistersPaneWidget::onRegistersRead ); } @@ -162,30 +162,6 @@ void TargetRegistersPaneWidget::onRegistersRead(const Targets::TargetRegisters& } } -void TargetRegistersPaneWidget::onRegistersWritten(const Bloom::Targets::TargetRegisterDescriptors& descriptors) { - if (this->targetState != Targets::TargetState::STOPPED) { - return; - } - - /* - * Don't bother refreshing individual registers if it will involve more than two refresh calls - In this case, it - * will be faster to just refresh all of them at once. - */ - if (descriptors.size() <= 2) { - for (const auto& descriptor : descriptors) { - for (const auto& registerGroupWidget : this->registerGroupWidgets) { - if (registerGroupWidget->registerWidgetsMappedByDescriptor.contains(descriptor)) { - registerGroupWidget->registerWidgetsMappedByDescriptor.at(descriptor)->refreshValue(); - break; - } - } - } - - } else { - this->refreshRegisterValues(); - } -} - void TargetRegistersPaneWidget::filterRegisters(const QString& keyword) { auto stdKeyword = keyword.toLower().toStdString(); diff --git a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegistersPane/TargetRegistersPaneWidget.hpp b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegistersPane/TargetRegistersPaneWidget.hpp index c72eeea0..63f531f9 100644 --- a/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegistersPane/TargetRegistersPaneWidget.hpp +++ b/src/Insight/UserInterfaces/InsightWindow/Widgets/TargetRegistersPane/TargetRegistersPaneWidget.hpp @@ -45,7 +45,6 @@ namespace Bloom::Widgets private slots: void onTargetStateChanged(Targets::TargetState newState); void onRegistersRead(const Targets::TargetRegisters& registers); - void onRegistersWritten(const Bloom::Targets::TargetRegisterDescriptors& descriptors); protected: void resizeEvent(QResizeEvent* event) override; diff --git a/src/TargetController/TargetController.cpp b/src/TargetController/TargetController.cpp index bed67445..161e6e18 100644 --- a/src/TargetController/TargetController.cpp +++ b/src/TargetController/TargetController.cpp @@ -578,15 +578,7 @@ void TargetController::onWriteRegistersEvent(const Events::WriteRegistersToTarge auto registersWrittenEvent = std::make_shared(); registersWrittenEvent->correlationId = event.id; - - std::transform( - event.registers.begin(), - event.registers.end(), - std::inserter(registersWrittenEvent->descriptors, registersWrittenEvent->descriptors.begin()), - [] (const TargetRegister& targetRegister) { - return targetRegister.descriptor; - } - ); + registersWrittenEvent->registers = event.registers; this->eventManager.triggerEvent(registersWrittenEvent); @@ -612,27 +604,49 @@ void TargetController::onReadMemoryEvent(const Events::RetrieveMemoryFromTarget& void TargetController::onWriteMemoryEvent(const Events::WriteMemoryToTarget& event) { try { + const auto& buffer = event.buffer; + const auto bufferSize = event.buffer.size(); + const auto bufferStartAddress = event.startAddress; + this->target->writeMemory(event.memoryType, event.startAddress, event.buffer); auto memoryWrittenEvent = std::make_shared(); memoryWrittenEvent->correlationId = event.id; this->eventManager.triggerEvent(memoryWrittenEvent); - if (this->registerDescriptorsByMemoryType.contains(event.memoryType)) { + if (this->eventManager.isEventTypeListenedFor(Events::RegistersWrittenToTarget::type) + && this->registerDescriptorsByMemoryType.contains(event.memoryType) + ) { /* * The memory type we just wrote to contains some number of registers - if we've written to any address * that is known to store the value of a register, trigger a RegistersWrittenToTarget event */ + const auto bufferEndAddress = static_cast(bufferStartAddress + (bufferSize - 1)); auto registerDescriptors = this->getRegisterDescriptorsWithinAddressRange( - event.startAddress, - static_cast(event.startAddress + (event.buffer.size() - 1)), + bufferStartAddress, + bufferEndAddress, event.memoryType ); if (!registerDescriptors.empty()) { auto registersWrittenEvent = std::make_shared(); registersWrittenEvent->correlationId = event.id; - registersWrittenEvent->descriptors = registerDescriptors; + + for (const auto& registerDescriptor : registerDescriptors) { + const auto registerSize = registerDescriptor.size; + const auto registerStartAddress = registerDescriptor.startAddress.value(); + const auto registerEndAddress = registerStartAddress + (registerSize - 1); + + if (registerStartAddress < bufferStartAddress || registerEndAddress > bufferEndAddress) { + continue; + } + + const auto bufferBeginIt = buffer.begin() + (registerStartAddress - bufferStartAddress); + registersWrittenEvent->registers.emplace_back(TargetRegister( + registerDescriptor, + TargetMemoryBuffer(bufferBeginIt, bufferBeginIt + registerSize) + )); + } this->eventManager.triggerEvent(registersWrittenEvent); }