Improve the time taken to validate and analyse large models

src/analyser.cpp

@@ -403,8 +403,17 @@ AnalyserInternalVariablePtr Analyser::AnalyserImpl::internalVariable(const Varia
     // Find and return, if there is one, the internal variable associated with
     // the given variable.
 
+    auto rawPtr = reinterpret_cast<uintptr_t>(variable.get());
+    auto rawPtrIt = mInternalVariableMap.find(rawPtr);
+
+    if (rawPtrIt != mInternalVariableMap.end()) {
+        return rawPtrIt->second;
+    }
+
     for (const auto &internalVariable : mInternalVariables) {
         if (mAnalyserModel->areEquivalentVariables(variable, internalVariable->mVariable)) {
+            mInternalVariableMap[rawPtr] = internalVariable;
+
             return internalVariable;
         }
     }
@@ -416,6 +425,8 @@ AnalyserInternalVariablePtr Analyser::AnalyserImpl::internalVariable(const Varia
 
     mInternalVariables.push_back(res);
 
+    mInternalVariableMap[rawPtr] = res;
+
     return res;
 }
 
@@ -2321,6 +2332,7 @@ void Analyser::AnalyserImpl::analyseModel(const ModelPtr &model)
     mAnalyserModel = AnalyserModel::AnalyserModelImpl::create(model);
 
     mInternalVariables.clear();
+    mInternalVariableMap.clear();
     mInternalEquations.clear();
 
     mCiCnUnits.clear();

src/analyser_p.h

@@ -161,6 +161,7 @@ class Analyser::AnalyserImpl: public Logger::LoggerImpl
     AnalyserExternalVariablePtrs mExternalVariables;
 
     AnalyserInternalVariablePtrs mInternalVariables;
+    std::unordered_map<std::uintptr_t, AnalyserInternalVariablePtr> mInternalVariableMap;
     AnalyserInternalEquationPtrs mInternalEquations;
 
     GeneratorProfilePtr mGeneratorProfile = GeneratorProfile::create();

src/analysermodel.cpp

@@ -48,35 +48,50 @@ AnalyserModel::~AnalyserModel()
     delete mPimpl;
 }
 
-void AnalyserModel::AnalyserModelImpl::buildEquivalentVariablesCache(const ComponentPtr &component)
+void exploreEquivalentVariables(const VariablePtr &variable, std::unordered_set<uintptr_t> &equivalentGroup, std::unordered_set<uintptr_t> &visited)
 {
-    for (size_t i = 0; i < component->variableCount(); ++i) {
-        auto variable = component->variable(i);
-
-        for (size_t j = 0; j < variable->equivalentVariableCount(); ++j) {
-            auto equivalentVariable = variable->equivalentVariable(j);
-            auto v1 = reinterpret_cast<uintptr_t>(variable.get());
-            auto v2 = reinterpret_cast<uintptr_t>(equivalentVariable.get());
+    auto rawPtr = reinterpret_cast<uintptr_t>(variable.get());
 
-            if (v2 < v1) {
-                std::swap(v1, v2);
-            }
+    if (visited.insert(rawPtr).second) {
+        equivalentGroup.insert(rawPtr);
 
-            uniteEquivalentVariableAddresses(v1, v2);
+        for (size_t i = 0; i < variable->equivalentVariableCount(); ++i) {
+            exploreEquivalentVariables(variable->equivalentVariable(i), equivalentGroup, visited);
         }
     }
-
-    for (size_t i = 0; i < component->componentCount(); ++i) {
-        buildEquivalentVariablesCache(component->component(i));
-    }
 }
 
 void AnalyserModel::AnalyserModelImpl::buildEquivalentVariablesCache()
 {
+    std::unordered_set<uintptr_t> visited;
+    size_t groupCount = 0;
     mEquivalentVariableCache.clear();
 
     for (size_t i = 0; i < mModel->componentCount(); ++i) {
-        buildEquivalentVariablesCache(mModel->component(i));
+        buildEquivalentVariablesCache(mModel->component(i), visited, groupCount);
+    }
+}
+
+void AnalyserModel::AnalyserModelImpl::buildEquivalentVariablesCache(const ComponentPtr &component, std::unordered_set<uintptr_t> &visited, size_t &groupCount)
+{
+    for (size_t i = 0; i < component->variableCount(); ++i) {
+        auto variable = component->variable(i);
+        auto rawPtr = reinterpret_cast<uintptr_t>(variable.get());
+
+        if (visited.count(rawPtr) == 0) {
+            std::unordered_set<uintptr_t> equivalentGroup;
+            exploreEquivalentVariables(variable, equivalentGroup, visited);
+
+            for (uintptr_t v : equivalentGroup) {
+                mEquivalentVariableCache[v] = groupCount;
+            }
+
+            ++groupCount;
+        }
+    }
+
+    for (size_t i = 0; i < component->componentCount(); ++i) {
+        buildEquivalentVariablesCache(component->component(i), visited, groupCount);
     }
 }
 
@@ -98,20 +113,21 @@ AnalyserModel::Type AnalyserModel::type() const
     return mPimpl->mType;
 }
 
-static const std::map<AnalyserModel::Type, std::string> typeToString = {
-    {AnalyserModel::Type::UNKNOWN, "unknown"},
-    {AnalyserModel::Type::ODE, "ode"},
-    {AnalyserModel::Type::DAE, "dae"},
-    {AnalyserModel::Type::NLA, "nla"},
-    {AnalyserModel::Type::ALGEBRAIC, "algebraic"},
-    {AnalyserModel::Type::INVALID, "invalid"},
-    {AnalyserModel::Type::UNDERCONSTRAINED, "underconstrained"},
-    {AnalyserModel::Type::OVERCONSTRAINED, "overconstrained"},
-    {AnalyserModel::Type::UNSUITABLY_CONSTRAINED, "unsuitably_constrained"}};
-
 std::string AnalyserModel::typeAsString(Type type)
 {
-    return typeToString.at(type);
+    static constexpr const char *names[] = {
+        "unknown",
+        "algebraic",
+        "dae",
+        "invalid",
+        "nla",
+        "ode",
+        "overconstrained",
+        "underconstrained",
+        "unsuitably_constrained",
+    };
+
+    return names[static_cast<size_t>(type)];
 }
 
 bool AnalyserModel::hasExternalVariables() const
@@ -274,9 +290,37 @@ AnalyserVariablePtr AnalyserModel::analyserVariable(const VariablePtr &variable)
         return {};
     }
 
-    for (const auto &analyserVariable : analyserVariables(shared_from_this())) {
-        if (areEquivalentVariables(variable, analyserVariable->variable())) {
-            return analyserVariable;
+    if (mPimpl->mVoi && areEquivalentVariables(variable, mPimpl->mVoi->variable())) {
+        return mPimpl->mVoi;
+    }
+
+    for (const auto &state : mPimpl->mStates) {
+        if (areEquivalentVariables(variable, state->variable())) {
+            return state;
+        }
+    }
+
+    for (const auto &constant : mPimpl->mConstants) {
+        if (areEquivalentVariables(variable, constant->variable())) {
+            return constant;
+        }
+    }
+
+    for (const auto &computedConstant : mPimpl->mComputedConstants) {
+        if (areEquivalentVariables(variable, computedConstant->variable())) {
+            return computedConstant;
+        }
+    }
+
+    for (const auto &algebraicVariable : mPimpl->mAlgebraicVariables) {
+        if (areEquivalentVariables(variable, algebraicVariable->variable())) {
+            return algebraicVariable;
+        }
+    }
+
+    for (const auto &externalVariable : mPimpl->mExternalVariables) {
+        if (areEquivalentVariables(variable, externalVariable->variable())) {
+            return externalVariable;
         }
     }
 
@@ -546,7 +590,19 @@ bool AnalyserModel::areEquivalentVariables(const VariablePtr &variable1,
     const auto v1 = reinterpret_cast<uintptr_t>(variable1.get());
     const auto v2 = reinterpret_cast<uintptr_t>(variable2.get());
 
-    return mPimpl->findVariableAddress(v1) == mPimpl->findVariableAddress(v2);
+    const auto it1 = mPimpl->mEquivalentVariableCache.find(v1);
+
+    if (it1 == mPimpl->mEquivalentVariableCache.end()) {
+        return false;
+    }
+
+    const auto it2 = mPimpl->mEquivalentVariableCache.find(v2);
+
+    if (it2 == mPimpl->mEquivalentVariableCache.end()) {
+        return false;
+    }
+
+    return it1->second == it2->second;
 }
 
 } // namespace libcellml

src/analysermodel_p.h

@@ -18,6 +18,7 @@ limitations under the License.
 
 #include <cstdint>
 #include <unordered_map>
+#include <unordered_set>
 
 #include "libcellml/analysermodel.h"
 
@@ -46,34 +47,7 @@ struct AnalyserModel::AnalyserModelImpl
 
     std::vector<AnalyserEquationPtr> mAnalyserEquations;
 
-    std::unordered_map<uintptr_t, uintptr_t> mEquivalentVariableCache;
-
-    uintptr_t findVariableAddress(uintptr_t x)
-    {
-        auto it = mEquivalentVariableCache.find(x);
-
-        if (it == mEquivalentVariableCache.end()) {
-            mEquivalentVariableCache[x] = x;
-
-            return x;
-        }
-
-        if (it->second != x) {
-            it->second = findVariableAddress(it->second);
-        }
-
-        return it->second;
-    }
-
-    void uniteEquivalentVariableAddresses(uintptr_t x, uintptr_t y)
-    {
-        const uintptr_t &rootX = findVariableAddress(x);
-        const uintptr_t &rootY = findVariableAddress(y);
-
-        if (rootX != rootY) {
-            mEquivalentVariableCache[rootY] = rootX;
-        }
-    }
+    std::unordered_map<uintptr_t, size_t> mEquivalentVariableCache;
 
     bool mNeedEqFunction = false;
     bool mNeedNeqFunction = false;
@@ -104,7 +78,7 @@ struct AnalyserModel::AnalyserModelImpl
 
     static AnalyserModelPtr create(const ModelPtr &model = nullptr);
 
-    void buildEquivalentVariablesCache(const ComponentPtr &component);
+    void buildEquivalentVariablesCache(const ComponentPtr &component, std::unordered_set<uintptr_t> &visited, size_t &groupCount);
     void buildEquivalentVariablesCache();
 
     AnalyserModelImpl(const ModelPtr &model);

src/api/libcellml/analysermodel.h

@@ -604,10 +604,6 @@ class LIBCELLML_EXPORT AnalyserModel
      * analysis phase (@ref Analyser::analyseModel). The cache may become
      * out of date if the model is changed after the model has been analysed.
      *
-     * @note This function is primarily designed for use during model analysis
-     *       by the @ref Analyser. While external usage is not programmatically
-     *       restricted, it is not the primary intended use case.
-     *
      * @param variable1 The @ref Variable to test if it is equivalent to
      * @p variable2.
      * @param variable2 The @ref Variable that is potentially equivalent to
@@ -616,8 +612,7 @@ class LIBCELLML_EXPORT AnalyserModel
      * @return @c true if @p variable1 is equivalent to @p variable2 and
      * @c false otherwise.
      */
-    bool areEquivalentVariables(const VariablePtr &variable1,
-                                const VariablePtr &variable2);
+    bool areEquivalentVariables(const VariablePtr &variable1, const VariablePtr &variable2);
 
 private:
     AnalyserModel(const ModelPtr &model); /**< Constructor, @private. */

src/api/libcellml/variable.h

@@ -174,14 +174,17 @@ class LIBCELLML_EXPORT Variable: public NamedEntity
      *
      * Get the connection identifier set for the equivalence defined with the given variables.
      * The variables are commutative.  If no connection identifier is set the empty string is returned.
+     * The optional parameter @p deepSearch will traverse the equivalence network to find the connection identifier for the
+     * equivalence defined by the two variables.  By default this is true.
      *
      * If the two variables are not equivalent the empty string is returned.
      *
      * @param variable1 Variable one of the equivalence.
      * @param variable2 Variable two of the equivalence.
+     * @param deepSearch Optional parameter to deep search the equivalence network for the connection identifier, true by default.
      * @return the @c std::string connection identifier.
      */
-    static std::string equivalenceConnectionId(const VariablePtr &variable1, const VariablePtr &variable2);
+    static std::string equivalenceConnectionId(const VariablePtr &variable1, const VariablePtr &variable2, bool deepSearch = true);
 
     /**
      * @brief Clear equivalent connection identifier for this equivalence.

src/internaltypes.h

@@ -46,7 +46,7 @@ using VariableMap = std::vector<VariablePairPtr>; /**< Type definition for vecto
 using VariableMapIterator = VariableMap::const_iterator; /**< Type definition of const iterator for vector of VariablePair.*/
 
 // ComponentMap
-using ComponentPair = std::pair<ComponentPtr, ComponentPtr>; /**< Type definition for Component pointer pair.*/
+using ComponentPair = std::pair<ComponentPtr, ComponentPtr>; /**< Type definition for Component pointer pair using standard library.*/
 using ComponentMap = std::vector<ComponentPair>; /**< Type definition for vector of ComponentPair.*/
 using ComponentMapIterator = ComponentMap::const_iterator; /**< Type definition of const iterator for vector of ComponentPair.*/
 
@@ -79,6 +79,9 @@ using UnitsConstPtr = std::shared_ptr<const Units>; /**< Type definition for sha
 using ConnectionMap = std::map<VariablePtr, VariablePtr>; /**< Type definition for a connection map.*/
 using NamePairList = std::vector<NamePair>; /**< Type definition for a list of a pair of names. */
 
+using ComponentRawPtrPair = std::pair<const Component *, const Component *>; /**< Type definition for pair of raw component pointers. */
+using ConnectionIdMap = std::map<ComponentRawPtrPair, std::string>; /**< Type definition for map of pair of raw component pointers to connection ID. */
+
 /**
  * @brief Class for defining an epoch in the history of a @ref Component or @ref Units.
  *