GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r371:684b9afd5f2a

Merge branch 'feature/ThreadFix' into develop

perrinel -

r371:684b9afd5f2a

parent child

Context file:

r371:684b9afd5f2a

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/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
             {
+                qCDebug(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 +8 0

             #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)
             {
+                qCDebug(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)
             {
+                qCDebug(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
             {
+                qCDebug(LOG_VariableCacheController()) << "VariableCacheController::dateCacheList"
+                                                       << QThread::currentThread()->objectName();
                 try {
                     return impl->m_VariableToSqpDateTimeListMap.at(variable);
                 }

core/src/Variable/VariableController.cpp +4 0

             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 +30 -25

@@ -5,12 +5,16
5		5
6	#include <Variable/Variable.h>	6	#include <Variable/Variable.h>
7		7
8	#include <QElapsedTimer>
9
10	Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")	8	Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
11		9
12	namespace {	10	namespace {
13		11
		12	class SqpDataContainer : public QCPGraphDataContainer {
		13	public:
		14	void appendGraphDataUnsorted(const QCPGraphData &data) { mData.append(data); }
		15	};
		16
		17
14	/// Format for datetimes on a axis	18	/// Format for datetimes on a axis
15	const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");	19	const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
16		20
@@ -33,35 +37,36 QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
33	void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,	37	void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,
34	const SqpDateTime &dateTime)	38	const SqpDateTime &dateTime)
35	{	39	{
36	QElapsedTimer timer;	40	qCDebug(LOG_VisualizationGraphHelper()) << "TORM: updateScalarData"
37	timer.start();	41	<< QThread::currentThread()->objectName();
38	if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {	42	if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
39	// Clean the graph	43	// Clean the graph
40	// NAIVE approch	44	// NAIVE approch
41	const auto &xData = scalarSeries.xAxisData()->data();	45	scalarSeries.lockRead();
42	const auto &valuesData = scalarSeries.valuesData()->data();	46	{
43	const auto count = xData.count();	47	const auto xData = scalarSeries.xAxisData()->data();
44	qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache" << xData.count();	48	const auto valuesData = scalarSeries.valuesData()->data();
45	auto xValue = QVector<double>(count);	49	const auto count = xData.count();
46	auto vValue = QVector<double>(count);	50	qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache"
47		51	<< xData.count();
48	int n = 0;	52
49	for (auto i = 0; i < count; ++i) {	53	auto dataContainer = qcpGraph->data();
50	const auto x = xData[i];	54	dataContainer->clear();
51	if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {	55	auto sqpDataContainer = QSharedPointer<SqpDataContainer>::create();
52	xValue[n] = x;	56	qcpGraph->setData(sqpDataContainer);
53	vValue[n] = valuesData[i];	57
54	++n;	58	for (auto i = 0; i < count; ++i) {
		59	const auto x = xData[i];
		60	if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {
		61	sqpDataContainer->appendGraphDataUnsorted(QCPGraphData(x, valuesData[i]));
		62	}
55	}	63	}
		64	sqpDataContainer->sort();
		65	qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
		66	<< sqpDataContainer->size();
56	}	67	}
		68	scalarSeries.unlock();
57		69
58	xValue.resize(n);
59	vValue.resize(n);
60
61	qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
62	<< xValue.count();
63
64	qcpGraph->setData(xValue, vValue);
65		70
66	// Display all data	71	// Display all data
67	component->rescaleAxes();	72	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 +1 -1

             }
             /*! \overload
-            */
+             */
             void QCPLegend::setIconSize(int width, int height)
             {
                 mIconSize.setWidth(width);

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)
             {
+                qCDebug(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