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

@@ -18,7 +18,10 Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")
18		18
19	struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {	19	struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
20		20
21	explicit VariableAcquisitionWorkerPrivate() : ~~m_Lock~~{~~QReadWriteLock~~::~~Recursive~~} {}	21	explicit VariableAcquisitionWorkerPrivate(VariableAcquisitionWorker *parent)
		22	: m_Lock{QReadWriteLock::Recursive}, q{parent}
		23	{
		24	}
22		25
23	void lockRead() { m_Lock.lockForRead(); }	26	void lockRead() { m_Lock.lockForRead(); }
24	void lockWrite() { m_Lock.lockForWrite(); }	27	void lockWrite() { m_Lock.lockForWrite(); }
@@ -26,17 +29,21 struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
26		29
27	void removeVariableRequest(QUuid vIdentifier);	30	void removeVariableRequest(QUuid vIdentifier);
28		31
		32	/// Remove the current request and execute the next one if exist
		33	void updateToNextRequest(QUuid vIdentifier);
		34
29	QMutex m_WorkingMutex;	35	QMutex m_WorkingMutex;
30	QReadWriteLock m_Lock;	36	QReadWriteLock m_Lock;
31		37
32	std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;	38	std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;
33	std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;	39	std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;
34	std::map<QUuid, std::pair<QUuid, QUuid> > m_VIdentifierToCurrrentAcqIdNextIdPairMap;	40	std::map<QUuid, std::pair<QUuid, QUuid> > m_VIdentifierToCurrrentAcqIdNextIdPairMap;
		41	VariableAcquisitionWorker *q;
35	};	42	};
36		43
37		44
38	VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)	45	VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
39	: QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>()}	46	: QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>(this)}
40	{	47	{
41	}	48	}
42		49
@@ -103,6 +110,35 QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid v
103	void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)	110	void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
104	{	111	{
105	// TODO	112	// TODO
		113	impl->lockRead();
		114
		115	auto it = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
		116	if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
		117	auto currentAcqId = it->second.first;
		118
		119	auto it = impl->m_AcqIdentifierToAcqRequestMap.find(currentAcqId);
		120	if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
		121	auto request = it->second;
		122	impl->unlock();
		123
		124	// Remove the current request from the worker
		125
		126	impl->lockWrite();
		127	impl->updateToNextRequest(vIdentifier);
		128	impl->unlock();
		129
		130	// notify the request aborting to the provider
		131	request.m_Provider->requestDataAborting(currentAcqId);
		132	}
		133	else {
		134	impl->unlock();
		135	qCWarning(LOG_VariableAcquisitionWorker())
		136	<< tr("Impossible to abort an unknown acquisition request") << currentAcqId;
		137	}
		138	}
		139	else {
		140	impl->unlock();
		141	}
106	}	142	}
107		143
108	void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,	144	void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
@@ -196,8 +232,8 void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
196	}	232	}
197	}	233	}
198	else {	234	else {
199	qC~~Critical~~(LOG_VariableAcquisitionWorker())	235	qCWarning(LOG_VariableAcquisitionWorker())
200	<< tr("Impossible to retrieve AcquisitionRequest for the incoming data");	236	<< tr("Impossible to retrieve AcquisitionRequest for the incoming data.");
201	}	237	}
202	impl->unlock();	238	impl->unlock();
203	}	239	}
@@ -255,3 +291,31 void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::removeVariable
255	m_VIdentifierToCurrrentAcqIdNextIdPairMap.erase(vIdentifier);	291	m_VIdentifierToCurrrentAcqIdNextIdPairMap.erase(vIdentifier);
256	unlock();	292	unlock();
257	}	293	}
		294
		295	void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::updateToNextRequest(
		296	QUuid vIdentifier)
		297	{
		298	auto it = m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
		299	if (it != m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
		300	if (it->second.second.isNull()) {
		301	// There is no next request, we can remove the variable request
		302	removeVariableRequest(vIdentifier);
		303	}
		304	else {
		305	auto acqIdentifierToRemove = it->second.first;
		306	// Move the next request to the current request
		307	it->second.first = it->second.second;
		308	it->second.second = QUuid();
		309	// Remove AcquisitionRequest and results;
		310	m_AcqIdentifierToAcqRequestMap.erase(acqIdentifierToRemove);
		311	m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqIdentifierToRemove);
		312	// Execute the current request
		313	QMetaObject::invokeMethod(q, "onExecuteRequest", Qt::QueuedConnection,
		314	Q_ARG(QUuid, it->second.first));
		315	}
		316	}
		317	else {
		318	qCCritical(LOG_VariableAcquisitionWorker())
		319	<< tr("Impossible to execute the acquisition on an unfound variable ");
		320	}
		321	}

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