#2472: runtime: remove error-prone argv container--directly build ArgConfig during preconfigure

Author: lifflander

src/vt/collective/collective_ops.cc

@@ -46,6 +46,7 @@
 #include "vt/runtime/runtime.h"
 #include "vt/scheduler/scheduler.h"
 #include "vt/runtime/runtime_inst.h"
+#include "vt/configs/arguments/args.h"
 
 #include <memory>
 #include <cstdlib>
@@ -246,6 +247,31 @@ RuntimePtrType CollectiveAnyOps<instance>::initialize(
   return runtime::makeRuntimePtr(rt_ptr);
 }
 
+template <runtime::RuntimeInstType instance>
+/*static*/ RuntimePtrType CollectiveAnyOps<instance>::initializePreconfigured(
+  std::unique_ptr<arguments::ArgConfig> arg_config, MPI_Comm* comm
+) {
+  using vt::runtime::RuntimeInst;
+  using vt::runtime::Runtime;
+  using vt::runtime::eRuntimeInstance;
+
+  MPI_Comm resolved_comm = comm not_eq nullptr ? *comm : MPI_COMM_WORLD;
+
+  RuntimeInst<instance>::rt = std::make_unique<Runtime>(
+    std::move(arg_config), resolved_comm, eRuntimeInstance::DefaultInstance
+  );
+
+  auto rt_ptr = RuntimeInst<instance>::rt.get();
+  if (instance == runtime::RuntimeInstType::DefaultInstance) {
+    // Set global variable for default instance for backward compatibility
+    ::vt::rt = rt_ptr;
+    curRT = rt_ptr;
+  }
+  RuntimeInst<instance>::rt->initialize();
+
+  return runtime::makeRuntimePtr(rt_ptr);
+}
+
 template <runtime::RuntimeInstType instance>
 void CollectiveAnyOps<instance>::setCurrentRuntimeTLS(RuntimeUnsafePtrType in) {
   bool const has_rt = in != nullptr;

src/vt/collective/collective_ops.h

@@ -72,6 +72,20 @@ struct CollectiveAnyOps {
   {
     return initialize(argc, argv, is_interop, comm, appConfig);
   }
+
+  /**
+   * \brief Initialize a VT runtime with arguments preconfigured
+   *
+   * \param[in] arg_config the preconfigured arguments
+   * \param[in] comm the communicator for VT to use
+   *
+   * \return the runtime pointer
+   */
+  static RuntimePtrType initializePreconfigured(
+    std::unique_ptr<arguments::ArgConfig> arg_config,
+    MPI_Comm* comm = nullptr
+  );
+
   static void finalize(RuntimePtrType in_rt = nullptr);
   static void scheduleThenFinalize(RuntimePtrType in_rt = nullptr);
   static void setCurrentRuntimeTLS(RuntimeUnsafePtrType in_rt = nullptr);

src/vt/collective/startup.cc

@@ -46,32 +46,25 @@
 #include "vt/collective/collective_ops.h"
 #include "vt/runtime/runtime_headers.h"
 #include "vt/context/context.h"
+#include "vt/configs/arguments/args.h"
 
 namespace vt {
 
-std::unique_ptr<arguments::ArgvContainer>
-preconfigure(int& argc, char**& argv) {
-  return std::make_unique<arguments::ArgvContainer>(argc, argv);
+std::unique_ptr<arguments::ArgConfig> preconfigure(
+  int& argc, char**& argv, MPI_Comm comm, arguments::AppConfig const* app_config
+) {
+  auto arg_config = std::make_unique<arguments::ArgConfig>();
+  runtime::Runtime::startupMPIConfigArgs(
+    argc, argv, true, comm, arg_config.get(), app_config
+  );
+  return arg_config;
 }
 
 RuntimePtrType initializePreconfigured(
-  MPI_Comm* comm, arguments::AppConfig const* appConfig,
-  arguments::ArgvContainer const* preconfigure_args
+  std::unique_ptr<arguments::ArgConfig> arg_config,
+  MPI_Comm* comm
 ) {
-  arguments::ArgvContainer args =
-    preconfigure_args ? *preconfigure_args : arguments::ArgvContainer{};
-
-  auto argc = args.getArgc();
-  auto argv_container = args.getArgvDeepCopy();
-  auto argv = argv_container.get();
-  bool const is_interop = comm != nullptr;
-  auto ptr = CollectiveOps::initialize(
-    argc, argv, is_interop, comm, appConfig
-  );
-  for (int i = 0; i < argc; i++) {
-    free(argv_container[i]);
-  };
-  return ptr;
+  return CollectiveOps::initializePreconfigured(std::move(arg_config), comm);
 }
 
 // vt::{initialize,finalize} for main ::vt namespace

src/vt/collective/startup.h

@@ -46,28 +46,58 @@
 
 #include "vt/config.h"
 #include "vt/runtime/runtime_headers.h"
-#include "vt/configs/arguments/argv_container.h"
 #include <mpi.h>
 
 namespace vt {
 
-std::unique_ptr<arguments::ArgvContainer>
-preconfigure(int& argc, char**& argv);
+/**
+ * \brief Preconfigure VT with argc/argv. This will remove all VT arguments and
+ * create a configuration for VT that should be passed to
+ * \c initializePreconfigured. Optionally, one many specify an MPI communicator
+ * to use (otherwise, it defaults to \c MPI_COMM_WORLD). Additionally, a
+ * custom app configuration may be passed to directly configure VT.
+ *
+ * \note MPI must be initialized to call this function because if an error
+ * occurs it uses MPI rank to limit how many times the error text gets printed.
+ *
+ * \param[in] argc argc (modifies it to remove VT arguments)
+ * \param[in] argv argv (modifies it to remove VT arguments)
+ * \param[in] comm (optional) MPI communicator to use
+ * \param[in] app_config (optional) base VT configuration to use
+ *
+ * \return the \c arguments::ArgConfig to pass to VT
+ */
+std::unique_ptr<arguments::ArgConfig> preconfigure(
+  int& argc, char**& argv, MPI_Comm comm = MPI_COMM_WORLD,
+  arguments::AppConfig const* app_config = nullptr
+);
+
+/**
+ * \brief Initialize VT after it has been preconfigured
+ *
+ * \param[in] arg_config the arg config
+ * \param[in] comm optional communicator
+ *
+ * \return the runtime pointer
+ */
 RuntimePtrType initializePreconfigured(
-  MPI_Comm* comm = nullptr,
-  arguments::AppConfig const* appConfig = nullptr,
-  arguments::ArgvContainer const* preconfigure_args = nullptr);
+  std::unique_ptr<arguments::ArgConfig> arg_config,
+  MPI_Comm* comm = nullptr
+);
 
 RuntimePtrType initialize(
   int& argc, char**& argv, MPI_Comm* comm = nullptr,
   arguments::AppConfig const* appConfig = nullptr
 );
+
 RuntimePtrType initialize(MPI_Comm* comm = nullptr);
+
 RuntimePtrType initialize(
   int& argc, char**& argv, arguments::AppConfig const* appConfig
 );
 
 void finalize(RuntimePtrType in_rt);
+
 void finalize();
 
 } /* end namespace vt */