GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r754:2015ea331dc4

Implementation of abort mechanism

perrinel -

r754:2015ea331dc4

parent child

Context file:

r754:2015ea331dc4

core/include/Variable/VariableController.h 0 -4

                   */
                  void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
-                 /**
-                  * @brief abort the variable retrieve data progression
-                  */
-                 void abortProgress(std::shared_ptr<Variable> variable);
                  static AcquisitionZoomType getZoomType(const SqpRange &range, const SqpRange &oldRange);
              signals:

core/src/Variable/VariableAcquisitionWorker.cpp +68 -4

              struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
-                 explicit VariableAcquisitionWorkerPrivate() : m_Lock{QReadWriteLock::Recursive} {}
+                 explicit VariableAcquisitionWorkerPrivate(VariableAcquisitionWorker *parent)
+                         : m_Lock{QReadWriteLock::Recursive}, q{parent}
+                 {
+                 }
                  void lockRead() { m_Lock.lockForRead(); }
                  void lockWrite() { m_Lock.lockForWrite(); }
                  void removeVariableRequest(QUuid vIdentifier);
+                 /// Remove the current request and execute the next one if exist
+                 void updateToNextRequest(QUuid vIdentifier);
                  QMutex m_WorkingMutex;
                  QReadWriteLock m_Lock;
                  std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;
                  std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;
                  std::map<QUuid, std::pair<QUuid, QUuid> > m_VIdentifierToCurrrentAcqIdNextIdPairMap;
+                 VariableAcquisitionWorker *q;
              };
              VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
-                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>()}
+                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>(this)}
              {
              }
              void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
              {
                  // TODO
+                 impl->lockRead();
+                 auto it = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
+                 if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
+                     auto currentAcqId = it->second.first;
+                     auto it = impl->m_AcqIdentifierToAcqRequestMap.find(currentAcqId);
+                     if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
+                         auto request = it->second;
+                         impl->unlock();
+                         // Remove the current request from the worker
+                         impl->lockWrite();
+                         impl->updateToNextRequest(vIdentifier);
+                         impl->unlock();
+                         // notify the request aborting to the provider
+                         request.m_Provider->requestDataAborting(currentAcqId);
+                     }
+                     else {
+                         impl->unlock();
+                         qCWarning(LOG_VariableAcquisitionWorker())
+                             << tr("Impossible to abort an unknown acquisition request") << currentAcqId;
+                     }
+                 }
+                 else {
+                     impl->unlock();
+                 }
              }
              void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
                      }
                  }
                  else {
-                     qCCritical(LOG_VariableAcquisitionWorker())
-                         << tr("Impossible to retrieve AcquisitionRequest for the incoming data");
+                     qCWarning(LOG_VariableAcquisitionWorker())
+                         << tr("Impossible to retrieve AcquisitionRequest for the incoming data.");
                  }
                  impl->unlock();
              }
                  m_VIdentifierToCurrrentAcqIdNextIdPairMap.erase(vIdentifier);
                  unlock();
              }
+             void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::updateToNextRequest(
+                 QUuid vIdentifier)
+             {
+                 auto it = m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
+                 if (it != m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
+                     if (it->second.second.isNull()) {
+                         // There is no next request, we can remove the variable request
+                         removeVariableRequest(vIdentifier);
+                     }
+                     else {
+                         auto acqIdentifierToRemove = it->second.first;
+                         // Move the next request to the current request
+                         it->second.first = it->second.second;
+                         it->second.second = QUuid();
+                         // Remove AcquisitionRequest and results;
+                         m_AcqIdentifierToAcqRequestMap.erase(acqIdentifierToRemove);
+                         m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqIdentifierToRemove);
+                         // Execute the current request
+                         QMetaObject::invokeMethod(q, "onExecuteRequest", Qt::QueuedConnection,
+                                                   Q_ARG(QUuid, it->second.first));
+                     }
+                 }
+                 else {
+                     qCCritical(LOG_VariableAcquisitionWorker())
+                         << tr("Impossible to execute the acquisition on an unfound variable ");
+                 }
+             }

core/src/Variable/VariableController.cpp +24 -18

                  }
              }
-             void VariableController::abortProgress(std::shared_ptr<Variable> variable)
+             {
+             }
              std::shared_ptr<Variable>
              VariableController::createVariable(const QString &name, const QVariantHash &metadata,
                                                 std::shared_ptr<IDataProvider> provider) noexcept
                      auto varRequestId = QUuid::createUuid();
-                     qCInfo(LOG_VariableController()) << "processRequest for" << name << varRequestId;
                      impl->processRequest(newVariable, range, varRequestId);
                      impl->updateVariableRequest(varRequestId);
              void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
              {
-                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
-                                                   << QThread::currentThread()->objectName();
                  auto it = impl->m_VariableToIdentifierMap.find(variable);
                  if (it != impl->m_VariableToIdentifierMap.cend()) {
-                     impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
+                     impl->m_VariableAcquisitionWorker->abortProgressRequested(it->second);
+                     QUuid varRequestId;
+                     auto varIdToVarRequestIdQueueMapIt = impl->m_VarIdToVarRequestIdQueueMap.find(it->second);
+                     if (varIdToVarRequestIdQueueMapIt != impl->m_VarIdToVarRequestIdQueueMap.cend()) {
+                         auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
+                         varRequestId = varRequestIdQueue.front();
+                         impl->cancelVariableRequest(varRequestId);
+                         // Finish the progression for the request
+                         impl->m_VariableModel->setDataProgress(variable, 0.0);
+                     }
+                     else {
+                         qCWarning(LOG_VariableController())
+                             << tr("Aborting progression of inexistant variable request detected !!!")
+                             << QThread::currentThread()->objectName();
+                     }
                  }
                  else {
                      qCWarning(LOG_VariableController())
                  // For the other, we ask the provider to give them.
                  auto varRequestId = QUuid::createUuid();
-                 qCInfo(LOG_VariableController()) << "VariableController::onRequestDataLoading"
+                 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
                                                   << QThread::currentThread()->objectName() << varRequestId;
                  for (const auto &var : variables) {
                  if (!notInCacheRangeList.empty()) {
                      varRequest.m_RangeRequested = varStrategyRangesRequested.first;
                      varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
-                     qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest RR ") << rangeRequested;
-                     qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest R  ")
-                                                              << varStrategyRangesRequested.first;
-                     qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest CR ")
-                                                              << varStrategyRangesRequested.second;
                      // store VarRequest
                      storeVariableRequest(varId, varRequestId, varRequest);
                              varProvider);
                          if (!varRequestIdCanceled.isNull()) {
-                             qCInfo(LOG_VariableAcquisitionWorker()) << tr("varRequestIdCanceled: ")
+                             qCDebug(LOG_VariableAcquisitionWorker()) << tr("varRequestIdCanceled: ")
                                                                      << varRequestIdCanceled;
                              cancelVariableRequest(varRequestIdCanceled);
                          }
                                  /// @todo MPL: confirm
                                  // Variable update is notified only if there is no pending request for it
-                                 if (m_VarIdToVarRequestIdQueueMap.count(varIdToVarRequestMapIt->first) == 0) {
+                                 //                    if
+                                 //                    (m_VarIdToVarRequestIdQueueMap.count(varIdToVarRequestMapIt->first)
+                                 //                    == 0) {
-                                     emit var->updated();
+                                 }
+                                 //                    }
                              }
                              else {
                                  qCCritical(LOG_VariableController())

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages