HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r364:d84300391f84

Add current progression for thread fix

perrinel -

r364:d84300391f84

parent child

Context file:

r364:d84300391f84

core/include/Data/ArrayData.h +30 -4

             #ifndef SCIQLOP_ARRAYDATA_H
             #define SCIQLOP_ARRAYDATA_H
+            #include <QReadLocker>
+            #include <QReadWriteLock>
             #include <QVector>
             /**
              * @brief The ArrayData class represents a dataset for a data series.
              *
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 explicit ArrayData(int nbColumns) : m_Data{1, QVector<double>{}}
                 {
+                    QWriteLocker locker(&m_Lock);
                     m_Data[0].resize(nbColumns);
                 }
                 /**
+                 * Ctor for a unidimensional ArrayData
+                 * @param nbColumns the number of values the ArrayData will hold
+                 */
+                explicit ArrayData(const ArrayData &other)
+                {
+                    QReadLocker otherLocker(&other.m_Lock);
+                    QWriteLocker locker(&m_Lock);
+                    m_Data = other.m_Data;
+                }
+                /**
                  * Sets a data at a specified index. The index has to be valid to be effective
                  * @param index the index to which the data will be set
                  * @param data the data to set
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 void setData(int index, double data) noexcept
                 {
+                    QWriteLocker locker(&m_Lock);
                     if (index >= 0 && index < m_Data.at(0).size()) {
                         m_Data[0].replace(index, data);
                     }
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
-                const QVector<double> &data() const noexcept
+                QVector<double> data() const noexcept
                 {
+                    QReadLocker locker(&m_Lock);
                     return m_Data[0];
                 }
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
-                const QVector<double> &data(double tStart, double tEnd) const noexcept
+                QVector<double> data(double tStart, double tEnd) const noexcept
                 {
+                    QReadLocker locker(&m_Lock);
                     return m_Data.at(tStart);
                 }
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 void merge(const ArrayData<1> &arrayData)
                 {
+                    QWriteLocker locker(&m_Lock);
                     if (!m_Data.empty()) {
+                        QReadLocker otherLocker(&arrayData.m_Lock);
                         m_Data[0] += arrayData.data();
                     }
                 }
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
-                int size()
+                int size() const
                 {
+                    QReadLocker locker(&m_Lock);
                     return m_Data[0].size();
                 }
+                void clear()
+                {
+                    QWriteLocker locker(&m_Lock);
+                    m_Data.clear();
+                }
             private:
                 QVector<QVector<double> > m_Data;
+                mutable QReadWriteLock m_Lock;
             };
             #endif // SCIQLOP_ARRAYDATA_H

core/include/Data/DataSeries.h +15 -1

             #include <QLoggingCategory>
+            #include <QReadLocker>
+            #include <QReadWriteLock>
             #include <memory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSeries)
             Q_LOGGING_CATEGORY(LOG_DataSeries, "DataSeries")
                 /// @sa IDataSeries::valuesUnit()
                 Unit valuesUnit() const override { return m_ValuesUnit; }
+                void clear()
+                {
+                    m_XAxisData->clear();
+                    m_ValuesData->clear();
+                }
                 /// @sa IDataSeries::merge()
                 void merge(IDataSeries *dataSeries) override
                 {
                     if (auto dimDataSeries = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
                         m_XAxisData->merge(*dimDataSeries->xAxisData());
                         m_ValuesData->merge(*dimDataSeries->valuesData());
+                        dimDataSeries->clear();
                     }
                     else {
                         qCWarning(LOG_DataSeries())
                     }
                 }
+                virtual void lockRead() { m_Lock.lockForRead(); }
+                virtual void lockWrite() { m_Lock.lockForWrite(); }
+                virtual void unlock() { m_Lock.unlock(); }
             protected:
                 /// Protected ctor (DataSeries is abstract)
                 explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
                 Unit m_XAxisUnit;
                 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
                 Unit m_ValuesUnit;
+                QReadWriteLock m_Lock;
             };
             #endif // SCIQLOP_DATASERIES_H

core/include/Data/IDataSeries.h +4 0

                 virtual void merge(IDataSeries *dataSeries) = 0;
                 virtual std::unique_ptr<IDataSeries> clone() const = 0;
+                virtual void lockRead() = 0;
+                virtual void lockWrite() = 0;
+                virtual void unlock() = 0;
             };
             // Required for using shared_ptr in signals/slots

core/src/DataSource/DataSourceController.cpp +6 -6

             DataSourceController::DataSourceController(QObject *parent)
                     : impl{spimpl::make_unique_impl<DataSourceControllerPrivate>()}
             {
-                qCDebug(LOG_DataSourceController()) << tr("DataSourceController construction")
+                qCDebug(LOG_DataSourceController())
-                                                    << QThread::currentThread();
+                    << tr("DataSourceController construction") << QThread::currentThread();
             }
             DataSourceController::~DataSourceController()
             {
-                qCDebug(LOG_DataSourceController()) << tr("DataSourceController destruction")
+                qCDebug(LOG_DataSourceController())
-                                                    << QThread::currentThread();
+                    << tr("DataSourceController destruction") << QThread::currentThread();
                 this->waitForFinish();
             }
             void DataSourceController::initialize()
             {
-                qCDebug(LOG_DataSourceController()) << tr("DataSourceController init")
+                qCDebug(LOG_DataSourceController())
-                                                    << QThread::currentThread();
+                    << tr("DataSourceController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init END");
             }

core/src/Variable/Variable.cpp +8 -1

             #include <Data/IDataSeries.h>
             #include <Data/SqpDateTime.h>
+            #include <QReadWriteLock>
+            #include <QThread>
             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
             struct Variable::VariablePrivate {
             void Variable::setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
+                qCInfo(LOG_Variable()) << "Variable::setDataSeries" << QThread::currentThread()->objectName();
                 if (!dataSeries) {
                     /// @todo ALX : log
                     return;
                     impl->m_DataSeries = dataSeries->clone();
                 }
                 else {
+                    dataSeries->lockWrite();
+                    impl->m_DataSeries->lockWrite();
                     impl->m_DataSeries->merge(dataSeries.get());
+                    impl->m_DataSeries->unlock();
+                    dataSeries->unlock();
                     emit updated();
                 }
             }

core/src/Variable/VariableCacheController.cpp +10 -2

             #include "Variable/Variable.h"
             #include <unordered_map>
+            #include <QThread>
             Q_LOGGING_CATEGORY(LOG_VariableCacheController, "VariableCacheController")
             struct VariableCacheController::VariableCacheControllerPrivate {
             void VariableCacheController::addDateTime(std::shared_ptr<Variable> variable,
                                                       const SqpDateTime &dateTime)
             {
+                qCInfo(LOG_VariableCacheController())
+                    << "VariableCacheController::addDateTime" << QThread::currentThread()->objectName();
                 if (variable) {
                     auto findVariableIte = impl->m_VariableToSqpDateTimeListMap.find(variable);
                     if (findVariableIte == impl->m_VariableToSqpDateTimeListMap.end()) {
             VariableCacheController::provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                                    const SqpDateTime &dateTime)
             {
+                qCInfo(LOG_VariableCacheController())
+                    << "VariableCacheController::provideNotInCacheDateTimeList"
+                    << QThread::currentThread()->objectName();
                 auto notInCache = QVector<SqpDateTime>{};
                 // This algorithm is recursif. The idea is to localise the start time then the end time in the
             QVector<SqpDateTime>
             VariableCacheController::dateCacheList(std::shared_ptr<Variable> variable) const noexcept
             {
+                qCInfo(LOG_VariableCacheController())
+                    << "VariableCacheController::dateCacheList" << QThread::currentThread()->objectName();
                 try {
                     return impl->m_VariableToSqpDateTimeListMap.at(variable);
                 }
             {
                 auto variableDateTimeList = impl->m_VariableToSqpDateTimeListMap.find(variable);
                 if (variableDateTimeList != impl->m_VariableToSqpDateTimeListMap.end()) {
-                    qCInfo(LOG_VariableCacheController()) << tr("VariableCacheController::displayCache")
+                    qCInfo(LOG_VariableCacheController())
-                                                          << variableDateTimeList->second;
+                        << tr("VariableCacheController::displayCache") << variableDateTimeList->second;
                 }
                 else {
                     qCWarning(LOG_VariableCacheController())

core/src/Variable/VariableController.cpp +8 -4

             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
-                qCDebug(LOG_VariableController()) << tr("VariableController construction")
+                qCDebug(LOG_VariableController())
-                                                  << QThread::currentThread();
+                    << tr("VariableController construction") << QThread::currentThread();
             }
             VariableController::~VariableController()
             {
-                qCDebug(LOG_VariableController()) << tr("VariableController destruction")
+                qCDebug(LOG_VariableController())
-                                                  << QThread::currentThread();
+                    << tr("VariableController destruction") << QThread::currentThread();
                 this->waitForFinish();
             }
             void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
             {
+                qCDebug(LOG_VariableController())
+                    << "VariableController::onDateTimeOnSelection" << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
             void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
                                                           const SqpDateTime &dateTime)
             {
+                qCDebug(LOG_VariableController())
+                    << "VariableController::onRequestDataLoading" << QThread::currentThread()->objectName();
                 // we want to load data of the variable for the dateTime.
                 // First we check if the cache contains some of them.
                 // For the other, we ask the provider to give them.

gui/src/SqpApplication.cpp +8 -3

                           m_VariableController{std::make_unique<VariableController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()}
                 {
+                    QThread::currentThread()->setObjectName("MainThread");
+                    m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
+                    m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
+                    m_VariableController->moveToThread(&m_VariableControllerThread);
+                    m_VariableControllerThread.setObjectName("VariableControllerThread");
+                    m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
+                    m_VisualizationControllerThread.setObjectName("VisualizationControllerThread");
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                             m_VisualizationController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
-                    m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
-                    m_VariableController->moveToThread(&m_VariableControllerThread);
-                    m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                     // Additionnal init
                     m_VariableController->setTimeController(m_TimeController.get());

gui/src/Visualization/VisualizationGraphHelper.cpp +25 -20

             #include <Variable/Variable.h>
-            #include <QElapsedTimer>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace {
+            class SqpDataContainer : public QCPGraphDataContainer {
+            public:
+                void sqpAdd(const QCPGraphData &data) { mData.append(data); }
+            };
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,
                                   const SqpDateTime &dateTime)
             {
-                QElapsedTimer timer;
+                qCInfo(LOG_VisualizationGraphHelper())
-                timer.start();
+                    << "TORM: updateScalarData" << QThread::currentThread()->objectName();
                 if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
                     // Clean the graph
                     // NAIVE approch
-                    const auto &xData = scalarSeries.xAxisData()->data();
+                    scalarSeries.lockRead();
-                    const auto &valuesData = scalarSeries.valuesData()->data();
+                        const auto xData = scalarSeries.xAxisData()->data();
+                        const auto valuesData = scalarSeries.valuesData()->data();
                         const auto count = xData.count();
-                    qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache" << xData.count();
+                        qCInfo(LOG_VisualizationGraphHelper())
-                    auto xValue = QVector<double>(count);
+                            << "TORM: Current points in cache" << xData.count();
-                    auto vValue = QVector<double>(count);
+                        auto dataContainer = qcpGraph->data();
+                        dataContainer->clear();
+                        auto sqpDataContainer = QSharedPointer<SqpDataContainer>::create();
+                        qcpGraph->setData(sqpDataContainer);
-                    int n = 0;
                         for (auto i = 0; i < count; ++i) {
                             const auto x = xData[i];
                             if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {
-                            xValue[n] = x;
+                                sqpDataContainer->sqpAdd(QCPGraphData(x, valuesData[i]));
-                            vValue[n] = valuesData[i];
-                            ++n;
                             }
                         }
+                        sqpDataContainer->sort();
+                        qCInfo(LOG_VisualizationGraphHelper())
+                            << "TORM: Current points displayed" << sqpDataContainer->size();
+                    }
+                    scalarSeries.unlock();
-                    xValue.resize(n);
-                    vValue.resize(n);
-                    qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
-                                                           << xValue.count();
-                    qcpGraph->setData(xValue, vValue);
                     // Display all data
                     component->rescaleAxes();

gui/src/Visualization/VisualizationGraphWidget.cpp +2 -2

                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
             }
             void VisualizationGraphWidget::addVariableUsingGraph(std::shared_ptr<Variable> variable)
             {
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1)
             {
-                qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged");
+                qCDebug(LOG_VisualizationGraphWidget())
+                    << tr("VisualizationGraphWidget::onRangeChanged") << QThread::currentThread()->objectName();
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {

gui/src/Visualization/qcustomplot.cpp +25 -16

                     mChildren.last()->setLayer(0); // removes itself from mChildren via removeChild()
                 if (mParentPlot->currentLayer() == this)
-                    qDebug() << Q_FUNC_INFO << "The parent plot's mCurrentLayer will be a dangling pointer. "
+                    qDebug() << Q_FUNC_INFO
+                             << "The parent plot's mCurrentLayer will be a dangling pointer. "
                                 "Should have been set to a valid layer or 0 beforehand.";
             }
               \see initializeParentPlot
             */
-            void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot)
+            void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot){Q_UNUSED(parentPlot)}
-                Q_UNUSED(parentPlot)
             /*! \internal
                             mRange = newRange.sanitizedForLogScale();
                     }
                     else
-                        qDebug() << Q_FUNC_INFO << "Center of scaling operation doesn't lie in same "
+                        qDebug() << Q_FUNC_INFO
+                                 << "Center of scaling operation doesn't lie in same "
                                     "logarithmic sign domain as range:"
                                  << center;
                 }
                 painter->setBrush(QBrush(basePen.color()));
                 QCPVector2D baseLineVector(baseLine.dx(), baseLine.dy());
                 if (lowerEnding.style() != QCPLineEnding::esNone)
-                    lowerEnding.draw(painter, QCPVector2D(baseLine.p1())
+                    lowerEnding.draw(painter,
+                                     QCPVector2D(baseLine.p1())
                                          - baseLineVector.normalized() * lowerEnding.realLength()
                                                * (lowerEnding.inverted() ? -1 : 1),
                                      -baseLineVector);
                 if (upperEnding.style() != QCPLineEnding::esNone)
-                    upperEnding.draw(painter, QCPVector2D(baseLine.p2())
+                    upperEnding.draw(painter,
+                                     QCPVector2D(baseLine.p2())
                                          + baseLineVector.normalized() * upperEnding.realLength()
                                                * (upperEnding.inverted() ? -1 : 1),
                                      baseLineVector);
                     bool labelClippedByBorder = false;
                     if (tickLabelSide == QCPAxis::lsOutside) {
                         if (QCPAxis::orientation(type) == Qt::Horizontal)
-                            labelClippedByBorder = finalPosition.x() + (labelData.rotatedTotalBounds.width()
+                            labelClippedByBorder = finalPosition.x()
+                                                           + (labelData.rotatedTotalBounds.width()
                                                               + labelData.rotatedTotalBounds.left())
                                                        > viewportRect.right()
                                                    || finalPosition.x() + labelData.rotatedTotalBounds.left()
                                                           < viewportRect.left();
                         else
-                            labelClippedByBorder = finalPosition.y() + (labelData.rotatedTotalBounds.height()
+                            labelClippedByBorder = finalPosition.y()
+                                                           + (labelData.rotatedTotalBounds.height()
                                                               + labelData.rotatedTotalBounds.top())
                                                        > viewportRect.bottom()
                                                    || finalPosition.y() + labelData.rotatedTotalBounds.top()
             */
             QPointF QCPAbstractItem::anchorPixelPosition(int anchorId) const
             {
-                qDebug() << Q_FUNC_INFO << "called on item which shouldn't have any anchors (this method not "
+                qDebug() << Q_FUNC_INFO
+                         << "called on item which shouldn't have any anchors (this method not "
                             "reimplemented). anchorId"
                          << anchorId;
                 return QPointF();
                 setupPaintBuffers();
             #else
                 Q_UNUSED(enabled)
-                qDebug() << Q_FUNC_INFO << "QCustomPlot can't use OpenGL because QCUSTOMPLOT_USE_OPENGL was "
+                qDebug() << Q_FUNC_INFO
+                         << "QCustomPlot can't use OpenGL because QCUSTOMPLOT_USE_OPENGL was "
                             "not defined during compilation (add 'DEFINES += "
                             "QCUSTOMPLOT_USE_OPENGL' to your qmake .pro file)";
             #endif
                 if (!valueAxis)
                     valueAxis = yAxis;
                 if (!keyAxis || !valueAxis) {
-                    qDebug() << Q_FUNC_INFO << "can't use default QCustomPlot xAxis or yAxis, because at least "
+                    qDebug() << Q_FUNC_INFO
+                             << "can't use default QCustomPlot xAxis or yAxis, because at least "
                                 "one is invalid (has been deleted)";
                     return 0;
                 }
                     return new QCPPaintBufferGlPbuffer(viewport().size(), mBufferDevicePixelRatio,
                                                        mOpenGlMultisamples);
             #else
-                    qDebug() << Q_FUNC_INFO << "OpenGL enabled even though no support for it compiled in, this "
+                    qDebug() << Q_FUNC_INFO
+                             << "OpenGL enabled even though no support for it compiled in, this "
                                 "shouldn't have happened. Falling back to pixmap paint buffer.";
                     return new QCPPaintBufferPixmap(viewport().size(), mBufferDevicePixelRatio);
             #endif
                                         hue -= 1.0;
                                     if (useAlpha) {
                                         const QRgb rgb
-                                            = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
+                                            = QColor::fromHsvF(hue,
+                                                               (1 - t) * lowHsv.saturationF()
                                                                    + t * highHsv.saturationF(),
                                                                (1 - t) * lowHsv.valueF() + t * highHsv.valueF())
                                                   .rgb();
                                     }
                                     else {
                                         mColorBuffer[i]
-                                            = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
+                                            = QColor::fromHsvF(hue,
+                                                               (1 - t) * lowHsv.saturationF()
                                                                    + t * highHsv.saturationF(),
                                                                (1 - t) * lowHsv.valueF() + t * highHsv.valueF())
                                                   .rgb();

plugins/mockplugin/src/CosinusProvider.cpp +3 0

             #include <cmath>
             #include <QDateTime>
+            #include <QThread>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
             {
+                qCInfo(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
+                                              << QThread::currentThread()->objectName();
                 // NOTE: Try to use multithread if possible
                 for (const auto &dateTime : dateTimeList) {
                     auto scalarSeries = this->retrieveData(DataProviderParameters{dateTime});

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