OMP environment variables override values defined in the configuration.

Author: shoops

CMakeLists.txt

@@ -464,7 +464,7 @@ if (ENABLE_OMP)
   # language bindings cant be linked against static libomp
   if (UNIX AND NOT APPLE AND (ENABLE_JAVA OR ENABLE_CSHARP OR ENABLE_PYTHON))
     set(_copasi_openmp_library_suffixes "${CMAKE_FIND_LIBRARY_SUFFIXES}")
-    set(CMAKE_FIND_LIBRARY_SUFFIXES ".so")
+    set(CMAKE_FIND_LIBRARY_SUFFIXES ".so;.so.0")
   endif()
 
   if(MSVC)

copasi/CopasiSE/CopasiSE.cpp

@@ -1214,7 +1214,7 @@ void writeLogo()
   if (NoLogo) return;
 
   std::cout << "COPASI "
-            << CVersion::VERSION.getVersion() <<  COpenMPConfig::Info() << std::endl
+            << CVersion::VERSION.getVersion() << " " << COpenMPConfig::Info() << std::endl
             << "The use of this software indicates the acceptance of the attached license." << std::endl
             << "To view the license please use the option: --license" << std::endl
             << std::endl;

copasi/OpenMP/CContext.h

@@ -34,6 +34,12 @@ const omp_sched_t omp_sched_monotonic = (omp_sched_t) 0x80000000;
 # define omp_get_max_threads() (1)
 # define omp_get_num_threads() (1)
 # define omp_get_thread_num() (0)
+# define omp_sched_static 1u
+# define omp_sched_dynamic 2u
+# define omp_sched_guided 3u
+# define omp_sched_auto 4u
+typedef unsigned int omp_sched_t;
+const omp_sched_t omp_sched_monotonic = (omp_sched_t) 0x80000000;
 #endif // USE_OMP
 
 template < class Data > class CContext

copasi/OpenMP/COpenMPConfig.cpp

@@ -6,35 +6,70 @@
 #include "copasi/OpenMP/COpenMPConfig.h"
 #include "copasi/OpenMP/CContext.h"
 
-#ifdef USE_OMP
-# include <omp.h>
-#else
-# define omp_sched_static 1u
-# define omp_sched_dynamic 2u
-# define omp_sched_guided 3u
-# define omp_sched_auto 4u
-typedef unsigned int omp_sched_t;
-#endif // USE_OMP
+// static
+const COpenMPConfig::ScheduleStrategyName COpenMPConfig::ScheduleStrategyNames({"static",
+                                                                                "dynamic",
+                                                                                "guided",
+                                                                                "automatic"});
+
+// static
+const CEnumAnnotation< omp_sched_t, COpenMPConfig::ScheduleStrategy > COpenMPConfig::ScheduleStrategyOpenMP({omp_sched_static,
+                                                                                                             omp_sched_dynamic,
+                                                                                                             omp_sched_guided,
+                                                                                                             omp_sched_auto});
 
 // static
-const COpenMPConfig::ScheduleStrategyName COpenMPConfig::ScheduleStrategyNames({
-  "static",
-  "dynamic",
-  "guided",
-  "automatic"
-});
+const COpenMPConfig::MonotonicName COpenMPConfig::MonotonicNames({"nonmonotonic",
+                                                                  "monotonic"});
 
 // static
-const CEnumAnnotation< omp_sched_t, COpenMPConfig::ScheduleStrategy > ScheduleStrategyOpenMP({
-  omp_sched_static,
-  omp_sched_dynamic,
-  omp_sched_guided,
-  omp_sched_auto
-});
+const CEnumAnnotation< omp_sched_t, COpenMPConfig::Monotonic > COpenMPConfig::MonotonicOpenMP({(omp_sched_t) 0x0, // nonmonotonic
+                                                                                               omp_sched_monotonic});
 
 // static
 const int COpenMPConfig::MaxNumThreads = omp_get_max_threads();
 
+struct _ScheduleStrategyOpenMP
+{
+  COpenMPConfig::ScheduleStrategy scheduleStrategy = COpenMPConfig::ScheduleStrategy::Static;
+  COpenMPConfig::Monotonic monotonicity = COpenMPConfig::Monotonic::nonmonotonic;
+  C_UINT32 chunkSize = 0;
+};
+
+_ScheduleStrategyOpenMP getSchedule()
+{
+  std::string OMP_SCHEDULE = COptions::getEnvironmentVariable("OMP_SCHEDULE");
+  std::string Monotonic = "";
+
+  std::string::size_type Pos = OMP_SCHEDULE.find(":");
+
+  if (Pos != std::string::npos)
+    {
+      Monotonic = OMP_SCHEDULE.substr(0, Pos);
+      OMP_SCHEDULE = OMP_SCHEDULE.substr(Pos + 1);
+
+#ifndef OMP_HAVE_MONOTONIC
+      Monotonic = "nonmonotonic";
+#endif // OMP_HAVE_MONOTONIC
+    }
+
+  std::string ChunkSize;
+  Pos = OMP_SCHEDULE.find(",");
+
+  if (Pos != std::string::npos)
+    {
+      ChunkSize = OMP_SCHEDULE.substr(Pos + 1);
+      OMP_SCHEDULE = OMP_SCHEDULE.substr(0, Pos);
+    }
+
+  _ScheduleStrategyOpenMP ScheduleStrategyOpenMP;
+  ScheduleStrategyOpenMP.scheduleStrategy = COpenMPConfig::ScheduleStrategyNames.toEnum(OMP_SCHEDULE);
+  ScheduleStrategyOpenMP.monotonicity = COpenMPConfig::MonotonicNames.toEnum(Monotonic);
+  ScheduleStrategyOpenMP.chunkSize = (C_UINT32) ChunkSize.empty() ? -1 : std::stoi(ChunkSize);
+
+  return ScheduleStrategyOpenMP;
+}
+
 COpenMPConfig::COpenMPConfig(const std::string & name,
                              const CDataContainer * pParent)
   : CCopasiParameterGroup(name, pParent)
@@ -82,11 +117,26 @@ COpenMPConfig & COpenMPConfig::operator=(const COpenMPConfig & rhs)
 
 void COpenMPConfig::apply() const
 {
+  std::string OMP_NUM_THREADS = COptions::getEnvironmentVariable("OMP_NUM_THREADS");
+  C_UINT32 MaxNumThreads = OMP_NUM_THREADS.empty() ? *mpMaxNumThreads : std::stoi(OMP_NUM_THREADS);
+
+  _ScheduleStrategyOpenMP Schedule = getSchedule();
+  std::string ScheduleStrategy = Schedule.scheduleStrategy == ScheduleStrategy::__SIZE ? *mpScheduleStrategy : ScheduleStrategyNames[Schedule.scheduleStrategy];
+  std::string Monotonic = Schedule.monotonicity == Monotonic::__SIZE ? *mpMonotonic : MonotonicNames[Schedule.monotonicity];
+  C_UINT32 ChunkSize = Schedule.chunkSize == (C_UINT32) -1 ? *mpChunkSize : Schedule.chunkSize;
+
+  bool IsEnabled = *mpIsEnabled || !OMP_NUM_THREADS.empty() || Schedule.scheduleStrategy != ScheduleStrategy::__SIZE;
+
 #ifdef USE_OMP
-  if (*mpIsEnabled)
+  if (IsEnabled)
     {
-      omp_set_num_threads(*mpMaxNumThreads);
-      omp_set_schedule(ScheduleStrategyOpenMP[ScheduleStrategyNames.toEnum(*mpScheduleStrategy)], 0);
+      omp_set_num_threads(MaxNumThreads);
+      omp_sched_t OpenMPStrategy =
+        ScheduleStrategyOpenMP[ScheduleStrategyNames.toEnum(ScheduleStrategy, ScheduleStrategy::Static)];
+      omp_sched_t OpenMPMonotonicity =
+        MonotonicOpenMP[MonotonicNames.toEnum(Monotonic, Monotonic::nonmonotonic)];
+
+      omp_set_schedule(omp_sched_t(OpenMPStrategy | OpenMPMonotonicity), ChunkSize);
     }
   else
     {
@@ -146,31 +196,48 @@ bool COpenMPConfig::setScheduleStrategy(const std::string & scheduleStrategy)
 
 void COpenMPConfig::initializeParameter()
 {
-  mpIsEnabled = assertParameter("Enabled", CCopasiParameter::Type::BOOL, false);
-  mpMaxNumThreads = assertParameter("Max Number Threads", CCopasiParameter::Type::UINT, (C_UINT32) ceil(MaxNumThreads / 2.0));
-  mpScheduleStrategy = assertParameter("Schedule Strategy", CCopasiParameter::Type::STRING, std::string("static"));
+  std::string OMP_NUM_THREADS = COptions::getEnvironmentVariable("OMP_NUM_THREADS");
+  C_UINT32 MaxNumThreads = OMP_NUM_THREADS.empty() ? ceil(MaxNumThreads / 2.0) : std::stoi(OMP_NUM_THREADS);
+
+  _ScheduleStrategyOpenMP Schedule = getSchedule();
+
+  bool IsEnabled = false || !OMP_NUM_THREADS.empty() || Schedule.scheduleStrategy != ScheduleStrategy::__SIZE;
+
+  mpIsEnabled = assertParameter("Enabled", CCopasiParameter::Type::BOOL, IsEnabled);
+  mpMaxNumThreads = assertParameter("Max Number Threads", CCopasiParameter::Type::UINT, MaxNumThreads);
+  mpScheduleStrategy = assertParameter("Schedule Strategy", CCopasiParameter::Type::STRING, ScheduleStrategyNames[Schedule.scheduleStrategy != ScheduleStrategy::__SIZE ? Schedule.scheduleStrategy : ScheduleStrategy::Static]);
+  mpMonotonic = assertParameter("Monotonicity", CCopasiParameter::Type::STRING, MonotonicNames[Schedule.monotonicity != Monotonic::__SIZE ? Schedule.monotonicity : Monotonic::nonmonotonic]);
+  mpChunkSize = assertParameter("Chunk Size", CCopasiParameter::Type::UINT, Schedule.chunkSize == (C_UINT32) -1 ? 0 : Schedule.chunkSize);
 
   CCopasiParameter * pMaxNumThreadsParameter = getParameter("Max Number Threads");
-  pMaxNumThreadsParameter->setValidValues(std::vector<std::pair<C_UINT32, C_UINT32>>({{1, MaxNumThreads}}));
+  pMaxNumThreadsParameter->setValidValues(std::vector< std::pair< C_UINT32, C_UINT32 > >({{1, MaxNumThreads}}));
 
   CCopasiParameter * pScheduleStrategyParameter = getParameter("Schedule Strategy");
   pScheduleStrategyParameter->setValidValues(ScheduleStrategyNames);
+
+  CCopasiParameter * pMonotonicParameter = getParameter("Monotonicity");
+  pMonotonicParameter->setValidValues(MonotonicNames);
 }
 
 std::string COpenMPConfig::Info()
 {
   std::ostringstream Info;
 
 #ifdef USE_OMP
-  Info << " (OpenMP threads: " << omp_get_max_threads() << " schedule: ";
+  Info << "OpenMP " << COPASI_OMP_VERSION << " (threads: " << omp_get_max_threads() << ", schedule: ";
   omp_sched_t Schedule;
   int Chunk;
   omp_get_schedule(&Schedule, &Chunk);
 
   // Schedule may have the monotonic modifier, we masked it.
-  Schedule = (omp_sched_t)(Schedule & ~omp_sched_monotonic);
+  if (Schedule & omp_sched_monotonic)
+    {
+      Schedule = (omp_sched_t) (Schedule & ~omp_sched_monotonic);
+      Info << "monotonic:";
+    }
+
   Info << ScheduleStrategyNames[ScheduleStrategyOpenMP.toEnum(Schedule)];
-  Info << "," << Chunk << ")";
+  Info << ", chunk size: " << Chunk << ")";
 #endif // USE_OMP
 
   return Info.str();

copasi/OpenMP/COpenMPConfig.h

@@ -6,6 +6,7 @@
 #pragma once
 
 #include "copasi/utilities/CCopasiParameter.h"
+#include "copasi/commandline/COptions.h"
 
 /**
  *  COpenMPConfig class.
@@ -26,6 +27,18 @@ class COpenMPConfig : public CCopasiParameterGroup
 
   typedef CEnumAnnotation< std::string, ScheduleStrategy > ScheduleStrategyName;
   static const ScheduleStrategyName ScheduleStrategyNames;
+  static const CEnumAnnotation< omp_sched_t, ScheduleStrategy > ScheduleStrategyOpenMP;
+
+  enum struct Monotonic
+  {
+    nonmonotonic = 0,
+    monotonic,
+    __SIZE
+  };
+
+  typedef CEnumAnnotation< std::string, Monotonic > MonotonicName;
+  static const MonotonicName MonotonicNames;
+  static const CEnumAnnotation< omp_sched_t, Monotonic > MonotonicOpenMP;
 
   static const int MaxNumThreads;
 
@@ -36,7 +49,7 @@ class COpenMPConfig : public CCopasiParameterGroup
    * @param const std::string & name (default: MIRIAM Resource)
    * @param const CDataContainer * pParent (default: NULL)
    */
-  COpenMPConfig(const std::string & name = "OpenMP Configuration",
+  COpenMPConfig(const std::string & name = "Parallel Processing",
                 const CDataContainer * pParent = NO_PARENT);
 
   /**
@@ -90,7 +103,11 @@ class COpenMPConfig : public CCopasiParameterGroup
 
   bool *mpIsEnabled;
 
-  unsigned C_INT32 *mpMaxNumThreads;
+  C_UINT32 *mpMaxNumThreads;
 
   std::string *mpScheduleStrategy;
+
+  std::string *mpMonotonic;
+
+  C_UINT32 *mpChunkSize;
 };

copasi/UI/AboutDialog.cpp

@@ -1,26 +1,26 @@
-// Copyright (C) 2019 - 2024 by Pedro Mendes, Rector and Visitors of the 
-// University of Virginia, University of Heidelberg, and University 
-// of Connecticut School of Medicine. 
-// All rights reserved. 
-
-// Copyright (C) 2017 - 2018 by Pedro Mendes, Virginia Tech Intellectual 
-// Properties, Inc., University of Heidelberg, and University of 
-// of Connecticut School of Medicine. 
-// All rights reserved. 
-
-// Copyright (C) 2010 - 2016 by Pedro Mendes, Virginia Tech Intellectual 
-// Properties, Inc., University of Heidelberg, and The University 
-// of Manchester. 
-// All rights reserved. 
-
-// Copyright (C) 2008 - 2009 by Pedro Mendes, Virginia Tech Intellectual 
-// Properties, Inc., EML Research, gGmbH, University of Heidelberg, 
-// and The University of Manchester. 
-// All rights reserved. 
-
-// Copyright (C) 2004 - 2007 by Pedro Mendes, Virginia Tech Intellectual 
-// Properties, Inc. and EML Research, gGmbH. 
-// All rights reserved. 
+// Copyright (C) 2019 - 2026 by Pedro Mendes, Rector and Visitors of the
+// University of Virginia, University of Heidelberg, and University
+// of Connecticut School of Medicine.
+// All rights reserved.
+
+// Copyright (C) 2017 - 2018 by Pedro Mendes, Virginia Tech Intellectual
+// Properties, Inc., University of Heidelberg, and University of
+// of Connecticut School of Medicine.
+// All rights reserved.
+
+// Copyright (C) 2010 - 2016 by Pedro Mendes, Virginia Tech Intellectual
+// Properties, Inc., University of Heidelberg, and The University
+// of Manchester.
+// All rights reserved.
+
+// Copyright (C) 2008 - 2009 by Pedro Mendes, Virginia Tech Intellectual
+// Properties, Inc., EML Research, gGmbH, University of Heidelberg,
+// and The University of Manchester.
+// All rights reserved.
+
+// Copyright (C) 2004 - 2007 by Pedro Mendes, Virginia Tech Intellectual
+// Properties, Inc. and EML Research, gGmbH.
+// All rights reserved.
 
 /*!
     \file AboutDialog.cpp
@@ -46,7 +46,7 @@
 #include <copasi/UI/qtUtilities.h>
 #include <copasi/math/CJitCompiler.h>
 #include <copasi/utilities/CVersion.h>
-#include "copasi/OpenMP/CContext.h"
+#include "copasi/OpenMP/COpenMPConfig.h"
 
 #include <copasi/utilities/json.hpp>
 
@@ -110,34 +110,34 @@ const char *AboutDialog::text =
 QString AboutDialog::getDefaultVersionText()
 {
   QString additionalVersion;
-  #ifdef COPASI_USE_RAPTOR
+#ifdef COPASI_USE_RAPTOR
   additionalVersion = QString("<li>raptor %1</li>").arg(COPASI_RAPTOR_VERSION);
-  #endif
+#endif
 
-  // add additional version info here. 
+  // add additional version info here.
   additionalVersion += QString("<li>json for Modern C++ version %1.%2.%3</li>")
                      .arg(NLOHMANN_JSON_VERSION_MAJOR)
                      .arg(NLOHMANN_JSON_VERSION_MINOR)
                      .arg(NLOHMANN_JSON_VERSION_PATCH);
 
   additionalVersion += QString("<li>statslib 3.4.0</li><li>GCEM 1.18.0</li>");
 
-  #ifdef COPASI_USE_QCUSTOMPLOT
+#ifdef COPASI_USE_QCUSTOMPLOT
   additionalVersion += QString("<li>QCustomPlot %1</li>").arg(QCUSTOMPLOT_VERSION_STR);
-  #endif
+#endif
 
-  #ifdef COPASI_USE_CROSSGUID
+#ifdef COPASI_USE_CROSSGUID
   additionalVersion += QString("<li>CrossGuid</li>");
-  #else
+#else
   additionalVersion += QString("<li>stduuid</li>");
-  #endif
+#endif
 
-  #ifdef ENABLE_OMP
-  additionalVersion += QString("<li>OpenMP %1, %2 threads</li>").arg(COPASI_OMP_VERSION).arg(omp_get_num_threads());
-  #endif
+#ifdef ENABLE_OMP
+  additionalVersion += QString("<li>%1 </li>").arg(FROM_UTF8(COpenMPConfig::Info()));
+#endif
 
   return QString(AboutDialog::text)
-         .arg(FROM_UTF8(CVersion::VERSION.getVersion()))            // 1      
+         .arg(FROM_UTF8(CVersion::VERSION.getVersion()))            // 1
          .arg(QT_VERSION_STR)                                       // 2
          .arg(QWT_VERSION_STR)                                      // 3
          .arg(COPASI_EXPAT_VERSION)                                 // 4

copasi/commandline/CConfigurationFile.cpp

@@ -217,7 +217,7 @@ bool CConfigurationFile::elevateChildren()
     }
 
   mpOpenMPConfig =
-    elevate<COpenMPConfig, CCopasiParameterGroup>(getGroup("OpenMP Configuration"));
+    elevate<COpenMPConfig, CCopasiParameterGroup>(getGroup("Parallel Processing"));
 
   return success;
 }
@@ -302,7 +302,7 @@ void CConfigurationFile::initializeParameter()
   assertGroup("Check for Updates");
 
   mpDisableJIT = assertParameter("Disable JIT Compilation", CCopasiParameter::Type::BOOL, false);
-  assertGroup("OpenMP Configuration");
+  assertGroup("Parallel Processing");
 
   elevateChildren();
 }