GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r697:2015ea331dc4

Implementation of abort mechanism

perrinel -

r697:2015ea331dc4

parent child

Context file:

r697: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);
            


        

    

      

  

      
          

              

                    
                        
                        note
                    

              
          
          
              
  

  
    
  
  

  

    
        perrinel
    
  

          

          
              Thu, 21 Sep 2017 14:42:16
          


          

              
                
              

          

                    
                    

            
              
              

                
                    Comment #2228
                    
                

                      
                      
                        Edit
                      
                      
                        Delete
                      
              
            

            |
                 
                 

          
      
      
          I can't because I unlock a lockRead and not a lockWrite
+                         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 +27 -21

                  }
              }
-             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"
-                                                  << QThread::currentThread()->objectName() << varRequestId;
+                 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
+                                                   << QThread::currentThread()->objectName() << varRequestId;
                  for (const auto &var : variables) {
                      qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId;
                  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: ")
-                                                                     << 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) {
-                                     emit var->updated();
+                                 }
+                                 //                    if
+                                 //                    (m_VarIdToVarRequestIdQueueMap.count(varIdToVarRequestMapIt->first)
+                                 //                    == 0) {
+                                 emit var->updated();
+                                 //                    }
                              }
                              else {
                                  qCCritical(LOG_VariableController())

General Comments 2

perrinel

|

Pull request updated. Auto status change to "Under Review"

Changed commits:
  * 2 added
  * 0 removed

Changed files:
  * A core/include/Variable/VariableAcquisitionWorker.h
  * M core/include/Data/IDataProvider.h
  * M core/include/Variable/VariableController.h
  * M core/src/Network/NetworkController.cpp
  * M core/src/Variable/VariableAcquisitionWorker.cpp
  * M core/src/Variable/VariableController.cpp
  * M plugins/amda/src/AmdaProvider.cpp

Write
Preview

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

	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