Merge pull request #1674 from DARMA-tasking/1550-allow-passing-appcon…

…fig-to-vt-during-init

#1550 allow passing appconfig to vt during init

docs/md/tutorial.md

@@ -30,6 +30,43 @@ int main(int argc, char** argv) {
 }
 \endcode
 
+If, for any reason, you want to predefine configuration, you can do it
+by creating `AppConfig` object, setting its members as you wish,
+and passing it to `vt::initialize`:
+
+\code{.cpp}
+int main(int argc, char** argv) {
+  arguments::AppConfig appConfig{};
+  appConfig.vt_lb_name = "RotateLB";
+  appConfig.vt_lb_stats = true;
+
+  vt::initialize(argc, argv, &appConfig);
+   // program here
+  vt::finalize();
+}
+\endcode
+
+You can do also do it if you initialized MPI on your own:
+
+\code{.cpp}
+int main(int argc, char** argv) {
+  MPI_Init(&argc, &argv);
+
+  arguments::AppConfig appConfig{};
+  appConfig.vt_lb_name = "RotateLB";
+  appConfig.vt_lb_stats = true;
+
+  vt::initialize(argc, argv, &MPI_COMM_WORLD, &appConfig);
+   // program here
+  vt::finalize();
+  MPI_Finalize();
+}
+\endcode
+
+It is worth noting that if you run your application with any of vt's command-line arguments and at the same time you define and pass `AppConfig` to `vt::initialize`, CLI arguments have a higher priority. In other words, if you predefine in source code and give from the command line the same vt's argument, but with a different value, the program will use the CLI one.
+
+There is also an option to use configuration file. Refer to CLI11 documentation for details https://cliutils.github.io/CLI11/book/chapters/config.html. Important thing to remember - CLI11 processes configuration file before command line arguments, so in the end command line arguments might overwrite values defined in configuration file.
+
 \section tutorial-walkthrough Tutorial Code Snippets
 
 This page walks through the tutorial that exists in the source code. See

examples/hello_world/objgroup.cc

@@ -57,7 +57,7 @@ struct MyObjGroup {
 };
 
 int main(int argc, char** argv) {
-  vt::initialize(argc, argv, nullptr);
+  vt::initialize(argc, argv);
 
   vt::NodeType this_node = vt::theContext()->getNode();
   vt::NodeType num_nodes = vt::theContext()->getNumNodes();

src/vt/collective/collective_ops.cc

@@ -42,6 +42,7 @@
 */
 
 #include "vt/collective/collective_ops.h"
+#include "vt/context/context.h"
 #include "vt/runtime/runtime.h"
 #include "vt/scheduler/scheduler.h"
 #include "vt/runtime/runtime_inst.h"
@@ -53,10 +54,166 @@
 
 namespace vt {
 
+namespace {
+
+#define printIfOverwritten(opt)                                                \
+  do {                                                                         \
+    if (cliConfig.opt != appConfig.opt) {                                      \
+      ++overwrittens;                                                          \
+      fmt::print(                                                              \
+        "{}\t{}--" #opt "{}\n",                                                \
+        vt_pre, magenta, reset                                                 \
+      );                                                                       \
+    }                                                                          \
+  } while (0)
+
+void printOverwrittens(
+  vt::arguments::AppConfig const &cliConfig,
+  vt::arguments::AppConfig const &appConfig
+) {
+  auto const green   = debug::green();
+  auto const reset   = debug::reset();
+  auto const magenta = debug::magenta();
+  auto const vt_pre  = debug::vtPre();
+
+  fmt::print(
+    "{}{}Predefined options overwritten by CLI arguments:{}\n",
+    vt_pre, green, reset
+  );
+
+  int overwrittens = 0;
+
+  printIfOverwritten(vt_color);
+  printIfOverwritten(vt_no_color);
+  printIfOverwritten(vt_quiet);
+  printIfOverwritten(vt_sched_progress_han);
+  printIfOverwritten(vt_sched_progress_sec);
+  printIfOverwritten(vt_no_sigint);
+  printIfOverwritten(vt_no_sigsegv);
+  printIfOverwritten(vt_no_sigbus);
+  printIfOverwritten(vt_no_terminate);
+  printIfOverwritten(vt_memory_reporters);
+  printIfOverwritten(vt_print_memory_each_phase);
+  printIfOverwritten(vt_print_memory_node);
+  printIfOverwritten(vt_allow_memory_report_with_ps);
+  printIfOverwritten(vt_print_memory_at_threshold);
+  printIfOverwritten(vt_print_memory_threshold);
+  printIfOverwritten(vt_print_memory_sched_poll);
+  printIfOverwritten(vt_print_memory_footprint);
+  printIfOverwritten(vt_no_warn_stack);
+  printIfOverwritten(vt_no_assert_stack);
+  printIfOverwritten(vt_no_abort_stack);
+  printIfOverwritten(vt_no_stack);
+  printIfOverwritten(vt_stack_file);
+  printIfOverwritten(vt_stack_dir);
+  printIfOverwritten(vt_stack_mod);
+  printIfOverwritten(vt_trace);
+  printIfOverwritten(vt_trace_mpi);
+  printIfOverwritten(vt_trace_pmpi);
+  printIfOverwritten(vt_trace_sys_all);
+  printIfOverwritten(vt_trace_sys_term);
+  printIfOverwritten(vt_trace_sys_location);
+  printIfOverwritten(vt_trace_sys_collection);
+  printIfOverwritten(vt_trace_sys_serial_msg);
+  printIfOverwritten(vt_trace_file);
+  printIfOverwritten(vt_trace_dir);
+  printIfOverwritten(vt_trace_mod);
+  printIfOverwritten(vt_trace_flush_size);
+  printIfOverwritten(vt_trace_spec);
+  printIfOverwritten(vt_trace_spec_file);
+  printIfOverwritten(vt_trace_memory_usage);
+  printIfOverwritten(vt_trace_event_polling);
+  printIfOverwritten(vt_trace_irecv_polling);
+  printIfOverwritten(vt_lb);
+  printIfOverwritten(vt_lb_show_spec);
+  printIfOverwritten(vt_lb_quiet);
+  printIfOverwritten(vt_lb_file_name);
+  printIfOverwritten(vt_lb_name);
+  printIfOverwritten(vt_lb_args);
+  printIfOverwritten(vt_lb_interval);
+  printIfOverwritten(vt_lb_stats);
+  printIfOverwritten(vt_lb_stats_compress);
+  printIfOverwritten(vt_lb_stats_dir);
+  printIfOverwritten(vt_lb_stats_file);
+  printIfOverwritten(vt_lb_stats_dir_in);
+  printIfOverwritten(vt_lb_stats_file_in);
+  printIfOverwritten(vt_help_lb_args);
+  printIfOverwritten(vt_no_detect_hang);
+  printIfOverwritten(vt_print_no_progress);
+  printIfOverwritten(vt_epoch_graph_on_hang);
+  printIfOverwritten(vt_epoch_graph_terse);
+  printIfOverwritten(vt_term_rooted_use_ds);
+  printIfOverwritten(vt_term_rooted_use_wave);
+  printIfOverwritten(vt_hang_freq);
+  printIfOverwritten(vt_diag_enable);
+  printIfOverwritten(vt_diag_print_summary);
+  printIfOverwritten(vt_diag_summary_csv_file);
+  printIfOverwritten(vt_diag_summary_file);
+  printIfOverwritten(vt_diag_csv_base_units);
+  printIfOverwritten(vt_pause);
+  printIfOverwritten(vt_no_assert_fail);
+  printIfOverwritten(vt_throw_on_abort);
+  printIfOverwritten(vt_max_mpi_send_size);
+  printIfOverwritten(vt_debug_level);
+  printIfOverwritten(vt_debug_all);
+  printIfOverwritten(vt_debug_none);
+  printIfOverwritten(vt_debug_gen);
+  printIfOverwritten(vt_debug_runtime);
+  printIfOverwritten(vt_debug_active);
+  printIfOverwritten(vt_debug_term);
+  printIfOverwritten(vt_debug_termds);
+  printIfOverwritten(vt_debug_barrier);
+  printIfOverwritten(vt_debug_event);
+  printIfOverwritten(vt_debug_pipe);
+  printIfOverwritten(vt_debug_pool);
+  printIfOverwritten(vt_debug_reduce);
+  printIfOverwritten(vt_debug_rdma);
+  printIfOverwritten(vt_debug_rdma_channel);
+  printIfOverwritten(vt_debug_rdma_state);
+  printIfOverwritten(vt_debug_param);
+  printIfOverwritten(vt_debug_handler);
+  printIfOverwritten(vt_debug_hierlb);
+  printIfOverwritten(vt_debug_temperedlb);
+  printIfOverwritten(vt_debug_scatter);
+  printIfOverwritten(vt_debug_sequence);
+  printIfOverwritten(vt_debug_sequence_vrt);
+  printIfOverwritten(vt_debug_serial_msg);
+  printIfOverwritten(vt_debug_trace);
+  printIfOverwritten(vt_debug_location);
+  printIfOverwritten(vt_debug_lb);
+  printIfOverwritten(vt_debug_vrt);
+  printIfOverwritten(vt_debug_vrt_coll);
+  printIfOverwritten(vt_debug_worker);
+  printIfOverwritten(vt_debug_group);
+  printIfOverwritten(vt_debug_broadcast);
+  printIfOverwritten(vt_debug_objgroup);
+  printIfOverwritten(vt_debug_phase);
+  printIfOverwritten(vt_debug_context);
+  printIfOverwritten(vt_debug_epoch);
+  printIfOverwritten(vt_debug_print_flush);
+  printIfOverwritten(vt_user_1);
+  printIfOverwritten(vt_user_2);
+  printIfOverwritten(vt_user_3);
+  printIfOverwritten(vt_user_int_1);
+  printIfOverwritten(vt_user_int_2);
+  printIfOverwritten(vt_user_int_3);
+  printIfOverwritten(vt_user_str_1);
+  printIfOverwritten(vt_user_str_2);
+  printIfOverwritten(vt_user_str_3);
+  printIfOverwritten(vt_output_config);
+  printIfOverwritten(vt_output_config_file);
+
+  if (overwrittens == 0) {
+    fmt::print("{}\tNone.\n", vt_pre);
+  }
+}
+
+} /* end anon namespace */
+
 template <runtime::RuntimeInstType instance>
 RuntimePtrType CollectiveAnyOps<instance>::initialize(
   int& argc, char**& argv, WorkerCountType const num_workers,
-  bool is_interop, MPI_Comm* comm
+  bool is_interop, MPI_Comm* comm, arguments::AppConfig const* appConfig
 ) {
   using vt::runtime::RuntimeInst;
   using vt::runtime::Runtime;
@@ -66,7 +223,8 @@ RuntimePtrType CollectiveAnyOps<instance>::initialize(
 
 #pragma sst global rt
   RuntimeInst<instance>::rt = std::make_unique<Runtime>(
-    argc, argv, num_workers, is_interop, resolved_comm
+    argc, argv, num_workers, is_interop, resolved_comm,
+    eRuntimeInstance::DefaultInstance, appConfig
   );
 
 #pragma sst global rt
@@ -79,6 +237,12 @@ RuntimePtrType CollectiveAnyOps<instance>::initialize(
 #pragma sst global rt
   RuntimeInst<instance>::rt->initialize();
 
+  // If appConfig is not nullptr, compare CLI arguments with user-defined ones,
+  // and report overwritten ones.
+  if (appConfig && theContext()->getNode() == 0) {
+    printOverwrittens(*rt->getAppConfig(), *appConfig);
+  }
+
   return runtime::makeRuntimePtr(rt_ptr);
 }
 

src/vt/collective/collective_ops.h

@@ -63,7 +63,8 @@ struct CollectiveAnyOps {
   // The general methods that interact with the managed runtime holder
   static RuntimePtrType initialize(
     int& argc, char**& argv, WorkerCountType const num_workers = no_workers,
-    bool is_interop = false, MPI_Comm* comm = nullptr
+    bool is_interop = false, MPI_Comm* comm = nullptr,
+    arguments::AppConfig const* appConfig = nullptr
   );
   static void finalize(RuntimePtrType in_rt = nullptr);
   static void scheduleThenFinalize(

src/vt/collective/startup.cc

@@ -52,14 +52,20 @@ namespace vt {
 // vt::{initialize,finalize} for main ::vt namespace
 RuntimePtrType initialize(
   int& argc, char**& argv, WorkerCountType const num_workers,
-  bool is_interop, MPI_Comm* comm
+  bool is_interop, MPI_Comm* comm, arguments::AppConfig const* appConfig
 ) {
-  return CollectiveOps::initialize(argc,argv,num_workers,is_interop,comm);
+  return CollectiveOps::initialize(
+    argc, argv, num_workers, is_interop, comm, appConfig
+  );
 }
 
-RuntimePtrType initialize(int& argc, char**& argv, MPI_Comm* comm) {
+RuntimePtrType initialize(
+  int& argc, char**& argv, MPI_Comm* comm, arguments::AppConfig const* appConfig
+) {
   bool const is_interop = comm != nullptr;
-  return CollectiveOps::initialize(argc,argv,no_workers,is_interop,comm);
+  return CollectiveOps::initialize(
+    argc, argv, no_workers, is_interop, comm, appConfig
+  );
 }
 
 RuntimePtrType initialize(MPI_Comm* comm) {
@@ -69,6 +75,18 @@ RuntimePtrType initialize(MPI_Comm* comm) {
   return CollectiveOps::initialize(argc,argv,no_workers,is_interop,comm);
 }
 
+RuntimePtrType initialize(
+  int& argc, char**& argv, arguments::AppConfig const* appConfig
+) {
+  return initialize(argc, argv, nullptr, appConfig);
+}
+
+RuntimePtrType initialize(arguments::AppConfig const* appConfig) {
+ int argc = 0;
+ char** argv = nullptr;
+ return initialize(argc, argv, nullptr, appConfig);
+}
+
 void finalize(RuntimePtrType in_rt) {
   if (in_rt) {
     return CollectiveOps::finalize(std::move(in_rt));

src/vt/collective/startup.h

@@ -51,10 +51,17 @@ namespace vt {
 
 RuntimePtrType initialize(
   int& argc, char**& argv, WorkerCountType const num_workers,
-  bool is_interop = false, MPI_Comm* comm = nullptr
+  bool is_interop = false, MPI_Comm* comm = nullptr,
+  arguments::AppConfig const* appConfig = nullptr
+);
+RuntimePtrType initialize(
+  int& argc, char**& argv, MPI_Comm* comm = nullptr,
+  arguments::AppConfig const* appConfig = nullptr
 );
-RuntimePtrType initialize(int& argc, char**& argv, MPI_Comm* comm = nullptr);
 RuntimePtrType initialize(MPI_Comm* comm = nullptr);
+RuntimePtrType initialize(
+  int& argc, char**& argv, arguments::AppConfig const* appConfig
+);
 
 void finalize(RuntimePtrType in_rt);
 void finalize();