GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1398:8cb3639e4927

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

perrinel -

r1398:8cb3639e4927

parent child

Context file:

r1398:8cb3639e4927

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

              void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
                                                                               double progress)
              {
-                 qCInfo(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
-                                                         << QThread::currentThread()->objectName()
-                                                         << acqIdentifier << progress;
+                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
+                                                          << QThread::currentThread()->objectName()
+                                                          << acqIdentifier << progress;
                  impl->lockRead();
                  auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                  if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                          = 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 +1 -1

                          &VisualizationGraphWidget::onMouseDoubleClick);
                  connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                                 &QCPAxis::rangeChanged),
-                     this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
+                         this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
                  // Activates menu when right clicking on the graph
                  ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);

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())
-                                   << tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;
+                               qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData 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 NB_MAX_OPERATIONS_DEFAULT_VALUE = 100;
-             const auto NB_MAX_SYNC_GROUPS_DEFAULT_VALUE = 1;
-             const auto NB_MAX_VARIABLES_DEFAULT_VALUE = 2;
+             const auto ACQUISITION_TIMEOUT_DEFAULT_VALUE = 100000;
+             const auto NB_MAX_OPERATIONS_DEFAULT_VALUE = 160;
+             const auto NB_MAX_SYNC_GROUPS_DEFAULT_VALUE = 8;
+             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_OUT, {0.}},
-                                 {FuzzingOperationType::SYNCHRONIZE, {4000.0}},
-                                 {FuzzingOperationType::DESYNCHRONIZE, {0.4}}});
+                                 {FuzzingOperationType::ZOOM_IN, {1.}},
+                                 {FuzzingOperationType::ZOOM_OUT, {1.}},
+                                 {FuzzingOperationType::SYNCHRONIZE, {500.0}},
+                                 {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{
-                 {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
-                 {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
-                 {PROVIDER_PROPERTY, QVariant::fromValue(provider)},
-                 {CUSTOM_OPERATIONS_PROPERTY, CUSTOM_CASE_TWO}};
+             //    QTest::newRow("fuzzingTestZoom") << Properties{
+             //    {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
+             //    {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
+             //    {PROVIDER_PROPERTY, QVariant::fromValue(provider)},
+             //    {CUSTOM_OPERATIONS_PROPERTY, CUSTOM_CASE_TWO}};
              ////     Fuzzing
-             //    QTest::newRow("fuzzingTest") << Properties{
-             //    {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
-             //    {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
-             //    {PROVIDER_PROPERTY, QVariant::fromValue(provider)}};
+                 QTest::newRow("fuzzingTest") << Properties{
+                 {MAX_RANGE_PROPERTY, QVariant::fromValue(maxRange)},
+                 {METADATA_POOL_PROPERTY, QVariant::fromValue(metadataPool)},
+                 {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