Global driver_version switch for mapping input to drivers

src/QMCApp/QMCMain.cpp

@@ -36,6 +36,7 @@
 #include "QMCDrivers/QMCDriver.h"
 #include "QMCDrivers/CloneManager.h"
 #include "Message/Communicate.h"
+#include "Message/UniformCommunicateError.h"
 #include "Concurrency/OpenMP.h"
 #include <queue>
 #include <cstring>
@@ -205,7 +206,6 @@ bool QMCMain::execute()
   }
 #endif
 
-
   NewTimer* t2 = timer_manager.createTimer("Total", timer_level_coarse);
   t2->start();
 
@@ -392,7 +392,14 @@ bool QMCMain::validateXML()
   }
   else
   {
-    myProject.put(result[0]);
+    try
+    {
+      myProject.put(result[0]);
+    }
+    catch (const UniformCommunicateError& ue)
+    {
+      myComm->barrier_and_abort(ue.what());
+    }
   }
   app_summary() << std::endl;
   myProject.get(app_summary());
@@ -578,10 +585,16 @@ bool QMCMain::runQMC(xmlNodePtr cur, bool reuse)
   else
   {
     QMCDriverFactory driver_factory(myProject);
-    QMCDriverFactory::DriverAssemblyState das = driver_factory.readSection(cur);
-
-    qmc_driver = driver_factory.createQMCDriver(cur, das, *qmcSystem, *ptclPool, *psiPool, *hamPool, myComm);
-    append_run = das.append_run;
+    try
+    {
+      QMCDriverFactory::DriverAssemblyState das = driver_factory.readSection(cur);
+      qmc_driver = driver_factory.createQMCDriver(cur, das, *qmcSystem, *ptclPool, *psiPool, *hamPool, myComm);
+      append_run = das.append_run;
+    }
+    catch (const UniformCommunicateError& ue)
+    {
+      myComm->barrier_and_abort(ue.what());
+    }
   }
 
   if (qmc_driver)

src/QMCDrivers/QMCDriverFactory.cpp

@@ -2,7 +2,7 @@
 // This file is distributed under the University of Illinois/NCSA Open Source License.
 // See LICENSE file in top directory for details.
 //
-// Copyright (c) 2016 Jeongnim Kim and QMCPACK developers.
+// Copyright (c) 2022 QMCPACK developers.
 //
 // File developed by: Bryan Clark, bclark@Princeton.edu, Princeton University
 //                    Ken Esler, kpesler@gmail.com, University of Illinois at Urbana-Champaign
@@ -12,6 +12,7 @@
 //                    Raymond Clay III, j.k.rofling@gmail.com, Lawrence Livermore National Laboratory
 //                    Mark Dewing, markdewing@gmail.com, University of Illinois at Urbana-Champaign
 //                    Mark A. Berrill, berrillma@ornl.gov, Oak Ridge National Laboratory
+//                    Peter Doak, doakpw@ornl.gov, Oak Ridge National Laboratory
 //
 // File created by: Jeongnim Kim, jeongnim.kim@gmail.com, University of Illinois at Urbana-Champaign
 //////////////////////////////////////////////////////////////////////////////////////
@@ -40,12 +41,13 @@
 #include "OhmmsData/AttributeSet.h"
 #include "OhmmsData/ParameterSet.h"
 #include "QMCDrivers/WFOpt/QMCWFOptFactoryNew.h"
+#include "Message/UniformCommunicateError.h"
 
 namespace qmcplusplus
 {
 QMCDriverFactory::QMCDriverFactory(const ProjectData& project_data) : project_data_(project_data) {}
 
-/** Read the xml specifify the driver for this QMC section
+/** Read the xml defining the driver for this QMC section
  *
  *  Copy elision should result in just a move of the
  *  DriverAssemblyState
@@ -57,7 +59,7 @@ QMCDriverFactory::QMCDriverFactory(const ProjectData& project_data) : project_da
 QMCDriverFactory::DriverAssemblyState QMCDriverFactory::readSection(xmlNodePtr cur) const
 {
   DriverAssemblyState das;
-  std::string curName((const char*)cur->name);
+  std::string curName(castXMLCharToChar(cur->name));
   std::string update_mode("pbyp");
   std::string qmc_mode;
   std::string multi_tag("no");
@@ -91,43 +93,64 @@ QMCDriverFactory::DriverAssemblyState QMCDriverFactory::readSection(xmlNodePtr c
   infoSummary.flush();
   infoLog.flush();
 
+  // Really by position if you don't write <qmc name="xxx",,,>
+  // you can write <vmc ...> so hacky
   if (curName != "qmc")
     qmc_mode = curName;
 
   const int nchars = qmc_mode.size();
+
+  using DV = ProjectData::DriverVersion;
+  switch (project_data_.get_driver_version())
+  {
+  case DV::BATCH:
 #if defined(QMC_CUDA)
-  if (qmc_mode.find("batch") < nchars)
     throw std::runtime_error("Batched drivers don't support legacy CUDA build! "
                              "Please use OpenMP offload build.");
 #endif
-
-  if (qmc_mode.find("linear_batch") < nchars)
-    das.new_run_type = QMCRunType::LINEAR_OPTIMIZE_BATCH;
-  else if (qmc_mode.find("linear") < nchars)
-    das.new_run_type = QMCRunType::LINEAR_OPTIMIZE;
-  else
-  {
-    if (qmc_mode.find("ptcl") < nchars)
-      das.what_to_do[UPDATE_MODE] = 1;
-    if (qmc_mode.find("mul") < nchars)
-      das.what_to_do[MULTIPLE_MODE] = 1;
-    if (qmc_mode.find("warp") < nchars)
-      das.what_to_do[SPACEWARP_MODE] = 1;
-
-    if (qmc_mode.find("rmc") < nchars)
-      das.new_run_type = QMCRunType::RMC;
-    else if (qmc_mode.find("vmc_batch") < nchars) // order matters here
+    if (qmc_mode.find("vmc") < nchars) // order matters here
       das.new_run_type = QMCRunType::VMC_BATCH;
-    else if (qmc_mode.find("vmc") < nchars)
-      das.new_run_type = QMCRunType::VMC;
-    else if (qmc_mode.find("dmc_batch") < nchars) // order matters here
+    else if (qmc_mode.find("dmc") < nchars) // order matters here
       das.new_run_type = QMCRunType::DMC_BATCH;
-    else if (qmc_mode.find("dmc") < nchars)
-      das.new_run_type = QMCRunType::DMC;
-    else if (qmc_mode == "wftest")
-      das.new_run_type = QMCRunType::WF_TEST;
+    else if (qmc_mode.find("linear") < nchars)
+      das.new_run_type = QMCRunType::LINEAR_OPTIMIZE_BATCH;
     else
-      throw std::runtime_error("qmc method cannot be empty!");
+      throw UniformCommunicateError("QMC mode unknown. Valid modes for batched drivers are : vmc, dmc, linear.");
+    break;
+  // Begin to separate driver version = batch input reading from the legacy input parsing
+  case DV::LEGACY:
+#if defined(QMC_CUDA)
+    if (qmc_mode.find("batch") < nchars)
+      throw std::runtime_error("Batched drivers don't support legacy CUDA build! "
+                               "Please use OpenMP offload build.");
+#endif
+    if (qmc_mode.find("linear_batch") < nchars) // order matters here
+      das.new_run_type = QMCRunType::LINEAR_OPTIMIZE_BATCH;
+    else if (qmc_mode.find("linear") < nchars)
+      das.new_run_type = QMCRunType::LINEAR_OPTIMIZE;
+    else
+    {
+      if (qmc_mode.find("ptcl") < nchars)
+        das.what_to_do[UPDATE_MODE] = 1;
+      if (qmc_mode.find("mul") < nchars)
+        das.what_to_do[MULTIPLE_MODE] = 1;
+      if (qmc_mode.find("warp") < nchars)
+        das.what_to_do[SPACEWARP_MODE] = 1;
+      if (qmc_mode.find("rmc") < nchars)
+        das.new_run_type = QMCRunType::RMC;
+      else if (qmc_mode.find("vmc_batch") < nchars) // order matters here
+        das.new_run_type = QMCRunType::VMC_BATCH;
+      else if (qmc_mode.find("vmc") < nchars)
+        das.new_run_type = QMCRunType::VMC;
+      else if (qmc_mode.find("dmc_batch") < nchars) // order matters here
+        das.new_run_type = QMCRunType::DMC_BATCH;
+      else if (qmc_mode.find("dmc") < nchars)
+        das.new_run_type = QMCRunType::DMC;
+      else if (qmc_mode == "wftest")
+        das.new_run_type = QMCRunType::WF_TEST;
+      else
+        throw std::runtime_error("qmc method cannot be empty!");
+    }
   }
   return das;
 }
@@ -250,9 +273,8 @@ std::unique_ptr<QMCDriverInterface> QMCDriverFactory::createQMCDriver(xmlNodePtr
   else if (das.new_run_type == QMCRunType::LINEAR_OPTIMIZE_BATCH)
   {
 #ifdef MIXED_PRECISION
-    APP_ABORT(
-        "QMCDriverFactory::createQMCDriver : method=\"linear_batch\" is not safe with CPU mixed precision. Please use "
-        "full precision build instead.");
+    APP_ABORT("QMCDriverFactory::createQMCDriver : method=\"linear_batch\" is not safe with CPU mixed precision. "
+              "Please use full precision build instead.");
 #endif
     QMCFixedSampleLinearOptimizeBatched* opt =
         QMCWFOptLinearFactoryNew(cur, project_data_, qmc_system,

src/QMCDrivers/QMCDriverFactory.h

@@ -2,14 +2,15 @@
 // This file is distributed under the University of Illinois/NCSA Open Source License.
 // See LICENSE file in top directory for details.
 //
-// Copyright (c) 2016 Jeongnim Kim and QMCPACK developers.
+// Copyright (c) 2022 QMCPACK developers.
 //
 // File developed by: Bryan Clark, bclark@Princeton.edu, Princeton University
 //                    Ken Esler, kpesler@gmail.com, University of Illinois at Urbana-Champaign
 //                    Jeongnim Kim, jeongnim.kim@gmail.com, University of Illinois at Urbana-Champaign
 //                    Jeremy McMinnis, jmcminis@gmail.com, University of Illinois at Urbana-Champaign
 //                    Raymond Clay III, j.k.rofling@gmail.com, Lawrence Livermore National Laboratory
 //                    Mark Dewing, markdewing@gmail.com, University of Illinois at Urbana-Champaign
+//                    Peter Doak, doakpw@ornl.gov, Oak Ridge National Laboratory
 //
 // File created by: Jeongnim Kim, jeongnim.kim@gmail.com, University of Illinois at Urbana-Champaign
 //////////////////////////////////////////////////////////////////////////////////////
@@ -48,12 +49,23 @@ class QMCDriverFactory
     QMCRunType new_run_type = QMCRunType::DUMMY;
   };
 
+  /** Application uses this constructor
+   *  param[in] project_data    this is stored as a reference and this state controls later behavior.
+   *                            For both the driver factory i.e. driver verion. And the drivers it creates
+   *                            i.e. the section id and max CPU seconds.
+   */
   QMCDriverFactory(const ProjectData& project_data);
 
   /** default constructor **/
   //QMCDriverFactory() ;
 
-  /** read the current QMC Section */
+  /** read the current QMC Section
+   *  In the application context project data can indicate the input be read in the context of
+   *  the batched driver architecture.
+   *  param[in] cur            qmc section node
+   *  param[in] force_batch    forces input to be evaluated as if project driver type = batched
+   *                           false does not force unbatched!
+   */
   DriverAssemblyState readSection(xmlNodePtr cur) const;
 
   /** create a new QMCDriver

src/QMCDrivers/QMCDriverNew.h

@@ -140,8 +140,7 @@ class QMCDriverNew : public QMCDriverInterface, public MPIObjectBase
   * @param nwalkers number of walkers to add
   *
   */
-  void makeLocalWalkers(int nwalkers,
-                        RealType reserve);
+  void makeLocalWalkers(int nwalkers, RealType reserve);
 
   DriftModifierBase& get_drift_modifier() const { return *drift_modifier_; }
 
@@ -199,6 +198,11 @@ class QMCDriverNew : public QMCDriverInterface, public MPIObjectBase
   ///return the i-th random generator
   inline RandomGenerator& getRng(int i) override { return (*Rng[i]); }
 
+  /** intended for logging output and debugging
+   *  you should base behavior on type preferably at compile time or if
+   *  necessary at runtime using and protected by dynamic cast.
+   *  QMCType is primarily for use in the debugger.
+   */
   std::string getEngineName() override { return QMCType; }
   unsigned long getDriverMode() override { return qmc_driver_mode_.to_ulong(); }
 

src/QMCDrivers/tests/ValidQMCInputSections.h

@@ -24,7 +24,7 @@ namespace qmcplusplus
 namespace testing
 {
 // clang-format: off
-constexpr std::array<const char*, 3> valid_vmc_input_sections{
+constexpr std::array<const char*, 4> valid_vmc_input_sections{
     R"(
   <qmc method="vmc" move="pbyp">
     <estimator name="LocalEnergy" hdf5="no" />
@@ -38,8 +38,8 @@ constexpr std::array<const char*, 3> valid_vmc_input_sections{
     <parameter name="usedrift">              no </parameter>
   </qmc>
 )",
-     R"(
-  <qmc method="vmc_batch" move="pbyp">
+    R"(
+  <qmc method="vmc" move="pbyp">
     <parameter name="crowds">                 8 </parameter>
     <estimator name="LocalEnergy" hdf5="no" />
     <parameter name="total_walkers">          32 </parameter>
@@ -51,8 +51,8 @@ constexpr std::array<const char*, 3> valid_vmc_input_sections{
     <parameter name="usedrift">              no </parameter>
   </qmc>
 )",
-     R"(
-  <qmc method="vmc_batch" move="pbyp">
+    R"(
+  <qmc method="vmc" move="pbyp">
     <parameter name="crowds">                 1 </parameter>
     <estimator name="LocalEnergy" hdf5="no" />
     <parameter name="total_walkers">          1 </parameter>
@@ -63,15 +63,29 @@ constexpr std::array<const char*, 3> valid_vmc_input_sections{
     <parameter name="timestep">             1.0 </parameter>
     <parameter name="usedrift">              no </parameter>
   </qmc>
+)",
+    R"(
+  <qmc method="vmc_batch" move="pbyp">
+    <parameter name="crowds">                 8 </parameter>
+    <estimator name="LocalEnergy" hdf5="no" />
+    <parameter name="total_walkers">          32 </parameter>
+    <parameter name="warmupSteps">            5 </parameter>
+    <parameter name="substeps">               5 </parameter>
+    <parameter name="steps">                  1 </parameter>
+    <parameter name="blocks">                 2 </parameter>
+    <parameter name="timestep">             1.0 </parameter>
+    <parameter name="usedrift">              no </parameter>
+  </qmc>
 )"};
 
 
 // to avoid creating a situation where section test xml is in two places
-constexpr int valid_vmc_input_vmc_index       = 0;
-constexpr int valid_vmc_input_vmc_batch_index = 1;
-constexpr int valid_vmc_input_vmc_tiny_index = 2;
+constexpr int valid_vmc_input_vmc_index             = 0;
+constexpr int valid_vmc_input_vmc_batch_index       = 1;
+constexpr int valid_vmc_input_vmc_tiny_index        = 2;
+constexpr int valid_vmc_batch_input_vmc_batch_index = 3;
 
-constexpr std::array<const char*, 2> valid_dmc_input_sections{
+constexpr std::array<const char*, 3> valid_dmc_input_sections{
     R"(
   <qmc method="dmc" move="pbyp" gpu="yes">
     <estimator name="LocalEnergy" hdf5="no" />
@@ -84,7 +98,21 @@ constexpr std::array<const char*, 2> valid_dmc_input_sections{
     <parameter name="nonlocalmoves">         no </parameter>
   </qmc>
 )",
-     R"(
+    R"(
+  <qmc method="dmc" move="pbyp">
+    <parameter name="crowds">                 4 </parameter>
+    <estimator name="LocalEnergy" hdf5="no" />
+    <parameter name="total_walkers">          8 </parameter>
+    <parameter name="reserve">             1.25 </parameter>
+    <parameter name="warmupSteps">            5 </parameter>
+    <parameter name="substeps">               5 </parameter>
+    <parameter name="steps">                  1 </parameter>
+    <parameter name="blocks">                 2 </parameter>
+    <parameter name="timestep">             1.0 </parameter>
+    <parameter name="usedrift">              no </parameter>
+  </qmc>
+)",
+    R"(
   <qmc method="dmc_batch" move="pbyp">
     <parameter name="crowds">                 4 </parameter>
     <estimator name="LocalEnergy" hdf5="no" />
@@ -100,16 +128,18 @@ constexpr std::array<const char*, 2> valid_dmc_input_sections{
 )"};
 
 // to avoid creating a situation where section test xml is in two places
-constexpr int valid_dmc_input_dmc_index       = 0;
-constexpr int valid_dmc_input_dmc_batch_index = 1;
+constexpr int valid_dmc_input_dmc_index             = 0;
+constexpr int valid_dmc_input_dmc_batch_index       = 1;
+constexpr int valid_dmc_batch_input_dmc_batch_index = 2;
 
+/** As far as I can tell these are no longer valid */
 constexpr std::array<const char*, 2> valid_opt_input_sections{
     R"(
-  <qmc method="opt_batch" move="pbyp" gpu="yes">
+  <qmc method="opt" move="pbyp" gpu="yes">
   </qmc>
 )",
     R"(
-  <qmc method="opt_batch" move="pbyp">
+  <qmc method="opt" move="pbyp">
     <optimize method="test" output_param_file="yes"/>
     <parameter name="opt_num_crowds">                 4 </parameter>
     <parameter name="opt_crowd_size">                 8 </parameter>