HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r16:5da3a19e8770

Made Variable data update atomic ease thread safety and avoid mixing...

jeandet -

r16:5da3a19e8770

parent child

Context file:

r16:5da3a19e8770

include/Data/DataSeries.h +7 -4

             public:
                 /// @sa IDataSeries::xAxisData()
                 std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
-                const std::shared_ptr<ArrayData<1> > xAxisData() const { return m_XAxisData; }
+                const std::shared_ptr<ArrayData<1> > xAxisData() const override { return m_XAxisData; }
                 /// @sa IDataSeries::xAxisUnit()
                 Unit xAxisUnit() const override { return m_XAxisUnit; }
                 // Mutexes //
                 // /////// //
-                virtual void lockRead() { m_Lock.lockForRead(); }
+                virtual QReadLocker getReadLock() override { return QReadLocker{&m_Lock}; }
-                virtual void lockWrite() { m_Lock.lockForWrite(); }
+                virtual QWriteLocker getWriteLock() override { return QWriteLocker{&m_Lock}; }
-                virtual void unlock() { m_Lock.unlock(); }
+                virtual void lockRead() override { m_Lock.lockForRead(); }
+                virtual void lockWrite() override { m_Lock.lockForWrite(); }
+                virtual void unlock() override { m_Lock.unlock(); }
             protected:
                 /// Protected ctor (DataSeries is abstract).

include/Data/IDataSeries.h +10 -4

             #ifndef SCIQLOP_IDATASERIES_H
             #define SCIQLOP_IDATASERIES_H
+            #include <memory>
+            #include <QReadWriteLock>
+            #include <QString>
             #include <Common/MetaTypes.h>
             #include <Data/DataSeriesIterator.h>
             #include <Data/DateTimeRange.h>
             #include <Data/Unit.h>
+            #include <Common/deprecate.h>
-            #include <memory>
-            #include <QString>
             template <int Dim>
             class ArrayData;
                 // /////// //
                 // Mutexes //
                 // /////// //
+                virtual QReadLocker getReadLock() = 0;
+                virtual QWriteLocker getWriteLock() = 0;
+            DEPRECATE(
                 virtual void lockRead() = 0;
                 virtual void lockWrite() = 0;
                 virtual void unlock() = 0;
+                )
             };
             // Required for using shared_ptr in signals/slots

include/Data/VectorSeries.h +1 -1

                 explicit VectorSeries(std::vector<double> xAxisData, std::vector<double> valuesData,
                                       const Unit &xAxisUnit, const Unit &valuesUnit);
-                std::unique_ptr<IDataSeries> clone() const;
+                std::unique_ptr<IDataSeries> clone() const override;
                 std::shared_ptr<IDataSeries> subDataSeries(const DateTimeRange &range) override;
             };

include/Variable/Variable.h +10 -5

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
-            #include "CoreGlobal.h"
+            #include <QLoggingCategory>
+            #include <QObject>
+            #include <QUuid>
+            #include <QReadWriteLock>
+            #include "CoreGlobal.h"
             #include <Data/DataSeriesIterator.h>
             #include <Data/DataSeriesType.h>
             #include <Data/DateTimeRange.h>
-            #include <QLoggingCategory>
-            #include <QObject>
-            #include <QUuid>
             #include <Common/deprecate.h>
             #include <Common/MetaTypes.h>
             DEPRECATE(
                 void mergeDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
                 )
-                void mergeDataSeries(IDataSeries* dataSeries, bool notify=false) noexcept;
+                void updateData(const std::vector<IDataSeries*>& dataSeries,
+                                const DateTimeRange& newRange, const DateTimeRange& newCacheRange,
+                                bool notify=true);
             DEPRECATE(
                 static QVector<DateTimeRange> provideNotInCacheRangeList(const DateTimeRange &oldRange,
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
                 QUuid _uuid;
+                QReadWriteLock m_lock;
             };
             // Required for using shared_ptr in signals/slots

src/Variable/Variable.cpp +25 -36

             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
-            namespace {
             /**
              * Searches in metadata for a value that can be converted to DataSeriesType
              * @return the value converted to a DataSeriesType if it was found, UNKNOWN type otherwise
              * @sa DataSeriesType
              */
-            DataSeriesType findDataSeriesType(const QVariantHash &metadata)
+            static DataSeriesType findDataSeriesType(const QVariantHash &metadata)
             {
                 auto dataSeriesType = DataSeriesType::UNKNOWN;
                 return dataSeriesType;
             }
-            } // namespace
             #define VP_PROPERTY(property,getter,setter,type) \
                 type getter() noexcept\
                     updateRealRange();
                     updateNbPoints();
                 }
+                void mergeDataSeries(const std::vector<IDataSeries*>& dataseries)
+                {
+                    QWriteLocker lock{&m_Lock};
+                    for(auto ds:dataseries)
+                    {
+                        if(m_DataSeries)
+                            m_DataSeries->merge(ds);
+                        else
+                            m_DataSeries = ds->clone();
+                    }
+                }
                 void updateNbPoints() { m_NbPoints = m_DataSeries ? m_DataSeries->nbPoints() : 0; }
                 /// Updates real range according to current variable range and data series
                 void updateRealRange()
                 {
                     if (m_DataSeries) {
-                        m_DataSeries->lockRead();
+                        auto lock = m_DataSeries->getReadLock();
                         auto end = m_DataSeries->cend();
                         auto minXAxisIt = m_DataSeries->minXAxisData(m_Range.m_TStart);
                         auto maxXAxisIt = m_DataSeries->maxXAxisData(m_Range.m_TEnd);
+                        if(minXAxisIt != end && maxXAxisIt != end && minXAxisIt->x() <= maxXAxisIt->x())
-                        m_RealRange
+                            m_RealRange = DateTimeRange{minXAxisIt->x(), maxXAxisIt->x()};
-                            = (minXAxisIt != end && maxXAxisIt != end && minXAxisIt->x() <= maxXAxisIt->x())
+                        else
-                                  ? DateTimeRange{minXAxisIt->x(), maxXAxisIt->x()}
+                            m_RealRange = std::nullopt;
-                                  : INVALID_RANGE;
-                        m_DataSeries->unlock();
                     }
                     else {
                         m_RealRange = std::nullopt;
                 }
             }
-            void Variable::mergeDataSeries(IDataSeries *dataSeries, bool notify) noexcept
+            void Variable::updateData(const std::vector<IDataSeries *> &dataSeries, const DateTimeRange &newRange, const DateTimeRange &newCacheRange, bool notify)
             {
-                if (dataSeries==nullptr) {
-                    SCIQLOP_ERROR(Variable,"Given IDataSeries is nullptr");
+                    QWriteLocker lock{&m_lock};
-                    return;
+                    impl->mergeDataSeries(dataSeries);
+                    impl->setRange(newRange);
+                    impl->setCacheRange(newCacheRange);
-                auto dataInit = false;
+                    impl->purgeDataSeries();
-                // @TODO move impl to Pimpl this is what it stands for...
-                // Add or merge the data
-                impl->lockWrite();
-                if (!impl->m_DataSeries) {
-                    //@TODO find a better way
-                    impl->m_DataSeries = dataSeries->clone();
-                    dataInit = true;
-                    delete dataSeries;
-                else {
-                    impl->m_DataSeries->merge(dataSeries);
-                impl->purgeDataSeries();
-                impl->unlock();
-                if (dataInit) {
-                    emit dataInitialized();
                 }
                 if(notify)
-                    emit this->updated();
+                    emit updated();
             }

src/Variable/VariableController2.cpp +3 -4

                         newCacheRange = _cacheStrategy->computeRange(var->cacheRange(),r);
                         missingRanges = newCacheRange - var->cacheRange();
                     }
+                    std::vector<IDataSeries*> data;
                     for(auto range:missingRanges)
                     {
-                        auto data = provider->getData(DataProviderParameters{{range},var->metadata()});
+                        data.push_back(provider->getData(DataProviderParameters{{range},var->metadata()}));
-                        var->mergeDataSeries(data);
                     }
-                    var->setCacheRange(newCacheRange);
+                    var->updateData(data,r,newCacheRange,true);
-                    var->setRange(r);
                 }
             public:
                 VariableController2Private(QObject* parent=Q_NULLPTR)

tests/Variable/TestVariableController.cpp +1 -1

             /// Provider used for the tests
             class TestProvider : public IDataProvider {
-                std::shared_ptr<IDataProvider> clone() const { return std::make_shared<TestProvider>(); }
+                std::shared_ptr<IDataProvider> clone() const override { return std::make_shared<TestProvider>(); }
                 void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override
                 {

tests/Variable/TestVariableSync.cpp +1 -1

             /// Provider used for the tests
             class TestProvider : public IDataProvider {
-                std::shared_ptr<IDataProvider> clone() const { return std::make_shared<TestProvider>(); }
+                std::shared_ptr<IDataProvider> clone() const override { return std::make_shared<TestProvider>(); }
                 void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override
                 {

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