Version 1.20260803.0.

Performance work
- Logger atomics
- LLVM JIT host CPU targeting
- SED-ML error/warning restore
- ODE solver computeRates() caching
- CellML runtime: WASM table dispatch
- KINSOL solver object caching

Benchmarking & testing
- Simulation benchmarks
- Test coverage

Author: agarny

.codespellexclude

@@ -1,10 +1,14 @@
-  afterAll(() => {
+    <!-- BG CVS MVP + Finbar's ANS + Peter's Blood volume Ctl model -->
+        <!-- controlling and modulating the resistance by ANS
     IssuePtrs mErrors;
-    return !mErrors.empty();
-    return mErrors.size();
     return mErrors;
-        mErrors.push_back(issue);
-    mErrors.clear();
     if (pIndex >= mErrors.size()) {
     return mErrors[pIndex];
         mErrors.push_back(std::move(issue));
+    mErrors.clear();
+    mTasksErrors = mErrors;
+        mErrors.clear();
+    // Note: the clearing of mIssues, mErrors, and mWarnings could be done using removeAllIssues(), but this would
+        mErrors = mTasksErrors;
+        mErrorCount.store(mErrors.size(), std::memory_order_release);
+    if ((document->getNumErrors() == 0)

VERSION.txt

@@ -1 +1 @@
-1.20260723.2
+1.20260803.0

newversion

@@ -12,7 +12,7 @@ old_patch_version=$(echo $old_version | cut -d. -f3)
 
 # Determine the new version based on the current version and the current date.
 
-now=$(date +%Y%m%d)
+now=$(TZ=Pacific/Auckland date +%Y%m%d)
 
 new_major_version=$old_major_version
 new_minor_version=$now

newversion.bat

@@ -16,7 +16,7 @@ FOR /F "tokens=1-3 delims=." %%A IN ("!OldVersion!") DO (
 
 REM Determine the new version based on the current version and the current date.
 
-FOR /F "tokens=2 delims==" %%I IN ('wmic os get localdatetime /value') DO SET Now=%%I
+FOR /F "usebackq delims=" %%I IN (`powershell -NoProfile -Command "[System.TimeZoneInfo]::ConvertTimeBySystemTimeZoneId([System.DateTime]::UtcNow, 'New Zealand Standard Time').ToString('yyyyMMdd')"`) DO SET Now=%%I
 
 SET NewMajorVersion=!OldMajorVersion!
 SET NewMinorVersion=!Now:~0,8!

src/logger/logger.cpp

@@ -21,28 +21,24 @@ namespace libOpenCOR {
 
 bool Logger::Impl::hasIssues() const
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
-
-    return !mIssues.empty();
+    return mIssueCount.load(std::memory_order_acquire) != 0;
 }
 
 size_t Logger::Impl::issueCount() const
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
-
-    return mIssues.size();
+    return mIssueCount.load(std::memory_order_acquire);
 }
 
 IssuePtrs Logger::Impl::issues() const
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
+    const std::scoped_lock<std::mutex> lock(mMutex);
 
     return mIssues;
 }
 
 IssuePtr Logger::Impl::issue(size_t pIndex) const
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
+    const std::scoped_lock<std::mutex> lock(mMutex);
 
     if (pIndex >= mIssues.size()) {
         return nullptr;
@@ -53,28 +49,24 @@ IssuePtr Logger::Impl::issue(size_t pIndex) const
 
 bool Logger::Impl::hasErrors() const
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
-
-    return !mErrors.empty();
+    return mErrorCount.load(std::memory_order_acquire) != 0;
 }
 
 size_t Logger::Impl::errorCount() const
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
-
-    return mErrors.size();
+    return mErrorCount.load(std::memory_order_acquire);
 }
 
 IssuePtrs Logger::Impl::errors() const
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
+    const std::scoped_lock<std::mutex> lock(mMutex);
 
     return mErrors;
 }
 
 IssuePtr Logger::Impl::error(size_t pIndex) const
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
+    const std::scoped_lock<std::mutex> lock(mMutex);
 
     if (pIndex >= mErrors.size()) {
         return nullptr;
@@ -85,28 +77,24 @@ IssuePtr Logger::Impl::error(size_t pIndex) const
 
 bool Logger::Impl::hasWarnings() const
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
-
-    return !mWarnings.empty();
+    return mWarningCount.load(std::memory_order_acquire) != 0;
 }
 
 size_t Logger::Impl::warningCount() const
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
-
-    return mWarnings.size();
+    return mWarningCount.load(std::memory_order_acquire);
 }
 
 IssuePtrs Logger::Impl::warnings() const
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
+    const std::scoped_lock<std::mutex> lock(mMutex);
 
     return mWarnings;
 }
 
 IssuePtr Logger::Impl::warning(size_t pIndex) const
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
+    const std::scoped_lock<std::mutex> lock(mMutex);
 
     if (pIndex >= mWarnings.size()) {
         return nullptr;
@@ -139,15 +127,21 @@ void Logger::Impl::addIssues(const libcellml::LoggerPtr &pLogger, const std::str
 
 void Logger::Impl::addIssue(Issue::Type pType, const std::string &pDescription, const std::string &pContext)
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
+    const std::scoped_lock<std::mutex> lock(mMutex);
 
     auto issue {IssuePtr {new Issue {pType, pDescription, pContext}}};
     mIssues.push_back(issue);
 
+    mIssueCount.fetch_add(1, std::memory_order_release);
+
     if (pType == Issue::Type::ERROR) {
         mErrors.push_back(std::move(issue));
+
+        mErrorCount.fetch_add(1, std::memory_order_release);
     } else {
         mWarnings.push_back(std::move(issue));
+
+        mWarningCount.fetch_add(1, std::memory_order_release);
     }
 }
 
@@ -163,12 +157,15 @@ void Logger::Impl::addWarning(const std::string &pDescription)
 
 void Logger::Impl::removeAllIssues()
 {
-    const std::scoped_lock<std::recursive_mutex> lock(mMutex);
+    const std::scoped_lock<std::mutex> lock(mMutex);
 
     mIssues.clear();
-
     mErrors.clear();
     mWarnings.clear();
+
+    mIssueCount.store(0, std::memory_order_release);
+    mErrorCount.store(0, std::memory_order_release);
+    mWarningCount.store(0, std::memory_order_release);
 }
 
 Logger::Logger(std::unique_ptr<Impl> pPimpl)

src/logger/logger_p.h

@@ -22,20 +22,31 @@ limitations under the License.
 #include "libopencor/issue.h"
 #include "libopencor/logger.h"
 
+#include <atomic>
 #include <mutex>
 
 namespace libOpenCOR {
 
 class Logger::Impl
 {
 public:
-    mutable std::recursive_mutex mMutex;
+    mutable std::mutex mMutex;
 
     IssuePtrs mIssues;
-
     IssuePtrs mErrors;
     IssuePtrs mWarnings;
 
+    // Note: we use atomic variables for the issue counts so that they can be read without locking the mutex, which is
+    //       otherwise needed to access the issue vectors themselves. This is because the issue counts can be read
+    //       frequently during a simulation and we want to avoid the overhead of locking the mutex. To ensure that a
+    //       reader never sees an updated count before the corresponding issue vectors have been updated, the counts are
+    //       written with std::memory_order_release and read with std::memory_order_acquire. The vectors themselves are
+    //       still protected by the mutex.
+
+    std::atomic<size_t> mIssueCount {0};
+    std::atomic<size_t> mErrorCount {0};
+    std::atomic<size_t> mWarningCount {0};
+
     virtual ~Impl() = default;
 
     bool hasIssues() const;
@@ -57,7 +68,6 @@ class Logger::Impl
     void addIssues(const libcellml::LoggerPtr &pLogger, const std::string &pContext);
 
     void addIssue(Issue::Type pType, const std::string &pDescription, const std::string &pContext = "");
-
     void addError(const std::string &pDescription);
     void addWarning(const std::string &pDescription);
 

src/misc/compiler.cpp

@@ -632,10 +632,14 @@ extern double atanh(double);
 
     return true;
 #else
-    // Create an ORC-based JIT with aggressive code generation and keep track of it.
+    // Create an ORC-based JIT with a target machine builder for the host system.
+    // Note: we set the CPU to the host CPU name and the optimisation level to aggressive. This is because the default
+    //       CPU is generic and the default optimisation level is none, which can lead to suboptimal performance for the
+    //       generated code.
 
     auto jitTargetMachineBuilder {llvm::orc::JITTargetMachineBuilder(llvm::Triple(llvm::sys::getProcessTriple()))};
 
+    jitTargetMachineBuilder.setCPU(llvm::sys::getHostCPUName().str());
     jitTargetMachineBuilder.setCodeGenOptLevel(llvm::CodeGenOptLevel::Aggressive);
 
     auto lljit {llvm::orc::LLJITBuilder().setJITTargetMachineBuilder(std::move(jitTargetMachineBuilder)).create()};

src/sed/sedinstance.cpp

@@ -78,13 +78,16 @@ SedInstance::Impl::Impl(const SedDocumentPtr &pDocument)
                 }
             }
         }
-
-        // Keep track of the issues of all the tasks.
-
-        mTasksIssues = mIssues;
     } else {
         addError("The simulation experiment description does not contain any tasks to run.");
     }
+
+    // Keep track of the issues so that they can be restored should the instance be run.
+    // Note: this includes the issues generated above (e.g., when there are no tasks to run).
+
+    mTasksIssues = mIssues;
+    mTasksErrors = mErrors;
+    mTasksWarnings = mWarnings;
 }
 
 SedInstance::Status SedInstance::Impl::status() const
@@ -102,11 +105,28 @@ SedInstance::Status SedInstance::Impl::status() const
 
 double SedInstance::Impl::run()
 {
-    // Reset ourselves.
-
-    removeAllIssues();
-
-    mIssues = mTasksIssues;
+    // Reset ourselves by restoring the issues of all the tasks.
+    // Note: the clearing of mIssues, mErrors, and mWarnings could be done using removeAllIssues(), but this would
+    //       result in transiently-empty issues, which could be seen by a reader. So, instead, we just clear and restore
+    //       the issues in one go.
+    // Note: the issue counts are published with std::memory_order_release so that readers using
+    //       std::memory_order_acquire never see an updated count before the corresponding issue vectors are visible.
+
+    {
+        const std::scoped_lock<std::mutex> lock(mMutex);
+
+        mIssues.clear();
+        mErrors.clear();
+        mWarnings.clear();
+
+        mIssues = mTasksIssues;
+        mErrors = mTasksErrors;
+        mWarnings = mTasksWarnings;
+
+        mIssueCount.store(mIssues.size(), std::memory_order_release);
+        mErrorCount.store(mErrors.size(), std::memory_order_release);
+        mWarningCount.store(mWarnings.size(), std::memory_order_release);
+    }
 
     // Reset our control flags and make sure that they are passed to each task so that they can be used by them.
 

src/sed/sedinstance_p.h

@@ -31,7 +31,10 @@ class SedInstance::Impl: public Logger::Impl
 {
 public:
     SedInstanceTaskPtrs mTasks;
+
     IssuePtrs mTasksIssues;
+    IssuePtrs mTasksErrors;
+    IssuePtrs mTasksWarnings;
 
     mutable std::atomic<bool> mRunning {false};
     mutable std::mutex mRunMutex;

src/sed/sedinstancetask.cpp

@@ -257,39 +257,20 @@ void SedInstanceTask::Impl::initialise()
     if (mSedUniformTimeCourse != nullptr) {
         mVoi = mSedUniformTimeCourse->pimpl()->mInitialTime;
 
-#ifdef __EMSCRIPTEN__
-        mRuntime->initialiseArraysForDifferentialModel(mStates, mRates, mConstants, mComputedConstants, mAlgebraicVariables);
-#else
         mRuntime->initialiseArraysForDifferentialModel()(mStates, mRates, mConstants, mComputedConstants, mAlgebraicVariables);
-#endif
     } else {
-#ifdef __EMSCRIPTEN__
-        mRuntime->initialiseArraysForAlgebraicModel(mConstants, mComputedConstants, mAlgebraicVariables);
-#else
         mRuntime->initialiseArraysForAlgebraicModel()(mConstants, mComputedConstants, mAlgebraicVariables);
-#endif
     }
 
     applyChanges();
 
     if (mSedUniformTimeCourse != nullptr) {
-#ifdef __EMSCRIPTEN__
-        mRuntime->computeComputedConstantsForDifferentialModel(mVoi, mStates, mRates, mConstants, mComputedConstants, mAlgebraicVariables);
-        mRuntime->computeRates(mVoi, mStates, mRates, mConstants, mComputedConstants, mAlgebraicVariables);
-        mRuntime->computeVariablesForDifferentialModel(mVoi, mStates, mRates, mConstants, mComputedConstants, mAlgebraicVariables);
-#else
         mRuntime->computeComputedConstantsForDifferentialModel()(mVoi, mStates, mRates, mConstants, mComputedConstants, mAlgebraicVariables);
         mRuntime->computeRates()(mVoi, mStates, mRates, mConstants, mComputedConstants, mAlgebraicVariables);
         mRuntime->computeVariablesForDifferentialModel()(mVoi, mStates, mRates, mConstants, mComputedConstants, mAlgebraicVariables);
-#endif
     } else {
-#ifdef __EMSCRIPTEN__
-        mRuntime->computeComputedConstantsForAlgebraicModel(mConstants, mComputedConstants, mAlgebraicVariables);
-        mRuntime->computeVariablesForAlgebraicModel(mConstants, mComputedConstants, mAlgebraicVariables);
-#else
         mRuntime->computeComputedConstantsForAlgebraicModel()(mConstants, mComputedConstants, mAlgebraicVariables);
         mRuntime->computeVariablesForAlgebraicModel()(mConstants, mComputedConstants, mAlgebraicVariables);
-#endif
     }
 
     // Make sure that the NLA solver, should it have been used, didn't report any issues.
@@ -355,9 +336,7 @@ void SedInstanceTask::Impl::run(double pVoiStart, double pVoiEnd, double pVoiInt
     auto *odeSolverPimpl {mOdeSolver->pimpl()};
     size_t voiCounter {0};
 
-#ifndef __EMSCRIPTEN__
     const auto computeVariablesForDifferentialModel = mRuntime->computeVariablesForDifferentialModel();
-#endif
 
     while (!fuzzyCompare(mVoi, pVoiEnd)) {
         // Check whether a pause or stop has been requested.
@@ -396,11 +375,7 @@ void SedInstanceTask::Impl::run(double pVoiStart, double pVoiEnd, double pVoiInt
             return;
         }
 
-#ifdef __EMSCRIPTEN__
-        mRuntime->computeVariablesForDifferentialModel(mVoi, mStates, mRates, mConstants, mComputedConstants, mAlgebraicVariables);
-#else
         computeVariablesForDifferentialModel(mVoi, mStates, mRates, mConstants, mComputedConstants, mAlgebraicVariables);
-#endif
 
         //---GRY--- WE NEED TO CHECK FOR POSSIBLE NLA ISSUES, BUT FOR CODE COVERAGE WE NEED A MODEL THAT WOULD TRIGGER
         //          NLA ISSUES HERE, WHICH WE DON'T HAVE YET HENCE WE DISABLE THE FOLLOWING CODE WHEN DOING CODE