GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1391:5fb7ba4d060e

Fix bug in acquisition !. Test fuzzing with 30 var in 8 group

perrinel -

r1391:5fb7ba4d060e feature/Acquisiti...

parent child

Context file:

r1391:5fb7ba4d060e

core/src/Variable/VariableAcquisitionWorker.cpp +2 -20

             void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
                                                                              double progress)
             {
-                qCInfo(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
+                qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
                                                          << QThread::currentThread()->objectName()
                                                          << acqIdentifier << progress;
                 impl->lockRead();
                         = std::isnan(progress) ? 0.0 : (progress * progressPartSize) / 100.0;
                     // We can only give an approximation of the currentProgression since its upgrade is async.
-                    qCInfo(LOG_VariableAcquisitionWorker())
-                        << tr("Progression: ") << aIdToARit->second.m_Progression << aIdToARit->second.m_Size;
                     auto currentProgression = aIdToARit->second.m_Progression;
                     if (currentProgression == aIdToARit->second.m_Size) {
                         currentProgression = aIdToARit->second.m_Size - 1;
                     auto finalProgression = currentAlreadyProgress + currentPartProgress;
                     emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, finalProgression);
-                    qCInfo(LOG_VariableAcquisitionWorker())
-                        << tr("TORM: onVariableRetrieveDataInProgress ")
-                        << QThread::currentThread()->objectName() << aIdToARit->second.m_vIdentifier
-                        << progressPartSize << currentAlreadyProgress << currentPartProgress
-                        << finalProgression;
                     if (finalProgression == 100.0) {
-                        qCInfo(LOG_VariableAcquisitionWorker())
-                            << tr("TORM: onVariableRetrieveDataInProgress : finished : 0.0 ");
                         emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, 0.0);
                     }
                 }
                 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                     auto request = it->second;
                     impl->unlock();
-                    qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
-                                                             << acqIdentifier << request.m_vIdentifier
-                                                             << QThread::currentThread();
                     emit variableCanceledRequested(request.m_vIdentifier);
                 }
                 else {
                     impl->unlock();
-                    // TODO log no acqIdentifier recognized
                 }
             }
                     // Decrement the counter of the request
                     auto &acqRequest = aIdToARit->second;
-                    qCInfo(LOG_VariableAcquisitionWorker()) << tr("TORM: +1 update progresson  ")
-                                                            << acqIdentifier;
                     acqRequest.m_Progression = acqRequest.m_Progression + 1;
                     // if the counter is 0, we can return data then run the next request if it exists and
                 QUuid varRequestId)
             {
                 qCDebug(LOG_VariableAcquisitionWorker())
-                    << "VariableAcquisitionWorkerPrivate::cancelVarRequest 0";
+                    << "VariableAcquisitionWorkerPrivate::cancelVarRequest start";
                 lockRead();
                 // get all AcqIdentifier in link with varRequestId
                 QVector<QUuid> acqIdsToRm;
                 lockWrite();
-                qCDebug(LOG_VariableAcquisitionWorker())
-                    << "VariableAcquisitionWorkerPrivate::updateToNextRequest removeAcqRequest: "
-                    << acqRequestId;
                 m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqRequestId);
                 m_AcqIdentifierToAcqRequestMap.erase(acqRequestId);

core/src/Variable/VariableController.cpp +14 -7

                     }
                     impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
                     for (const auto &var : variables) {
-                        qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId
+                        qCDebug(LOG_VariableController()) << "onRequestDataLoading: for" << varRequestId
                                                           << varIds.size();
                         impl->processRequest(var, range, varRequestId);
                     }
                         for (auto vId : vSyncIds) {
                             varIds.push_back(vId);
                         }
+                        qCDebug(LOG_VariableController()) << "onRequestDataLoading sync: for" << varRequestId
+                                                          << varIds.size();
                         impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
                         for (auto vId : vSyncIds) {
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 bool processVariableUpdate = true;
-                qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
-                                                  << varRequestId << varIds.size();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd) && processVariableUpdate;
                      ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                 }
                 if (processVariableUpdate) {
-                    qCDebug(LOG_VariableController()) << "Final update OK for the var request" << varIds.size();
                     for (auto varIdsIt = varIds.begin(); varIdsIt != varIdsEnd; ++varIdsIt) {
                         auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                         if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                                                                   << var->nbPoints();
                                 emit var->updated();
-                                qCDebug(LOG_VariableController()) << tr("Update OK");
                             }
                             else {
                                 qCCritical(LOG_VariableController())
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
+                // First pass all canUpdate of handler to false
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         auto varHandler = itVarHandler->second.get();
                         varHandler->m_CanUpdate = false;
+                    }
+                }
+                // Second update requests of handler
+                for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
+                    auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
+                    if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
+                        auto varHandler = itVarHandler->second.get();
                         switch (varHandler->m_State) {
                             case VariableRequestHandlerState::OFF: {
             void VariableController::VariableControllerPrivate::executeVarRequest(std::shared_ptr<Variable> var,
                                                                                   VariableRequest &varRequest)
             {
-                qCDebug(LOG_VariableController()) << tr("TORM: executeVarRequest");
                 auto varIdIt = m_VariableToIdentifierMap.find(var);
                 if (varIdIt == m_VariableToIdentifierMap.cend()) {
                     qCWarning(LOG_VariableController()) << tr(
                     }
                 }
                 else {
+                    qCDebug(LOG_VariableController()) << "All already in the cache "
+                                                      << varRequest.m_RangeRequested;
                     acceptVariableRequest(varId,
                                           var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));
                 }

gui/src/Visualization/VisualizationGraphWidget.cpp 0 0

NO CONTENT: modified file

plugins/amda/src/AmdaProvider.cpp +7 -6

                         finalProgress = finalProgress / fraq;
                     }
-                    qCDebug(LOG_AmdaProvider()) << tr("Current final progress: ") << fraq << finalProgress;
+                    qCDebug(LOG_AmdaProvider()) << tr("final progress:  ")
+                                                << QThread::currentThread()->objectName() << acqIdentifier
+                                                << fraq << finalProgress;
                     emit dataProvidedProgress(acqIdentifier, finalProgress);
                 }
                 else {
                     // This case can happened when a progression is send after the request has been finished.
                     // Generaly the case when aborting a request
+                    qCDebug(LOG_AmdaProvider()) << tr("Acquisition request not found: final progress: 100 : ")
+                                                << QThread::currentThread()->objectName() << acqIdentifier;
                     emit dataProvidedProgress(acqIdentifier, 100.0);
                 }
             }
                 QVariantHash urlProperties{{AMDA_SERVER_KEY, data.value(AMDA_SERVER_KEY)}};
                 auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(AmdaServer::instance().url(urlProperties),
                                                              startDate, endDate, productId)};
-                qCInfo(LOG_AmdaProvider()) << tr("TORM AmdaProvider::retrieveData url:") << url;
                 auto tempFile = std::make_shared<QTemporaryFile>();
                 // LAMBDA
                           if (reply->error() == QNetworkReply::NoError) {
                               auto downloadFileUrl = QUrl{QString{reply->readAll()}.trimmed()};
-                              qCInfo(LOG_AmdaProvider())
+                              qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData downloadFileUrl:")
-                                  << tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;
+                                                          << downloadFileUrl;
                               // Executes request for downloading file //
                               // Creates destination file
                 // //////////////// //
                 auto request = std::make_shared<QNetworkRequest>(url);
-                qCDebug(LOG_AmdaProvider()) << tr("First Request creation") << request.get();
                 updateRequestProgress(token, request, 0.0);
                 emit requestConstructed(request, token, httpFinishedLambda);
             void AmdaProvider::updateRequestProgress(QUuid acqIdentifier,
                                                      std::shared_ptr<QNetworkRequest> request, double progress)
             {
-                qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress request") << request.get();
                 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;

plugins/amda/tests/FuzzingOperations.cpp +1 -1

                     fuzzingState.synchronizeVariable(variableId, syncGroupId);
                     variableController.onRequestDataLoading({variableState.m_Variable}, variableState.m_Range,
-                                                            false);
+                                                            true);
                 }
             };

plugins/amda/tests/TestAmdaFuzzing.cpp +23 -21

             // ///////// //
             // Defaults values used when the associated properties have not been set for the test
-            const auto ACQUISITION_TIMEOUT_DEFAULT_VALUE = 30000;
+            const auto ACQUISITION_TIMEOUT_DEFAULT_VALUE = 100000;
-            const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 100;
+            const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 160;
-            const auto NB_MAX_SYNC_GROUPS_DEFAULT_VALUE = 1;
+            const auto NB_MAX_SYNC_GROUPS_DEFAULT_VALUE = 8;
-            const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 2;
+            const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 30;
             const auto AVAILABLE_OPERATIONS_DEFAULT_VALUE = QVariant::fromValue(
-                OperationsTypes{{FuzzingOperationType::CREATE, {400., true}},
+                OperationsTypes{{FuzzingOperationType::CREATE, {40000., true}},
                                 {FuzzingOperationType::DELETE, {0.0}}, // Delete operation is less frequent
                                 {FuzzingOperationType::PAN_LEFT, {1.}},
                                 {FuzzingOperationType::PAN_RIGHT, {1.}},
-                                {FuzzingOperationType::ZOOM_IN, {0.}},
+                                {FuzzingOperationType::ZOOM_IN, {1.}},
-                                {FuzzingOperationType::ZOOM_OUT, {0.}},
+                                {FuzzingOperationType::ZOOM_OUT, {1.}},
-                                {FuzzingOperationType::SYNCHRONIZE, {4000.0}},
+                                {FuzzingOperationType::SYNCHRONIZE, {500.0}},
-                                {FuzzingOperationType::DESYNCHRONIZE, {0.4}}});
+                                {FuzzingOperationType::DESYNCHRONIZE, {0.0}}});
             const auto CACHE_TOLERANCE_DEFAULT_VALUE = 0.2;
             /// Min/max delays between each operation (in ms)
-            const auto OPERATION_DELAY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(20, 20));
+            const auto OPERATION_DELAY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(20, 3000));
             /// Validators for the tests (executed in the order in which they're defined)
             const auto VALIDATORS_DEFAULT_VALUE = QVariant::fromValue(
                 ValidatorsTypes{{FuzzingValidatorType::RANGE, FuzzingValidatorType::DATA}});
             /// Min/max number of operations to execute before calling validation
-            const auto VALIDATION_FREQUENCY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(2, 2));
+            const auto VALIDATION_FREQUENCY_BOUNDS_DEFAULT_VALUE = QVariant::fromValue(std::make_pair(2, 10));
             // /////// //////
                             auto waitAcquisition = nextValidationCounter == 0
                                                    || forceWait;
+                            qCInfo(LOG_TestAmdaFuzzing()).noquote() << "Operation :" << i +1 << " on"
+                                                                    << nbOperations;
                             fuzzingOperation->execute(variableId, m_FuzzingState, m_VariableController,
                                                       m_Properties);
                 // Test cases //
                 // ////////// //
-                auto maxRange = SqpRange::fromDateTime({2017, 1, 3}, {0, 0}, {2017, 1, 5}, {0, 0});
+                auto maxRange = SqpRange::fromDateTime({2017, 1, 5}, {8, 0}, {2017, 1, 5}, {16, 0});
                 MetadataPool metadataPool{{{"dataType", "vector"}, {"xml:id", "c1_b"}}};
                 // Note: we don't use auto here as we want to pass std::shared_ptr<IDataProvider> as is in the
             //    {PROVIDER_PROPERTY, QVariant::fromValue(provider)},
             //    {CUSTOM_OPERATIONS_PROPERTY, CUSTOM_CASE_ONE}};
-                QTest::newRow("fuzzingTestZoom") << Properties{
+            //    QTest::newRow("fuzzingTestZoom") << Properties{
-                {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
+            //    {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
-                {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
+            //    {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
-                {PROVIDER_PROPERTY, QVariant::fromValue(provider)},
+            //    {PROVIDER_PROPERTY, QVariant::fromValue(provider)},
-                {CUSTOM_OPERATIONS_PROPERTY, CUSTOM_CASE_TWO}};
+            //    {CUSTOM_OPERATIONS_PROPERTY, CUSTOM_CASE_TWO}};
             ////     Fuzzing
-            //    QTest::newRow("fuzzingTest") << Properties{
+                QTest::newRow("fuzzingTest") << Properties{
-            //    {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
+                {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
-            //    {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
+                {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
-            //    {PROVIDER_PROPERTY, QVariant::fromValue(provider)}};
+                {PROVIDER_PROPERTY, QVariant::fromValue(provider)}};
             }

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