GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1241:5f4e5de2ac36

Implements execute() method of desync operation...

Alexandre Leroux -

r1241:5f4e5de2ac36

parent child

Context file:

r1241:5f4e5de2ac36

Collapse all files

plugins/amda/tests/FuzzingDefs.cpp +14 0

             #include "FuzzingDefs.h"
             const QString NB_MAX_OPERATIONS_PROPERTY = QStringLiteral("component");
             const QString NB_MAX_SYNC_GROUPS_PROPERTY = QStringLiteral("nbSyncGroups");
             const QString NB_MAX_VARIABLES_PROPERTY = QStringLiteral("nbMaxVariables");
             const QString AVAILABLE_OPERATIONS_PROPERTY = QStringLiteral("availableOperations");
             const QString CACHE_TOLERANCE_PROPERTY = QStringLiteral("cacheTolerance");
             const QString INITIAL_RANGE_PROPERTY = QStringLiteral("initialRange");
             const QString MAX_RANGE_PROPERTY = QStringLiteral("maxRange");
             const QString METADATA_POOL_PROPERTY = QStringLiteral("metadataPool");
             const QString PROVIDER_PROPERTY = QStringLiteral("provider");
             const QString OPERATION_DELAY_PROPERTY = QStringLiteral("operationDelay");
             const QString VALIDATORS_PROPERTY = QStringLiteral("validators");
             // //////////// //
             // FuzzingState //
             // //////////// //
             const SyncGroup &FuzzingState::syncGroup(SyncGroupId id) const
             {
                 return m_SyncGroupsPool.at(id);
             }
             SyncGroup &FuzzingState::syncGroup(SyncGroupId id)
             {
                 return m_SyncGroupsPool.at(id);
             }
             const VariableState &FuzzingState::variableState(VariableId id) const
             {
                 return m_VariablesPool.at(id);
             }
             VariableState &FuzzingState::variableState(VariableId id)
             {
                 return m_VariablesPool.at(id);
             }
             SyncGroupId FuzzingState::syncGroupId(VariableId variableId) const
             {
                 auto end = m_SyncGroupsPool.cend();
                 auto it
                     = std::find_if(m_SyncGroupsPool.cbegin(), end, [&variableId](const auto &syncGroupEntry) {
                           const auto &syncGroup = syncGroupEntry.second;
                           return syncGroup.m_Variables.find(variableId) != syncGroup.m_Variables.end();
                       });
                 return it != end ? it->first : SyncGroupId{};
             }
             std::vector<SyncGroupId> FuzzingState::syncGroupsIds() const
             {
                 std::vector<SyncGroupId> result{};
                 for (const auto &entry : m_SyncGroupsPool) {
                     result.push_back(entry.first);
                 }
                 return result;
             }
             void FuzzingState::synchronizeVariable(VariableId variableId, SyncGroupId syncGroupId)
             {
                 if (syncGroupId.isNull()) {
                     return;
                 }
                 // Registers variable into sync group: if it's the first variable, sets the variable range as
                 // the sync group range
                 auto &syncGroup = m_SyncGroupsPool.at(syncGroupId);
                 syncGroup.m_Variables.insert(variableId);
                 if (syncGroup.m_Variables.size() == 1) {
                     auto &variableState = m_VariablesPool.at(variableId);
                     syncGroup.m_Range = variableState.m_Range;
                 }
             }
+            void FuzzingState::desynchronizeVariable(VariableId variableId, SyncGroupId syncGroupId)
+            {
+                if (syncGroupId.isNull()) {
+                    return;
+                }
+                // Unregisters variable from sync group: if there is no more variable in the group, resets the range
+                auto &syncGroup = m_SyncGroupsPool.at(syncGroupId);
+                syncGroup.m_Variables.erase(variableId);
+                if (syncGroup.m_Variables.empty()) {
+                    syncGroup.m_Range = INVALID_RANGE;
+                }
+            }

plugins/amda/tests/FuzzingDefs.h +5 0

             #ifndef SCIQLOP_FUZZINGDEFS_H
             #define SCIQLOP_FUZZINGDEFS_H
             #include <Data/SqpRange.h>
             #include <QString>
             #include <QUuid>
             #include <QVariantHash>
             #include <memory>
             #include <set>
             // /////// //
             // Aliases //
             // /////// //
             using MetadataPool = std::vector<QVariantHash>;
             Q_DECLARE_METATYPE(MetadataPool)
             using Properties = QVariantHash;
             // ///////// //
             // Constants //
             // ///////// //
             /// Max number of operations to generate
             extern const QString NB_MAX_OPERATIONS_PROPERTY;
             /// Max number of sync groups to create through operations
             extern const QString NB_MAX_SYNC_GROUPS_PROPERTY;
             /// Max number of variables to manipulate through operations
             extern const QString NB_MAX_VARIABLES_PROPERTY;
             /// Set of operations available for the test
             extern const QString AVAILABLE_OPERATIONS_PROPERTY;
             /// Tolerance used for variable's cache (in ratio)
             extern const QString CACHE_TOLERANCE_PROPERTY;
             /// Range with which the timecontroller is initialized
             extern const QString INITIAL_RANGE_PROPERTY;
             /// Max range that an operation can reach
             extern const QString MAX_RANGE_PROPERTY;
             /// Set of metadata that can be associated to a variable
             extern const QString METADATA_POOL_PROPERTY;
             /// Provider used to retrieve data
             extern const QString PROVIDER_PROPERTY;
             /// Time left for an operation to execute
             extern const QString OPERATION_DELAY_PROPERTY;
             /// Validators used to validate an operation
             extern const QString VALIDATORS_PROPERTY;
             // /////// //
             // Structs //
             // /////// //
             class Variable;
             struct VariableState {
                 std::shared_ptr<Variable> m_Variable{nullptr};
                 SqpRange m_Range{INVALID_RANGE};
             };
             using VariableId = int;
             using VariablesPool = std::map<VariableId, VariableState>;
             /**
              * Defines a synchronization group for a fuzzing state. A group reports the variables synchronized
              * with each other, and the current range of the group (i.e. range of the last synchronized variable
              * that has been moved)
              */
             struct SyncGroup {
                 std::set<VariableId> m_Variables{};
                 SqpRange m_Range{INVALID_RANGE};
             };
             using SyncGroupId = QUuid;
             using SyncGroupsPool = std::map<SyncGroupId, SyncGroup>;
             /**
              * Defines a current state during a fuzzing state. It contains all the variables manipulated during
              * the test, as well as the synchronization status of these variables.
              */
             struct FuzzingState {
                 const SyncGroup &syncGroup(SyncGroupId id) const;
                 SyncGroup &syncGroup(SyncGroupId id);
                 const VariableState &variableState(VariableId id) const;
                 VariableState &variableState(VariableId id);
                 /// @return the identifier of the synchronization group in which the variable passed in
                 /// parameter is located. If the variable is not in any group, returns an invalid identifier
                 SyncGroupId syncGroupId(VariableId variableId) const;
                 /// @return the set of synchronization group identifiers
                 std::vector<SyncGroupId> syncGroupsIds() const;
                 /// Updates fuzzing state according to a variable synchronization
                 /// @param variableId the variable that is synchronized
                 /// @param syncGroupId the synchronization group
                 void synchronizeVariable(VariableId variableId, SyncGroupId syncGroupId);
+                /// Updates fuzzing state according to a variable desynchronization
+                /// @param variableId the variable that is desynchronized
+                /// @param syncGroupId the synchronization group from which to remove the variable
+                void desynchronizeVariable(VariableId variableId, SyncGroupId syncGroupId);
                 VariablesPool m_VariablesPool;
                 SyncGroupsPool m_SyncGroupsPool;
             };
             #endif // SCIQLOP_FUZZINGDEFS_H

plugins/amda/tests/FuzzingOperations.cpp +19 0

             #include "FuzzingOperations.h"
             #include "FuzzingUtils.h"
             #include <Data/IDataProvider.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QUuid>
             #include <functional>
             Q_LOGGING_CATEGORY(LOG_FuzzingOperations, "FuzzingOperations")
             namespace {
             struct CreateOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     // A variable can be created only if it doesn't exist yet
                     return fuzzingState.variableState(variableId).m_Variable == nullptr;
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController,
                              const Properties &properties) const override
                 {
                     // Retrieves metadata pool from properties, and choose one of the metadata entries to
                     // associate it with the variable
                     auto metaDataPool = properties.value(METADATA_POOL_PROPERTY).value<MetadataPool>();
                     auto variableMetadata = RandomGenerator::instance().randomChoice(metaDataPool);
                     // Retrieves provider
                     auto variableProvider
                         = properties.value(PROVIDER_PROPERTY).value<std::shared_ptr<IDataProvider> >();
                     auto variableName = QString{"Var_%1"}.arg(QUuid::createUuid().toString());
                     qCInfo(LOG_FuzzingOperations()).noquote()
                         << "Creating variable" << variableName << "(metadata:" << variableMetadata << ")...";
                     auto newVariable
                         = variableController.createVariable(variableName, variableMetadata, variableProvider);
                     // Updates variable's state
                     auto &variableState = fuzzingState.variableState(variableId);
                     variableState.m_Range = properties.value(INITIAL_RANGE_PROPERTY).value<SqpRange>();
                     std::swap(variableState.m_Variable, newVariable);
                 }
             };
             struct DeleteOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     // A variable can be delete only if it exists
                     return fuzzingState.variableState(variableId).m_Variable != nullptr;
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController, const Properties &) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     qCInfo(LOG_FuzzingOperations()).noquote()
                         << "Deleting variable" << variableState.m_Variable->name() << "...";
                     variableController.deleteVariable(variableState.m_Variable);
                     // Updates variable's state
                     variableState.m_Range = INVALID_RANGE;
                     variableState.m_Variable = nullptr;
+                    // Desynchronizes the variable if it was in a sync group
+                    auto syncGroupId = fuzzingState.syncGroupId(variableId);
+                    fuzzingState.desynchronizeVariable(variableId, syncGroupId);
                 }
             };
             /**
              * Defines a move operation through a range.
              *
              * A move operation is determined by three functions:
              * - Two 'move' functions, used to indicate in which direction the beginning and the end of a range
              * are going during the operation. These functions will be:
              * -- {<- / <-} for pan left
              * -- {-> / ->} for pan right
              * -- {-> / <-} for zoom in
              * -- {<- / ->} for zoom out
              * - One 'max move' functions, used to compute the max delta at which the operation can move a
              * range, according to a max range. For exemple, for a range of {1, 5} and a max range of {0, 10},
              * max deltas will be:
              * -- {0, 4} for pan left
              * -- {6, 10} for pan right
              * -- {3, 3} for zoom in
              * -- {0, 6} for zoom out (same spacing left and right)
              */
             struct MoveOperation : public IFuzzingOperation {
                 using MoveFunction = std::function<double(double currentValue, double maxValue)>;
                 using MaxMoveFunction = std::function<double(const SqpRange &range, const SqpRange &maxRange)>;
                 explicit MoveOperation(MoveFunction rangeStartMoveFun, MoveFunction rangeEndMoveFun,
                                        MaxMoveFunction maxMoveFun,
                                        const QString &label = QStringLiteral("Move operation"))
                         : m_RangeStartMoveFun{std::move(rangeStartMoveFun)},
                           m_RangeEndMoveFun{std::move(rangeEndMoveFun)},
                           m_MaxMoveFun{std::move(maxMoveFun)},
                           m_Label{label}
                 {
                 }
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     return fuzzingState.variableState(variableId).m_Variable != nullptr;
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController,
                              const Properties &properties) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     auto variable = variableState.m_Variable;
                     // Gets the max range defined
                     auto maxRange = properties.value(MAX_RANGE_PROPERTY, QVariant::fromValue(INVALID_RANGE))
                                         .value<SqpRange>();
                     auto variableRange = variable->range();
                     if (maxRange == INVALID_RANGE || variableRange.m_TStart < maxRange.m_TStart
                         || variableRange.m_TEnd > maxRange.m_TEnd) {
                         qCWarning(LOG_FuzzingOperations()) << "Can't execute operation: invalid max range";
                         return;
                     }
                     // Computes the max delta at which the variable can move, up to the limits of the max range
                     auto deltaMax = m_MaxMoveFun(variable->range(), maxRange);
                     // Generates random delta that will be used to move variable
                     auto delta = RandomGenerator::instance().generateDouble(0, deltaMax);
                     // Moves variable to its new range
                     auto newVariableRange = SqpRange{m_RangeStartMoveFun(variableRange.m_TStart, delta),
                                                      m_RangeEndMoveFun(variableRange.m_TEnd, delta)};
                     qCInfo(LOG_FuzzingOperations()).noquote()
                         << "Performing" << m_Label << "on" << variable->name() << "(from" << variableRange
                         << "to" << newVariableRange << ")...";
                     variableController.onRequestDataLoading({variable}, newVariableRange, false);
                     // Updates variable's state
                     variableState.m_Range = newVariableRange;
                 }
                 MoveFunction m_RangeStartMoveFun;
                 MoveFunction m_RangeEndMoveFun;
                 MaxMoveFunction m_MaxMoveFun;
                 QString m_Label;
             };
             struct SynchronizeOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     auto variable = fuzzingState.variableState(variableId).m_Variable;
                     return variable != nullptr && !fuzzingState.m_SyncGroupsPool.empty()
                            && fuzzingState.syncGroupId(variableId).isNull();
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController, const Properties &) const override
                 {
                     auto &variableState = fuzzingState.variableState(variableId);
                     // Chooses a random synchronization group and adds the variable into sync group
                     auto syncGroupId = RandomGenerator::instance().randomChoice(fuzzingState.syncGroupsIds());
                     qCInfo(LOG_FuzzingOperations()).noquote()
                         << "Adding" << variableState.m_Variable->name() << "into synchronization group"
                         << syncGroupId << "...";
                     variableController.onAddSynchronized(variableState.m_Variable, syncGroupId);
                     // Updates state
                     fuzzingState.synchronizeVariable(variableId, syncGroupId);
                 }
             };
             struct DesynchronizeOperation : public IFuzzingOperation {
                 bool canExecute(VariableId variableId, const FuzzingState &fuzzingState) const override
                 {
                     auto variable = fuzzingState.variableState(variableId).m_Variable;
                     return variable != nullptr && !fuzzingState.syncGroupId(variableId).isNull();
                 }
                 void execute(VariableId variableId, FuzzingState &fuzzingState,
                              VariableController &variableController, const Properties &) const override
                 {
+                    auto &variableState = fuzzingState.variableState(variableId);
+                    // Gets the sync group of the variable
+                    auto syncGroupId = fuzzingState.syncGroupId(variableId);
+                    qCInfo(LOG_FuzzingOperations()).noquote()
+                        << "Removing" << variableState.m_Variable->name() << "from synchronization group"
+                        << syncGroupId << "...";
+                    variableController.onAddSynchronized(variableState.m_Variable, syncGroupId);
+                    // Updates state
+                    fuzzingState.desynchronizeVariable(variableId, syncGroupId);
+                }
+            };
             struct UnknownOperation : public IFuzzingOperation {
                 bool canExecute(VariableId, const FuzzingState &) const override { return false; }
                 void execute(VariableId, FuzzingState &, VariableController &,
                              const Properties &) const override
                 {
                 }
             };
             } // namespace
             std::unique_ptr<IFuzzingOperation> FuzzingOperationFactory::create(FuzzingOperationType type)
             {
                 switch (type) {
                     case FuzzingOperationType::CREATE:
                         return std::make_unique<CreateOperation>();
                     case FuzzingOperationType::DELETE:
                         return std::make_unique<DeleteOperation>();
                     case FuzzingOperationType::PAN_LEFT:
                         return std::make_unique<MoveOperation>(
                             std::minus<double>(), std::minus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 return range.m_TStart - maxRange.m_TStart;
                             },
                             QStringLiteral("Pan left operation"));
                     case FuzzingOperationType::PAN_RIGHT:
                         return std::make_unique<MoveOperation>(
                             std::plus<double>(), std::plus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 return maxRange.m_TEnd - range.m_TEnd;
                             },
                             QStringLiteral("Pan right operation"));
                     case FuzzingOperationType::ZOOM_IN:
                         return std::make_unique<MoveOperation>(
                             std::plus<double>(), std::minus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 Q_UNUSED(maxRange)
                                 return range.m_TEnd - (range.m_TStart + range.m_TEnd) / 2.;
                             },
                             QStringLiteral("Zoom in operation"));
                     case FuzzingOperationType::ZOOM_OUT:
                         return std::make_unique<MoveOperation>(
                             std::minus<double>(), std::plus<double>(),
                             [](const SqpRange &range, const SqpRange &maxRange) {
                                 return std::min(range.m_TStart - maxRange.m_TStart,
                                                 maxRange.m_TEnd - range.m_TEnd);
                             },
                             QStringLiteral("Zoom out operation"));
                     case FuzzingOperationType::SYNCHRONIZE:
                         return std::make_unique<SynchronizeOperation>();
                     case FuzzingOperationType::DESYNCHRONIZE:
                         return std::make_unique<DesynchronizeOperation>();
                     default:
                         // Default case returns unknown operation
                         break;
                 }
                 return std::make_unique<UnknownOperation>();
             }

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