MCA: remove deprecated mca_base_param functions (mca_base_param_register_int, mca_base_param_register_string, mca_base_param_environ_variable). Remove all uses of deprecated functions.

cmr:v1.7

This commit was SVN r27451.

ompi/mca/allocator/bucket/allocator_bucket.c

@@ -81,9 +81,8 @@ struct mca_allocator_base_module_t* mca_allocator_bucket_module_init(
 }
 
 int mca_allocator_bucket_module_open(void) {
-
-    int id = mca_base_param_register_int("allocator","bucket","num_buckets", NULL,30);
-    mca_base_param_lookup_int(id,&mca_allocator_num_buckets);
+    (void) mca_base_param_reg_int_name ("allocator", "bucket_num_buckets", NULL, false, false,
+                                        30, &mca_allocator_num_buckets);
     return(OMPI_SUCCESS);
 }
 

ompi/mca/bcol/basesmuma/bcol_basesmuma_component.c

@@ -45,9 +45,10 @@ static int mca_bcol_basesmuma_deregister_ctl_sm(
 static inline int mca_bcol_basesmuma_param_register_int(
         const char* param_name, int default_value)
 {
-    int id = mca_base_param_register_int("bcol","basesmuma",param_name,NULL,default_value);
-    int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
+    int param_value;
+
+    (void) mca_base_param_reg_int (&mca_bcol_basesmuma_component.super.bcol_version, param_name,
+                                   NULL, false, false, default_value, &param_value);
     return param_value;
 }
 

ompi/mca/bml/base/bml_base_open.c

@@ -55,20 +55,16 @@ int mca_bml_base_open(void)
     do {
         int param, value;
 
-        mca_base_param_register_int("bml", NULL, "error_rate_floor", "error_rate_floor", 0);
-        param = mca_base_param_find("bml", NULL, "error_rate_floor");
-        mca_base_param_lookup_int(param, &value);
-        mca_bml_base_error_rate_floor = value;
+        (void) mca_base_param_reg_int_name ("bml", "error_rate_floor", NULL, false, false,
+                                            0, &value);
+        mca_bml_base_error_rate_floor = (double) value;
 
-        mca_base_param_register_int("bml", NULL, "error_rate_ceiling", "error_rate_ceiling", 0);
-        param = mca_base_param_find("bml", NULL, "error_rate_ceiling");
-        mca_base_param_lookup_int(param, &value);
-        mca_bml_base_error_rate_ceiling = value;
+        (void) mca_base_param_reg_int_name ("bml", "error_rate_ceiling", NULL, false, false,
+                                            0, &value);
+        mca_bml_base_error_rate_ceiling = (double) value;
 
-
-        mca_base_param_register_int("bml", NULL, "srand", "srand", 1);
-        param = mca_base_param_find("bml", NULL, "srand");
-        mca_base_param_lookup_int(param, &value);
+        (void) mca_base_param_reg_int_name ("bml", "srand", NULL, false, false,
+                                            1, &value);
 
         /* seed random number generator */
         if(value) {

ompi/mca/btl/base/btl_base_open.c

@@ -124,11 +124,11 @@ int mca_btl_base_open(void)
   OBJ_CONSTRUCT(&mca_btl_base_modules_initialized, opal_list_t);
 
   /* register parameters */
-  mca_base_param_lookup_string(
-      mca_base_param_register_string("btl","base","include",NULL,NULL), &mca_btl_base_include);
-  mca_base_param_lookup_string(
-      mca_base_param_register_string("btl","base","exclude",NULL,NULL), &mca_btl_base_exclude);
-  mca_base_param_reg_int_name("btl", "base_warn_component_unused",
+  (void) mca_base_param_reg_string_name ("btl", "base_include", NULL, false, false, NULL,
+                                         &mca_btl_base_include);
+  (void) mca_base_param_reg_string_name ("btl", "base_exclude", NULL, false, false, NULL,
+                                         &mca_btl_base_exclude);
+  (void) mca_base_param_reg_int_name ("btl", "base_warn_component_unused",
       "This parameter is used to turn on warning messages when certain NICs are not used",
       false, false, 1, &mca_btl_base_warn_component_unused);
 

ompi/mca/btl/btl.h

@@ -31,8 +31,8 @@
  * During library initialization, all available BTL components are
  * loaded and opened via their mca_base_open_component_fn_t
  * function. The BTL open function should register any mca parameters
- * used to tune/adjust the behaviour of the BTL (mca_base_param_register_int(),
- * mca_base_param_register_string()). Note that the open function may fail
+ * used to tune/adjust the behaviour of the BTL (mca_base_param_reg_int(),
+ * mca_base_param_reg_string()). Note that the open function may fail
  * if the resources (e.g. shared libraries, etc) required by the network
  * transport are not available.
  *

ompi/mca/btl/openib/btl_openib_component.c

@@ -622,9 +622,11 @@ static int openib_dereg_mr(void *reg_data, mca_mpool_base_registration_t *reg)
 static inline int param_register_int(const char* param_name, int default_value)
 {
     int param_value = default_value;
-    int id = mca_base_param_register_int("btl", "openib", param_name, NULL,
-            default_value);
-    mca_base_param_lookup_int(id, &param_value);
+
+    (void) mca_base_param_reg_int (&mca_btl_openib_component.super.btl_version,
+                                   param_name, NULL, false, false, default_value,
+                                   &param_value);
+
     return param_value;
 }
 

ompi/mca/btl/sm/btl_sm_component.c

@@ -112,8 +112,11 @@ static inline char* mca_btl_sm_param_register_string(
     const char* default_value)
 {
     char *param_value;
-    int id = mca_base_param_register_string("btl","sm",param_name,NULL,default_value);
-    mca_base_param_lookup_string(id, &param_value);
+
+    (void) mca_base_param_reg_string (&mca_btl_sm_component.super.btl_version,
+                                      param_name, NULL, false, false, default_value,
+                                      &param_value);
+
     return param_value;
 }
 
@@ -121,9 +124,12 @@ static inline int mca_btl_sm_param_register_int(
     const char* param_name,
     int default_value)
 {
-    int id = mca_base_param_register_int("btl","sm",param_name,NULL,default_value);
     int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
+
+    (void) mca_base_param_reg_int (&mca_btl_sm_component.super.btl_version,
+                                   param_name, NULL, false, false, default_value,
+                                   &param_value);
+
     return param_value;
 }
 

ompi/mca/btl/smcuda/btl_smcuda_component.c

@@ -115,8 +115,11 @@ static inline char* mca_btl_smcuda_param_register_string(
     const char* default_value)
 {
     char *param_value;
-    int id = mca_base_param_register_string("btl","sm",param_name,NULL,default_value);
-    mca_base_param_lookup_string(id, &param_value);
+
+    (void) mca_base_param_reg_string (&mca_btl_smcuda_component.super.btl_version,
+                                      param_name, NULL, false, false, default_value,
+                                      &param_value);
+
     return param_value;
 }
 
@@ -124,9 +127,12 @@ static inline int mca_btl_smcuda_param_register_int(
     const char* param_name,
     int default_value)
 {
-    int id = mca_base_param_register_int("btl","sm",param_name,NULL,default_value);
     int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
+
+    (void) mca_base_param_reg_int (&mca_btl_smcuda_component.super.btl_version,
+                                   param_name, NULL, false, false, default_value,
+                                   &param_value);
+
     return param_value;
 }
 

ompi/mca/btl/template/btl_template_component.c

@@ -82,8 +82,11 @@ static inline char* mca_btl_template_param_register_string(
                                                      const char* default_value)
 {
     char *param_value;
-    int id = mca_base_param_register_string("btl","template",param_name,NULL,default_value);
-    mca_base_param_lookup_string(id, &param_value);
+
+    (void) mca_base_param_reg_string (&mca_btl_template_component.super.btl_version,
+                                      param_name, NULL, false, false, default_value,
+                                      &param_value);
+
     return param_value;
 }
 
@@ -91,9 +94,12 @@ static inline int mca_btl_template_param_register_int(
         const char* param_name, 
         int default_value)
 {
-    int id = mca_base_param_register_int("btl","template",param_name,NULL,default_value);
     int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
+
+    (void) mca_base_param_reg_int (&mca_btl_template_component.super.btl_version,
+                                   param_name, NULL, false, false, default_value,
+                                   &param_value);
+
     return param_value;
 }
 

ompi/mca/btl/vader/btl_vader_component.c

@@ -89,19 +89,19 @@ static inline char *mca_btl_vader_param_register_string(const char *param_name,
                                                         const char *default_value)
 {
     char *param_value;
-    int id = mca_base_param_register_string("btl", "vader",
-                                            param_name, NULL,
-                                            default_value);
-    mca_base_param_lookup_string(id, &param_value);
+
+    (void) mca_base_param_reg_string (&mca_btl_vader_component.super.btl_version,
+                                      param_name, NULL, false, false, default_value,
+                                      &param_value);
+
     return param_value;
 }
 
 static inline int mca_btl_vader_param_register_int(const char *param_name,
                                                    int value)
 {
-    int id = mca_base_param_register_int("btl", "vader", param_name,
-                                         NULL, value);
-    mca_base_param_lookup_int(id, &value);
+    (void) mca_base_param_reg_int (&mca_btl_vader_component.super.btl_version,
+                                   param_name, NULL, false, false, value, &value);
     return value;
 }
 

ompi/mca/btl/wv/btl_wv_component.c

@@ -497,9 +497,9 @@ static int wv_dereg_mr(void *reg_data, mca_mpool_base_registration_t *reg)
 static inline int param_register_int(const char* param_name, int default_value)
 {
     int param_value = default_value;
-    int id = mca_base_param_register_int("btl", "wv", param_name, NULL,
-             default_value);
-    mca_base_param_lookup_int(id, &param_value);
+    mca_base_param_reg_int(&mca_btl_wv_component.super.btl_version,
+			   param_name, NULL, false, false, default_value,
+			   &param_value);
     return param_value;
 }
 

ompi/mca/coll/demo/coll_demo_component.c

@@ -86,10 +86,12 @@ const mca_coll_base_component_2_0_0_t mca_coll_demo_component = {
 static int demo_open(void)
 {
     mca_coll_demo_priority_param = 
-        mca_base_param_register_int("coll", "demo", "priority", NULL, 20);
+      mca_base_param_reg_int(&mca_coll_demo_component.collm_version,
+                             "priority", NULL, false, false, 20, NULL);
     mca_coll_demo_verbose_param = 
-        mca_base_param_register_int("coll", "demo", "verbose", NULL, 
-                                    mca_coll_demo_verbose);
+      mca_base_param_reg_int(&mca_coll_demo_component.collm_version,
+                             "verbose", NULL, false, false,
+                             mca_coll_demo_verbose, NULL);
 
     return OMPI_SUCCESS;
 }

ompi/mca/coll/ml/coll_ml_component.c

@@ -54,24 +54,7 @@ const char *mca_coll_ml_component_version_string =
 static int ml_open(void);
 static int ml_close(void);
 static int coll_ml_progress(void);
-/*
-static inline int mca_coll_ml_param_register_int(
-        const char* param_name, int default_value)
-{
-    int id = mca_base_param_register_int("coll","ml",param_name,NULL,default_value);
-    int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
-    return param_value;
-}
-static inline char* mca_coll_ml_param_register_string(
-        const char* param_name, const char* default_value)
-{
-    char *param_value;
-    int id = mca_base_param_register_string("coll","ml",param_name,NULL,default_value);
-    mca_base_param_lookup_string(id, &param_value);
-    return param_value;
-}
-*/
+
 /*
  * Instantiate the public struct with all of our public information
  * and pointers to our public functions in it

ompi/mca/coll/self/coll_self_component.c

@@ -88,7 +88,8 @@ static int self_open(void)
        communicator */
     
     mca_coll_self_priority_param = 
-        mca_base_param_register_int("coll", "self", "priority", NULL, 75);
+      mca_base_param_reg_int (&mca_coll_self_component.collm_version,
+                              "priority", NULL, false, false, 75, NULL);
 
     return OMPI_SUCCESS;
 }

ompi/mca/pml/base/pml_base_bsend.c

@@ -78,7 +78,6 @@ static void* mca_pml_bsend_alloc_segment(
  */
 int mca_pml_base_bsend_init(bool thread_safe)
 {
-    int id = mca_base_param_register_string("pml", "base", "bsend_allocator", NULL, "basic");
     char *name;
     size_t tmp;
 
@@ -90,7 +89,9 @@ int mca_pml_base_bsend_init(bool thread_safe)
     OBJ_CONSTRUCT(&mca_pml_bsend_condition, opal_condition_t);
 
     /* lookup name of the allocator to use for buffered sends */
-    mca_base_param_lookup_string(id, &name);
+    (void) mca_base_param_reg_string_name ("pml", "base_bsend_allocator", NULL, false, false,
+                                           "basic", &name);
+
     if(NULL == (mca_pml_bsend_allocator_component = mca_allocator_component_lookup(name))) {
         free(name);
         return OMPI_ERR_BUFFER;

ompi/mca/pml/bfo/pml_bfo_component.c

@@ -85,9 +85,11 @@ static inline int mca_pml_bfo_param_register_int(
     const char* param_name,
     int default_value)
 {
-    int id = mca_base_param_register_int("pml","bfo",param_name,NULL,default_value);
     int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
+
+    (void) mca_base_param_reg_int (&mca_pml_bfo_component.pmlm_version, param_name,
+                                   NULL, false, false, default_value, &param_value);
+
     return param_value;
 }
 

ompi/mca/pml/csum/pml_csum_component.c

@@ -88,9 +88,11 @@ static inline int mca_pml_csum_param_register_int(
     const char* param_name,
     int default_value)
 {
-    int id = mca_base_param_register_int("pml","csum",param_name,NULL,default_value);
     int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
+
+    (void) mca_base_param_reg_int (&mca_pml_csum_component.pmlm_version, param_name,
+                                   NULL, false, false, default_value, &param_value);
+
     return param_value;
 }
 

ompi/mca/pml/dr/pml_dr_component.c

@@ -70,9 +70,11 @@ static inline int
 mca_pml_dr_param_register_int( const char* param_name,
                                int default_value )
 {
-    int id = mca_base_param_register_int("pml","dr",param_name,NULL,default_value);
     int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
+
+    (void) mca_base_param_reg_int (&mca_pml_dr_component.pmlm_version, param_name,
+                                   NULL, false, false, default_value, &param_value);
+
     return param_value;
 }
 

ompi/mca/pml/example/pml_example_component.c

@@ -51,9 +51,11 @@ mca_pml_base_component_2_0_0_t mca_pml_example_component = {
 static inline int mca_pml_example_param_register_int( const char* param_name,
                                                   int default_value )
 {
-    int id = mca_base_param_register_int("pml","example",param_name,NULL,default_value);
     int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
+
+    (void) mca_base_param_reg_int (&mca_pml_example_component.pmlm_version, param_name,
+                                   NULL, false, false, default_value, &param_value);
+
     return param_value;
 }
 

ompi/mca/pml/ob1/pml_ob1_component.c

@@ -85,9 +85,11 @@ static inline int mca_pml_ob1_param_register_int(
     const char* param_name,
     int default_value)
 {
-    int id = mca_base_param_register_int("pml","ob1",param_name,NULL,default_value);
     int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
+
+    (void) mca_base_param_reg_int (&mca_pml_ob1_component.pmlm_version, param_name,
+                                   NULL, false, false, default_value, &param_value);
+
     return param_value;
 }
 

ompi/mca/pml/v/pml_v_component.c

@@ -237,17 +237,21 @@ static int mca_pml_v_enable(bool enable)
 static inline int mca_pml_v_param_register_int( const char* param_name,
                                                   int default_value )
 {
-    int id = mca_base_param_register_int("pml", "v", param_name, NULL, default_value);
     int param_value = default_value;
-    mca_base_param_lookup_int(id, &param_value);
+
+    (void) mca_base_param_reg_int (&mca_pml_v_component.pmlm_version, param_name,
+                                   NULL, false, false, default_value, &param_value);
+
     return param_value;
 }
 
 static inline char *mca_pml_v_param_register_string( const char* param_name,
                                                   char *default_value )
 {
-    int id = mca_base_param_register_string("pml", "v", param_name, NULL, default_value);
     char *param_value = default_value;
-    mca_base_param_lookup_string(id, &param_value);
+
+    (void) mca_base_param_reg_string (&mca_pml_v_component.pmlm_version, param_name,
+                                      NULL, false, false, default_value, &param_value);
+
     return param_value;
 }

ompi/mca/sbgp/basesmsocket/sbgp_basesmsocket_component.c

@@ -68,9 +68,12 @@ static int mca_sbgp_basesmsocket_init_query(bool enable_progress_threads,
 static inline int mca_sbgp_basesmsocket_param_register_int(
         const char* param_name, int default_value)
 {
-    int id = mca_base_param_register_int("sbgp", "basesmsocket", param_name,NULL,default_value);
     int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
+
+    (void) mca_base_param_reg_int (&mca_sbgp_basesmsocket_component.super.sbgp_version,
+                                   param_name, NULL, false, false, default_value,
+                                   &param_value);
+
     return param_value;
 }
 

ompi/mca/sbgp/basesmuma/sbgp_basesmuma_component.c

@@ -52,9 +52,12 @@ static int mca_sbgp_basesmuma_init_query(bool enable_progress_threads,
 static inline int mca_sbgp_basesmuma_param_register_int(
         const char* param_name, int default_value)
 {
-    int id = mca_base_param_register_int("sbgp","basesmuma",param_name,NULL,default_value);
     int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
+
+    (void) mca_base_param_reg_int (&mca_sbgp_basesmuma_component.super.sbgp_version,
+                                   param_name, NULL, false, false, default_value,
+                                   &param_value);
+
     return param_value;
 }
 

ompi/mca/sbgp/ibnet/sbgp_ibnet_component.c

@@ -49,15 +49,6 @@ static int mca_sbgp_ibnet_close(void);
 static int mca_sbgp_ibnet_init_query(bool enable_progress_threads,
         bool enable_mpi_threads);
 
-static inline int mca_sbgp_ibnet_param_register_int(
-        const char* param_name, int default_value)
-{
-    int id = mca_base_param_register_int("sbgp","ibnet",param_name,NULL,default_value);
-    int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
-    return param_value;
-}
-
 /*
  * Instantiate the public struct with all of our public information
  * and pointers to our public functions in it

ompi/mca/sbgp/p2p/sbgp_p2p_component.c

@@ -52,9 +52,12 @@ static int mca_sbgp_p2p_init_query(bool enable_progress_threads,
 static inline int mca_sbgp_p2p_param_register_int(
         const char* param_name, int default_value)
 {
-    int id = mca_base_param_register_int("sbgp","p2p",param_name,NULL,default_value);
     int param_value = default_value;
-    mca_base_param_lookup_int(id,&param_value);
+
+    (void) mca_base_param_reg_int (&mca_sbgp_p2p_component.super.sbgp_version,
+                                   param_name, NULL, false, false, default_value,
+                                   &param_value);
+
     return param_value;
 }
 

ompi/mca/vprotocol/example/vprotocol_example_component.c

@@ -113,9 +113,12 @@ int mca_vprotocol_example_component_finalize(void)
 static inline int mca_param_register_int( const char* param_name,
                                                   int default_value )
 {
-  int id = mca_base_param_register_int("vprotocol", "example", param_name, NULL, default_value);
   int param_value = default_value;
-  mca_base_param_lookup_int(id, &param_value);
+
+  (void) mca_base_param_reg_int (&mca_vprotocol_example_component.pmlm_version,
+                                 param_name, NULL, false, false, default_value,
+                                 &param_value);
+
   return param_value;
 }
 

ompi/mca/vprotocol/pessimist/vprotocol_pessimist_component.c

@@ -143,17 +143,23 @@ int mca_vprotocol_pessimist_enable(bool enable) {
 static inline int mca_param_register_int( const char* param_name,
                                                   int default_value )
 {
-    int id = mca_base_param_register_int("vprotocol", "pessimist", param_name, NULL, default_value);
     int param_value = default_value;
-    mca_base_param_lookup_int(id, &param_value);
+
+    (void) mca_base_param_reg_int (&mca_vprotocol_pessimist_component.pmlm_version,
+                                   param_name, NULL, false, false, default_value,
+                                   &param_value);
+
     return param_value;
 }
 
 static inline char *mca_param_register_string( const char* param_name,
                                                   char *default_value )
 {
-    int id = mca_base_param_register_string("vprotocol", "pessimist", param_name, NULL, default_value);
     char *param_value = default_value;
-    mca_base_param_lookup_string(id, &param_value);
+
+    (void) mca_base_param_reg_string (&mca_vprotocol_pessimist_component.pmlm_version,
+                                      param_name, NULL, false, false, default_value,
+                                      &param_value);
+
     return param_value;
 }

ompi/tools/ompi-server/ompi-server.c

@@ -82,24 +82,24 @@ static char *report_uri=NULL;
  */
 opal_cmd_line_init_t ompi_server_cmd_line_opts[] = {
     /* Various "obvious" options */
-    { NULL, NULL, NULL, 'h', NULL, "help", 0,
+    { NULL, 'h', NULL, "help", 0,
       &help, OPAL_CMD_LINE_TYPE_BOOL,
       "This help message" },
 
-    { NULL, NULL, NULL, 'd', NULL, "debug", 0,
+    { NULL, 'd', NULL, "debug", 0,
       &debug, OPAL_CMD_LINE_TYPE_BOOL,
         "Debug the Open MPI server" },
         
-    { "orte", "no_daemonize", NULL, '\0', NULL, "no-daemonize", 0,
+    { "orte_no_daemonize", '\0', NULL, "no-daemonize", 0,
       &no_daemonize, OPAL_CMD_LINE_TYPE_BOOL,
       "Don't daemonize into the background" },
     
-    { NULL, NULL, NULL, 'r', NULL, "report-uri", 1,
+    { NULL, 'r', NULL, "report-uri", 1,
       &report_uri, OPAL_CMD_LINE_TYPE_STRING,
       "Report the server's uri on stdout [-], stderr [+], or a file [anything else]"},
 
     /* End of list */
-    { NULL, NULL, NULL, '\0', NULL, NULL, 0,
+    { NULL, '\0', NULL, NULL, 0,
       NULL, OPAL_CMD_LINE_TYPE_NULL, NULL }
 };
 

opal/dss/dss_open_close.c

@@ -193,22 +193,21 @@ int opal_dss_open(void)
     def_type = OPAL_DSS_BUFFER_NON_DESC;
 #endif
 
-    id = mca_base_param_register_int("dss", "buffer", "type",
-                                     "Set the default mode for OpenRTE buffers (0=non-described, 1=described)",
-                                     def_type);
-    mca_base_param_lookup_int(id, &rc);
+    (void) mca_base_param_reg_int_name ("dss", "buffer_type",
+					"Set the default mode for OpenRTE buffers (0=non-described, 1=described)",
+					false, false, def_type, &rc);
     default_buf_type = rc;
 
     /* setup the initial size of the buffer. */
-    id = mca_base_param_register_int("dss", "buffer_initial", "size", NULL, 
-                                     OPAL_DSS_DEFAULT_INITIAL_SIZE);
-    mca_base_param_lookup_int(id, &opal_dss_initial_size);
+    (void) mca_base_param_reg_int_name ("dss", "buffer_initial_size", NULL,
+					false, false, OPAL_DSS_DEFAULT_INITIAL_SIZE,
+					&opal_dss_initial_size);
 
     /* the threshold as to where to stop doubling the size of the buffer 
      * allocated memory and start doing additive increases */
-    id = mca_base_param_register_int("dss", "buffer_threshold", "size", NULL, 
-                                     OPAL_DSS_DEFAULT_THRESHOLD_SIZE);
-    mca_base_param_lookup_int(id, &opal_dss_threshold_size);
+    (void) mca_base_param_reg_int_name ("dss", "buffer_threshold_size", NULL,
+					false, false, OPAL_DSS_DEFAULT_THRESHOLD_SIZE,
+					&opal_dss_threshold_size);
 
     /* Setup the types array */
     OBJ_CONSTRUCT(&opal_dss_types, opal_pointer_array_t);

opal/mca/base/mca_base_cmd_line.c

@@ -62,7 +62,7 @@ int mca_base_cmd_line_setup(opal_cmd_line_t *cmd)
 
     {
         opal_cmd_line_init_t entry = 
-            {"mca", "base", "param_file_prefix", '\0', "am", NULL, 1,
+            {"mca_base_param_file_prefix", '\0', "am", NULL, 1,
              NULL, OPAL_CMD_LINE_TYPE_STRING,
              "Aggregate MCA parameter set file list"
             };
@@ -171,7 +171,7 @@ static void add_to_env(char **params, char **values, char ***env)
        vars of the form OMPI_MCA_*=value. */
 
     for (i = 0; NULL != params && NULL != params[i]; ++i) {
-        name = mca_base_param_environ_variable(params[i], NULL, NULL);
+        name = mca_base_param_env_var (params[i]);
         opal_setenv(name, values[i], true, env);
         free(name);
     }

opal/mca/base/mca_base_components_open.c

@@ -487,9 +487,14 @@ static int open_components(const char *type_name, int output_id,
             if (0 > mca_base_param_find(type_name, 
                                         component->mca_component_name,
                                         "priority")) {
-                mca_base_param_register_int(type_name,
-                                            component->mca_component_name,
-                                            "priority", NULL, 0);
+                char *tmp_name;
+                asprintf (&tmp_name, "%s_priority", component->mca_component_name);
+
+                if (NULL != tmp_name) {
+                    (void) mca_base_param_reg_int_name (type_name, tmp_name, NULL,
+                                                        false, false, 0, NULL);
+                    free (tmp_name);
+                }
             }
             
             cli = OBJ_NEW(mca_base_component_list_item_t);

opal/mca/base/mca_base_param.c

@@ -411,52 +411,6 @@ int mca_base_param_reg_string_name(const char *type,
 }
 
 
-/*
- * Register an integer MCA parameter 
- * (deprecated)
- */
-int mca_base_param_register_int(const char *type_name, 
-                                const char *component_name,
-                                const char *param_name, 
-                                const char *mca_param_name, 
-                                int default_value)
-{
-    int ret;
-    mca_base_param_storage_t storage;
-
-    storage.intval = default_value;
-    ret = param_register(type_name, component_name, param_name, mca_param_name,
-                         MCA_BASE_PARAM_TYPE_INT, false, false,
-                         &storage, NULL, NULL, NULL);
-    return ret;
-}
-
-
-/*
- * Register a string MCA parameter.
- * (deprecated)
- */
-int mca_base_param_register_string(const char *type_name, 
-                                   const char *component_name,
-                                   const char *param_name, 
-                                   const char *mca_param_name,
-                                   const char *default_value)
-{
-    int ret;
-    mca_base_param_storage_t storage;
-
-    if (NULL != default_value) {
-        storage.stringval = (char *) default_value;
-    } else {
-        storage.stringval = NULL;
-    }
-    ret = param_register(type_name, component_name, param_name, mca_param_name,
-                         MCA_BASE_PARAM_TYPE_STRING, false, false,
-                         &storage, NULL, NULL, NULL);
-    return ret;
-}
-
-
 /*
  * Register a synonym name for an existing MCA parameter
  */
@@ -613,56 +567,6 @@ char *mca_base_param_env_var(const char *param_name)
     return name;
 }
 
-/*
- * Make a string suitable for the environment, setting an MCA param
- */
-char *mca_base_param_environ_variable(const char *type,
-                                      const char *component,
-                                      const char *param)
-{
-    size_t len;
-    int id;
-    char *ret = NULL, *name;
-    mca_base_param_t *array;
-
-    if (NULL == type) {
-        return NULL;
-    }
-
-    id = mca_base_param_find(type, component, param);
-    if (0 <= id) {
-        array = OPAL_VALUE_ARRAY_GET_BASE(&mca_base_params, mca_base_param_t);
-        ret = strdup(array[id].mbp_env_var_name);
-    } else {
-        len = strlen(mca_prefix) + strlen(type) + 16;
-        if (NULL != component) {
-            len += strlen(component);
-        }
-        if (NULL != param) {
-            len += strlen(param);
-        }
-        name = (char*)malloc(len);
-        if (NULL == name) {
-            return NULL;
-        }
-        name[0] = '\0';
-        snprintf(name, len, "%s%s", mca_prefix, type);
-        if (NULL != component) {
-            strcat(name, "_");
-            strcat(name, component);
-        }
-        if (NULL != param) {
-            strcat(name, "_");
-            strcat(name, param);
-        }
-        ret = name;
-    }
-
-    /* All done */
-
-    return ret;
-}
-
 
 /*
  * Find the index for an MCA parameter based on its names.

opal/mca/base/mca_base_param.h

@@ -481,7 +481,7 @@ BEGIN_C_DECLS
      * Look up an integer MCA parameter.
      *
      * @param index Index previous returned from
-     * mca_base_param_register_int().
+     * mca_base_param_reg_int().
      * @param value Pointer to int where the parameter value will be
      * stored.
      *
@@ -491,7 +491,7 @@ BEGIN_C_DECLS
      * parameter's current value.
      *
      * The value of a specific MCA parameter can be looked up using the
-     * return value from mca_base_param_register_int().
+     * return value from mca_base_param_reg_int().
      */
     OPAL_DECLSPEC int mca_base_param_lookup_int(int index, int *value);
     
@@ -499,7 +499,7 @@ BEGIN_C_DECLS
      * Look up a string MCA parameter.
      *
      * @param index Index previous returned from
-     * mca_base_param_register_string().
+     * mca_base_param_reg_string().
      * @param value Pointer to (char *) where the parameter value will be
      * stored.
      *
@@ -516,7 +516,7 @@ BEGIN_C_DECLS
      * free()'ed.
      *
      * The value of a specific MCA parameter can be looked up using the
-     * return value from mca_base_param_register_string().
+     * return value from mca_base_param_reg_string().
      */
     OPAL_DECLSPEC int mca_base_param_lookup_string(int index, char **value);
 
@@ -626,11 +626,10 @@ BEGIN_C_DECLS
      * It is not always convenient to widely propagate a parameter's index
      * value, or it may be necessary to look up the parameter from a
      * different component -- where it is not possible to have the return
-     * value from mca_base_param_register_int() or
-     * mca_base_param_register_string().  This function can be used to
-     * look up the index of any registered parameter.  The returned index
-     * can be used with mca_base_param_lookup_int() and
-     * mca_base_param_lookup_string().
+     * value from mca_base_param_reg_int() or mca_base_param_reg_string().
+     * This function can be used to look up the index of any registered
+     * parameter.  The returned index can be used with
+     * mca_base_param_lookup_int() and mca_base_param_lookup_string().
      */
     OPAL_DECLSPEC int mca_base_param_find(const char *type, 
                                           const char *component, 
@@ -754,7 +753,7 @@ OPAL_DECLSPEC int mca_base_param_check_exclusive_string(const char *type_a,
      * Set the "internal" flag on an MCA parameter to true or false.
      *
      * @param index [in] Index previous returned from
-     * mca_base_param_register_string() or mca_base_param_register_int(). 
+     * mca_base_param_reg_string() or mca_base_param_reg_int(). 
      * @param internal [in] Boolean indicating whether the MCA
      * parameter is internal (private) or public.
      *
@@ -853,123 +852,6 @@ OPAL_DECLSPEC int mca_base_param_check_exclusive_string(const char *type_a,
      */
     OPAL_DECLSPEC int mca_base_param_finalize(void);
 
-    /***************************************************************
-     * Deprecated interface
-     ***************************************************************/
-
-    /**
-     * \deprecated
-     *
-     * Register an integer MCA parameter (deprecated).
-     *
-     * @param type_name [in] The MCA type (string).
-     * @param component_name [in] The name of the component (string).
-     * @param param_name [in] The name of the parameter being registered
-     * (string).
-     * @param mca_param_name [in] Optional parameter to override the
-     * user-visible name of this parameter (string).
-     * @param default_value [in] The value that is used for this
-     * parameter if the user does not supply one.
-     *
-     * @retval OPAL_ERROR Upon failure to register the parameter.
-     * @retval index Index value that can be used with
-     * mca_base_param_lookup_int() to retrieve the value of the parameter.
-     *
-     * This function is deprecated.  Use mca_base_param_reg_int() instead.
-     *
-     * This function registers an integer MCA parameter and associates it
-     * with a specific component.
-     *
-     * The default resulting MCA parameter name is
-     * {type_name}[_{component_name}][_{param_name}].
-     *
-     * {component_name} is only included if it is non-NULL.  All
-     * components an should include their name; component frameworks
-     * should pass "base".  It is only permissible for the MCA base
-     * itself to pass NULL for the component_name.
-     *
-     * Likewise, {param_name} is also only included if it is non-NULL.
-     * Components and frameworks can pass NULL for this parameter if
-     * they wish.
-     *
-     * In most cases, mca_param_name should be NULL, in which case the
-     * user-visible name of this parameter will be the default form (as
-     * described above).  Only in rare cases is it necessary (or
-     * advisable) to override the default name -- its use is strongly
-     * discouraged.
-     *
-     * It is permissable to register a (type_name, component_name,
-     * param_name) triple more than once; the same index value will be
-     * returned, but the default value will be changed to reflect the
-     * last registration.
-     */
-    OPAL_DECLSPEC int mca_base_param_register_int(const char *type_name, 
-                                                  const char *component_name,
-                                                  const char *param_name, 
-                                                  const char *mca_param_name,
-                                                  int default_value) /* __opal_attribute_deprecated__ */;
-    
-    /**
-     * \deprecated
-     *
-     * Register a string MCA parameter (deprecated).
-     *
-     * @param type_name [in] The MCA type (string).
-     * @param component_name [in] The name of the component (string).
-     * @param param_name [in] The name of the parameter being registered
-     * (string).
-     * @param mca_param_name [in] Optional parameter to override the
-     * user-visible name of this parameter (string).
-     * @param default_value [in] The value that is used for this
-     * parameter if the user does not supply one.
-     *
-     * @retval OPAL_ERROR Upon failure to register the parameter.
-     * @retval index Index value that can be used with
-     * mca_base_param_lookup_string() to retrieve the value of the
-     * parameter.
-     *
-     * This function is deprecated.  Use mca_base_param_reg_string()
-     * instead.
-     *
-     * Note that if a string value is read in from a file then it will
-     * never be NULL. It will always have a value, even if that value is
-     * the empty string.
-     *
-     * This function is identical to mca_base_param_register_int()
-     * except that you are registering a string parameter with an
-     * associated string default value (which is \em not allowed to be NULL).
-     * See mca_base_param_register_int() for all other details.
-     */
-    OPAL_DECLSPEC int mca_base_param_register_string(const char *type_name, 
-                                                     const char *component_name,
-                                                     const char *param_name, 
-                                                     const char *mca_param_name,
-                                                     const char *default_value) /* __opal_attribute_deprecated__ */;
-
-    /**
-     * \deprecated
-     *
-     * Get the string name corresponding to the MCA parameter
-     * value in the environment (deprecated).
-     *
-     * @param type Name of the type containing the parameter.
-     * @param comp Name of the component containing the parameter.
-     * @param param Name of the parameter.
-     *
-     * @retval string A string suitable for setenv() or appending to
-     * an environ-style string array.
-     * @retval NULL Upon failure.
-     *
-     * This function is deprecated.  Use mca_base_param_env_var()
-     * instead.
-     *
-     * The string that is returned is owned by the caller; if
-     * appropriate, it must be eventually freed by the caller.
-     */
-    OPAL_DECLSPEC char *mca_base_param_environ_variable(const char *type,
-                                                        const char *comp,
-                                                        const char *param) /* __opal_attribute_deprecated__ */;
-
 END_C_DECLS
 
 #endif /* OPAL_MCA_BASE_PARAM_H */

opal/mca/shmem/base/shmem_base_select.c

@@ -96,8 +96,7 @@ opal_shmem_base_runtime_query(mca_base_module_t **best_module,
      * is for internal use only!
      * see odls_base_default_fns.c for more details.
      */
-    env_hint_name = mca_base_param_environ_variable("shmem_RUNTIME_QUERY_hint",
-                                                    NULL, NULL);
+    env_hint_name = mca_base_param_env_var ("shmem_RUNTIME_QUERY_hint");
     env_hint_val = getenv(env_hint_name);
     free(env_hint_name);
 

opal/tools/opal-checkpoint/opal-checkpoint.c

@@ -102,37 +102,37 @@ typedef struct {
 opal_checkpoint_globals_t opal_checkpoint_globals;
 
 opal_cmd_line_init_t cmd_line_opts[] = {
-    { NULL, NULL, NULL, 
+    { NULL, 
       'h', NULL, "help", 
       0,
       &opal_checkpoint_globals.help, OPAL_CMD_LINE_TYPE_BOOL,
       "This help message" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'v', NULL, "verbose", 
       0,
       &opal_checkpoint_globals.verbose, OPAL_CMD_LINE_TYPE_BOOL,
       "Be Verbose" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'q', NULL, "quiet", 
       0,
       &opal_checkpoint_globals.quiet, OPAL_CMD_LINE_TYPE_BOOL,
       "Be Super Quiet" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', NULL, "term", 
       0,
       &opal_checkpoint_globals.term, OPAL_CMD_LINE_TYPE_BOOL,
       "Terminate the application after checkpoint" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'n', NULL, "name",
       1,
       &opal_checkpoint_globals.snapshot_name, OPAL_CMD_LINE_TYPE_STRING,
       "Request a specific snapshot reference." },
 
-    { "crs", "base", "snapshot_dir", 
+    { "crs_base_snapshot_dir", 
       'w', NULL, "where", 
       1,
       &opal_checkpoint_globals.snapshot_loc, OPAL_CMD_LINE_TYPE_STRING,
@@ -141,7 +141,7 @@ opal_cmd_line_init_t cmd_line_opts[] = {
       "the desired directory." },
 
     /* End of list */
-    { NULL, NULL, NULL, '\0', NULL, NULL, 0,
+    { NULL, '\0', NULL, NULL, 0,
       NULL, OPAL_CMD_LINE_TYPE_NULL,
       NULL }
 };

opal/tools/opal-restart/opal-restart.c

@@ -105,56 +105,56 @@ typedef struct {
 opal_restart_globals_t opal_restart_globals;
 
 opal_cmd_line_init_t cmd_line_opts[] = {
-    { NULL, NULL, NULL, 
+    { NULL,
       'h', NULL, "help", 
       0,
       &opal_restart_globals.help, OPAL_CMD_LINE_TYPE_BOOL,
       "This help message" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'v', NULL, "verbose", 
       0,
       &opal_restart_globals.verbose, OPAL_CMD_LINE_TYPE_BOOL,
       "Be Verbose" },
 
-    { NULL, NULL, NULL,
+    { NULL,
       'l', NULL, "location",
       1,
       &opal_restart_globals.snapshot_loc, OPAL_CMD_LINE_TYPE_STRING,
       "Full path to the location of the local snapshot."},
 
-    { NULL, NULL, NULL,
+    { NULL,
       'm', NULL, "metadata",
       1,
       &opal_restart_globals.snapshot_metadata, OPAL_CMD_LINE_TYPE_STRING,
       "Relative path (with respect to --location) to the metadata file."},
 
-    { NULL, NULL, NULL,
+    { NULL,
       'r', NULL, "reference",
       1,
       &opal_restart_globals.snapshot_ref, OPAL_CMD_LINE_TYPE_STRING,
       "Local snapshot reference."},
 
-    { NULL, NULL, NULL,
+    { NULL,
       'c', NULL, "cache",
       1,
       &opal_restart_globals.snapshot_cache, OPAL_CMD_LINE_TYPE_STRING,
       "Possible local cache of the snapshot reference."},
 
-    { NULL, NULL, NULL,
+    { NULL,
       'd', NULL, "decompress",
       1,
       &opal_restart_globals.snapshot_compress, OPAL_CMD_LINE_TYPE_STRING,
       "Decompression component to use."},
 
-    { NULL, NULL, NULL,
+    { NULL,
       'p', NULL, "decompress_postfix",
       1,
       &opal_restart_globals.snapshot_compress_postfix, OPAL_CMD_LINE_TYPE_STRING,
       "Decompression component postfix."},
 
     /* End of list */
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', NULL, NULL, 
       0,
       NULL, OPAL_CMD_LINE_TYPE_NULL,

opal/util/cmd_line.c

@@ -210,8 +210,6 @@ int opal_cmd_line_make_opt3(opal_cmd_line_t *cmd, char short_name,
 {
     opal_cmd_line_init_t e;
 
-    e.ocl_mca_type_name = NULL;
-    e.ocl_mca_component_name = NULL;
     e.ocl_mca_param_name = NULL;
 
     e.ocl_cmd_short_name = short_name;
@@ -993,11 +991,9 @@ static int make_opt(opal_cmd_line_t *cmd, opal_cmd_line_init_t *e)
 
     option->clo_type = e->ocl_variable_type;
     option->clo_variable_dest = e->ocl_variable_dest;
-    if (NULL != e->ocl_mca_type_name) {
+    if (NULL != e->ocl_mca_param_name) {
         option->clo_mca_param_env_var = 
-            mca_base_param_environ_variable(e->ocl_mca_type_name,
-                                            e->ocl_mca_component_name,
-                                            e->ocl_mca_param_name);
+            mca_base_param_env_var (e->ocl_mca_param_name);
     }
 
     /* Append the item, serializing thread access */

opal/util/cmd_line.h

@@ -177,17 +177,8 @@ BEGIN_C_DECLS
      * opal_cmd_line_create().
      */
     struct opal_cmd_line_init_t {
-        /** If want to set an MCA parameter, set its type name here.
-            WARNING: This MCA tuple (type, component, param) will
-            eventually be replaced with a single name! */
-        const char *ocl_mca_type_name;
-        /** If want to set an MCA parameter, set its component name
-            here.  WARNING: This MCA tuple (type, component, param)
-            will eventually be replaced with a single name! */
-        const char *ocl_mca_component_name;
         /** If want to set an MCA parameter, set its parameter name
-            here.  WARNING: This MCA tuple (type, component, param)
-            will eventually be replaced with a single name! */
+            here. */
         const char *ocl_mca_param_name;
 
         /** "Short" name (i.e., "-X", where "X" is a single letter) */

orte/mca/ess/base/ess_base_put.c

@@ -42,7 +42,7 @@ int orte_ess_env_put(orte_std_cntr_t num_procs,
     /* tell the ESS to select the env component - but don't override
      * anything that may have been provided elsewhere
      */
-    if(NULL == (param = mca_base_param_environ_variable("ess",NULL,NULL))) {
+    if(NULL == (param = mca_base_param_env_var ("ess"))) {
         ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
         return ORTE_ERR_OUT_OF_RESOURCE;
     }
@@ -52,7 +52,7 @@ int orte_ess_env_put(orte_std_cntr_t num_procs,
     /* since we want to pass the name as separate components, make sure
      * that the "name" environmental variable is cleared!
      */
-    if(NULL == (param = mca_base_param_environ_variable("orte","ess","name"))) {
+    if(NULL == (param = mca_base_param_env_var ("orte_ess_name"))) {
         ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
         return ORTE_ERR_OUT_OF_RESOURCE;
     }
@@ -60,7 +60,7 @@ int orte_ess_env_put(orte_std_cntr_t num_procs,
     free(param);
 
     asprintf(&value, "%ld", (long) num_procs);
-    if(NULL == (param = mca_base_param_environ_variable("orte","ess","num_procs"))) {
+    if(NULL == (param = mca_base_param_env_var ("orte_ess_num_procs"))) {
         ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
         return ORTE_ERR_OUT_OF_RESOURCE;
     }

orte/mca/ess/pmi/ess_pmi_module.c

@@ -213,7 +213,7 @@ static int rte_init(void)
             ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
             return ORTE_ERR_OUT_OF_RESOURCE;
         }
-        if (NULL == (cs_env = mca_base_param_environ_variable("orte_precondition_transports",NULL,NULL))) {
+        if (NULL == (cs_env = mca_base_param_env_var ("orte_precondition_transports"))) {
             ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
             return ORTE_ERR_OUT_OF_RESOURCE;
         }

orte/mca/odls/base/odls_base_default_fns.c

@@ -669,7 +669,7 @@ static int odls_base_default_setup_fork(orte_app_context_t *context,
     }
     
     /* pass my contact info to the local proc so we can talk */
-    param = mca_base_param_environ_variable("orte","local_daemon","uri");
+    param = mca_base_param_env_var ("orte_local_daemon_uri");
     opal_setenv(param, orte_process_info.my_daemon_uri, true, environ_copy);
     free(param);
     
@@ -677,23 +677,23 @@ static int odls_base_default_setup_fork(orte_app_context_t *context,
      * needs it
      */
     if (NULL != orte_process_info.my_hnp_uri) {
-        param = mca_base_param_environ_variable("orte","hnp","uri");
+        param = mca_base_param_env_var ("orte_hnp_uri");
         opal_setenv(param, orte_process_info.my_hnp_uri, true, environ_copy);
         free(param);
     }
     
     /* setup yield schedule - do not override any user-supplied directive! */
     if (oversubscribed) {
-        param = mca_base_param_environ_variable("mpi", NULL, "yield_when_idle");
+        param = mca_base_param_env_var ("mpi_yield_when_idle");
         opal_setenv(param, "1", false, environ_copy);
     } else {
-        param = mca_base_param_environ_variable("mpi", NULL, "yield_when_idle");
+        param = mca_base_param_env_var ("mpi_yield_when_idle");
         opal_setenv(param, "0", false, environ_copy);
     }
     free(param);
     
     /* set the app_context number into the environment */
-    param = mca_base_param_environ_variable("orte","app","num");
+    param = mca_base_param_env_var ("orte_app_num");
     asprintf(&param2, "%ld", (long)context->idx);
     opal_setenv(param, param2, true, environ_copy);
     free(param);
@@ -712,7 +712,7 @@ static int odls_base_default_setup_fork(orte_app_context_t *context,
     free(param2);
     
     /* pass the number of nodes involved in this job */
-    param = mca_base_param_environ_variable("orte","num","nodes");
+    param = mca_base_param_env_var ("orte_num_nodes");
     asprintf(&param2, "%ld", (long)num_nodes);
     opal_setenv(param, param2, true, environ_copy);
     free(param);
@@ -730,24 +730,24 @@ static int odls_base_default_setup_fork(orte_app_context_t *context,
             obj = hwloc_get_root_obj(opal_hwloc_topology);
             if (NULL != (htmp = (char*)hwloc_obj_get_info_by_name(obj, "CPUType")) ||
                 NULL != (htmp = orte_local_cpu_type)) {
-                param = mca_base_param_environ_variable("orte","cpu","type");
+                param = mca_base_param_env_var ("orte_cpu_type");
                 opal_setenv(param, htmp, true, environ_copy);
                 free(param);
             }
             if (NULL != (htmp = (char*)hwloc_obj_get_info_by_name(obj, "CPUModel")) ||
                 NULL != (htmp = orte_local_cpu_model)) {
-                param = mca_base_param_environ_variable("orte","cpu","model");
+                param = mca_base_param_env_var ("orte_cpu_model");
                 opal_setenv(param, htmp, true, environ_copy);
                 free(param);
             }
         } else {
             if (NULL != orte_local_cpu_type) {
-                param = mca_base_param_environ_variable("orte","cpu","type");
+                param = mca_base_param_env_var ("orte_cpu_type");
                 opal_setenv(param, orte_local_cpu_type, true, environ_copy);
                 free(param);
             }
             if (NULL != orte_local_cpu_model) {
-                param = mca_base_param_environ_variable("orte","cpu","model");
+                param = mca_base_param_env_var ("orte_cpu_model");
                 opal_setenv(param, orte_local_cpu_model, true, environ_copy);
                 free(param);
             }
@@ -763,8 +763,8 @@ static int odls_base_default_setup_fork(orte_app_context_t *context,
      */
     if (NULL != (param2 = opal_shmem_base_best_runnable_component_name())) {
         if (NULL != (param =
-                     mca_base_param_environ_variable("shmem_RUNTIME_QUERY_hint",
-                                                     NULL, NULL))) {
+                     mca_base_param_env_var ("shmem_RUNTIME_QUERY_hint"))) {
+                                             
             opal_setenv(param, param2, true, environ_copy);
             free(param);
         }
@@ -780,7 +780,7 @@ static int odls_base_default_setup_fork(orte_app_context_t *context,
     orte_ess_env_put(vpid_range, num_local_procs, environ_copy);
     
     /* forcibly set the local tmpdir base to match ours */
-    param = mca_base_param_environ_variable("orte","tmpdir","base");
+    param = mca_base_param_env_var ("orte_tmpdir_base");
     opal_setenv(param, orte_process_info.tmpdir_base, true, environ_copy);
     free(param);
 
@@ -802,7 +802,7 @@ static int setup_child(orte_proc_t *child,
         ORTE_ERROR_LOG(rc);
         return rc;
     }
-    if (NULL == (param = mca_base_param_environ_variable("orte","ess","jobid"))) {
+    if (NULL == (param = mca_base_param_env_var ("orte_ess_jobid"))) {
         ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
         rc = ORTE_ERR_OUT_OF_RESOURCE;
         return rc;
@@ -816,7 +816,7 @@ static int setup_child(orte_proc_t *child,
         ORTE_ERROR_LOG(rc);
         return rc;
     }
-    if (NULL == (param = mca_base_param_environ_variable("orte","ess","vpid"))) {
+    if (NULL == (param = mca_base_param_env_var ("orte_ess_vpid"))) {
         ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
         rc = ORTE_ERR_OUT_OF_RESOURCE;
         return rc;
@@ -866,7 +866,7 @@ static int setup_child(orte_proc_t *child,
     asprintf(&value, "%lu", (unsigned long) child->node_rank);
     opal_setenv("OMPI_COMM_WORLD_NODE_RANK", value, true, env);
     /* set an mca param for it too */
-    if(NULL == (param = mca_base_param_environ_variable("orte","ess","node_rank"))) {
+    if(NULL == (param = mca_base_param_env_var ("orte_ess_node_rank"))) {
         ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
         rc = ORTE_ERR_OUT_OF_RESOURCE;
         return rc;
@@ -879,7 +879,7 @@ static int setup_child(orte_proc_t *child,
      * an initial start, but procs would like to know if they are being
      * restarted so they can take appropriate action
      */
-    if (NULL == (param = mca_base_param_environ_variable("orte","num","restarts"))) {
+    if (NULL == (param = mca_base_param_env_var ("orte_num_restarts"))) {
         ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
         rc = ORTE_ERR_OUT_OF_RESOURCE;
         return rc;
@@ -891,7 +891,7 @@ static int setup_child(orte_proc_t *child,
     
     /* if the proc should not barrier in orte_init, tell it */
     if (child->do_not_barrier || 0 < child->restarts) {
-        if (NULL == (param = mca_base_param_environ_variable("orte","do_not","barrier"))) {
+        if (NULL == (param = mca_base_param_env_var ("orte_do_not_barrier"))) {
             ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
             rc = ORTE_ERR_OUT_OF_RESOURCE;
             return rc;

orte/mca/odls/default/odls_default_module.c

@@ -533,13 +533,14 @@ static int do_child(orte_app_context_t* context,
                 /* Set an info MCA param that tells
                    the launched processes that it was bound by us (e.g., so that
                    MPI_INIT doesn't try to bind itself) */
-                param = mca_base_param_environ_variable("orte","bound","at_launch");
+                param = mca_base_param_env_var ("orte_bound_at_launch");
                 opal_setenv(param, "1", true, &environ_copy);
                 free(param);
                 /* ...and provide a nice string representation of what we
                    bound to */
-                param = mca_base_param_environ_variable("orte","base","applied_binding");
+                param = mca_base_param_env_var ("orte_base_applied_binding");
                 opal_setenv(param, child->cpu_bitmap, true, &environ_copy);
+                free (param);
             }
         }
 #endif

orte/mca/plm/base/plm_base_launch_support.c

@@ -283,13 +283,13 @@ void orte_plm_base_setup_job(int fd, short args, void *cbdata)
 
     /* get collective ids for the std MPI operations */
     caddy->jdata->peer_modex = orte_grpcomm_base_get_coll_id();
-    modx_par = mca_base_param_environ_variable("orte", NULL, "peer_modex_id");
+    modx_par = mca_base_param_env_var ("orte_peer_modex_id");
     asprintf(&modx_val, "%d", caddy->jdata->peer_modex);
     caddy->jdata->peer_init_barrier = orte_grpcomm_base_get_coll_id();
-    bar1_par = mca_base_param_environ_variable("orte", NULL, "peer_init_barrier_id");
+    bar1_par = mca_base_param_env_var ("orte_peer_init_barrier_id");
     asprintf(&bar1_val, "%d", caddy->jdata->peer_init_barrier);
     caddy->jdata->peer_fini_barrier = orte_grpcomm_base_get_coll_id();
-    bar2_par = mca_base_param_environ_variable("orte", NULL, "peer_fini_barrier_id");
+    bar2_par = mca_base_param_env_var ("orte_peer_fini_barrier_id");
     asprintf(&bar2_val, "%d", caddy->jdata->peer_fini_barrier);
 
     /* if app recovery is not defined, set apps to defaults */

orte/mca/plm/tm/plm_tm_module.c

@@ -312,7 +312,7 @@ static void launch_daemons(int fd, short args, void *cbdata)
     env = opal_argv_copy(orte_launch_environ);
 
     /* enable local launch by the orteds */
-    var = mca_base_param_environ_variable("plm", NULL, NULL);
+    var = mca_base_param_env_var ("plm");
     opal_setenv(var, "rsh", true, &env);
     free(var);
     

orte/orted/orted_main.c

@@ -125,102 +125,102 @@ static struct {
  */
 opal_cmd_line_init_t orte_cmd_line_opts[] = {
     /* Various "obvious" options */
-    { NULL, NULL, NULL, 'h', NULL, "help", 0,
+    { NULL, 'h', NULL, "help", 0,
       &orted_globals.help, OPAL_CMD_LINE_TYPE_BOOL,
       "This help message" },
 
-    { "orte", "daemon_spin", NULL, 's', NULL, "spin", 0,
+    { "orte_daemon_spin", 's', NULL, "spin", 0,
       &orted_spin_flag, OPAL_CMD_LINE_TYPE_BOOL,
       "Have the orted spin until we can connect a debugger to it" },
 
-    { NULL, NULL, NULL, '\0', NULL, "debug-failure", 1,
+    { NULL, '\0', NULL, "debug-failure", 1,
       &orted_globals.fail, OPAL_CMD_LINE_TYPE_INT,
       "Have the specified orted fail after init for debugging purposes" },
     
-    { NULL, NULL, NULL, '\0', NULL, "debug-failure-delay", 1,
+    { NULL, '\0', NULL, "debug-failure-delay", 1,
       &orted_globals.fail_delay, OPAL_CMD_LINE_TYPE_INT,
       "Have the orted specified for failure delay for the provided number of seconds before failing" },
     
-    { "orte", "debug", NULL, 'd', NULL, "debug", 0,
+    { "orte_debug", 'd', NULL, "debug", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Debug the OpenRTE" },
         
-    { "orte", "daemonize", NULL, '\0', NULL, "daemonize", 0,
+    { "orte_daemonize", '\0', NULL, "daemonize", 0,
       &orted_globals.daemonize, OPAL_CMD_LINE_TYPE_BOOL,
       "Daemonize the orted into the background" },
 
-    { "orte", "debug", "daemons", '\0', NULL, "debug-daemons", 0,
+    { "orte_debug_daemons", '\0', NULL, "debug-daemons", 0,
       &orted_globals.debug, OPAL_CMD_LINE_TYPE_BOOL,
       "Enable debugging of OpenRTE daemons" },
 
-    { "orte", "debug", "daemons_file", '\0', NULL, "debug-daemons-file", 0,
+    { "orte_debug_daemons_file", '\0', NULL, "debug-daemons-file", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Enable debugging of OpenRTE daemons, storing output in files" },
 
-    { NULL, NULL, NULL, '\0', NULL, "hnp", 0,
+    { NULL, '\0', NULL, "hnp", 0,
       &orted_globals.hnp, OPAL_CMD_LINE_TYPE_BOOL,
       "Direct the orted to act as the HNP"},
 
-    { "orte", "hnp", "uri", '\0', NULL, "hnp-uri", 1,
+    { "orte_hnp_uri", '\0', NULL, "hnp-uri", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "URI for the HNP"},
     
-    { "orte", "parent", "uri", '\0', NULL, "parent-uri", 1,
+    { "orte_parent_uri", '\0', NULL, "parent-uri", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "URI for the parent if tree launch is enabled."},
     
-    { "orte", "use", "common_port", '\0', NULL, "use-common-port", 0,
+    { "orte_use_common_port", '\0', NULL, "use-common-port", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Use the same port as the HNP."},
     
-    { NULL, NULL, NULL, '\0', NULL, "tree-spawn", 0,
+    { NULL, '\0', NULL, "tree-spawn", 0,
       &orted_globals.tree_spawn, OPAL_CMD_LINE_TYPE_BOOL,
       "Tree spawn is underway"},
     
-    { NULL, NULL, NULL, '\0', NULL, "set-sid", 0,
+    { NULL, '\0', NULL, "set-sid", 0,
       &orted_globals.set_sid, OPAL_CMD_LINE_TYPE_BOOL,
       "Direct the orted to separate from the current session"},
     
-    { "tmpdir", "base", NULL, '\0', NULL, "tmpdir", 1,
+    { "tmpdir_base", '\0', NULL, "tmpdir", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Set the root for the session directory tree" },
 
-    { NULL, NULL, NULL, '\0', NULL, "report-uri", 1,
+    { NULL, '\0', NULL, "report-uri", 1,
       &orted_globals.uri_pipe, OPAL_CMD_LINE_TYPE_INT,
       "Report this process' uri on indicated pipe"},
 
-    { NULL, NULL, NULL, '\0', NULL, "singleton-died-pipe", 1,
+    { NULL, '\0', NULL, "singleton-died-pipe", 1,
       &orted_globals.singleton_died_pipe, OPAL_CMD_LINE_TYPE_INT,
       "Watch on indicated pipe for singleton termination"},
     
-    { "orte", "output", "filename", '\0', "output-filename", "output-filename", 1,
+    { "orte_output_filename", '\0', "output-filename", "output-filename", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Redirect output from application processes into filename.rank" },
     
-    { "orte", "xterm", NULL, '\0', "xterm", "xterm", 1,
+    { "orte_xterm", '\0', "xterm", "xterm", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Create a new xterm window and display output from the specified ranks there" },
 
-    { "orte", "report", "bindings", '\0', "report-bindings", "report-bindings", 0,
+    { "orte_report_bindings", '\0', "report-bindings", "report-bindings", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Whether to report process bindings to stderr" },
 
-    { "orte", "node", "regex", '\0', "nodes", "nodes", 1,
+    { "orte_node_regex", '\0', "nodes", "nodes", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Regular expression defining nodes in system" },
 
 #if OPAL_HAVE_HWLOC
-    { "orte", "hetero", "nodes", '\0', NULL, "hetero-nodes", 0,
+    { "orte_hetero_nodes", '\0', NULL, "hetero-nodes", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Nodes in cluster may differ in topology, so send the topology back from each node [Default = false]" },
 #endif
 
-    { NULL, NULL, NULL, '\0', "mapreduce", "mapreduce", 0,
+    { NULL, '\0', "mapreduce", "mapreduce", 0,
       &orted_globals.mapreduce, OPAL_CMD_LINE_TYPE_BOOL,
       "Whether to report process bindings to stderr" },
 
     /* End of list */
-    { NULL, NULL, NULL, '\0', NULL, NULL, 0,
+    { NULL, '\0', NULL, NULL, 0,
       NULL, OPAL_CMD_LINE_TYPE_NULL, NULL }
 };
 

orte/tools/orte-checkpoint/orte-checkpoint.c

@@ -147,82 +147,82 @@ typedef struct {
 orte_checkpoint_globals_t orte_checkpoint_globals;
 
 opal_cmd_line_init_t cmd_line_opts[] = {
-    { NULL, NULL, NULL, 
+    { NULL,
       'h', NULL, "help", 
       0,
       &orte_checkpoint_globals.help, OPAL_CMD_LINE_TYPE_BOOL,
       "This help message" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'v', NULL, "verbose", 
       0,
       &orte_checkpoint_globals.verbose, OPAL_CMD_LINE_TYPE_BOOL,
       "Be Verbose" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'V', NULL, NULL, 
       1,
       &orte_checkpoint_globals.verbose_level, OPAL_CMD_LINE_TYPE_INT,
       "Set the verbosity level (For additional debugging information)" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', NULL, "term", 
       0,
       &(orte_checkpoint_globals.term), OPAL_CMD_LINE_TYPE_BOOL,
       "Terminate the application after checkpoint (Cannot be used with --stop)" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', NULL, "stop", 
       0,
       &(orte_checkpoint_globals.stop), OPAL_CMD_LINE_TYPE_BOOL,
       "Send SIGSTOP to application just after checkpoint (checkpoint will not finish until SIGCONT is sent) (Cannot be used with --term)" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'w', NULL, "nowait", 
       0,
       &orte_checkpoint_globals.nowait, OPAL_CMD_LINE_TYPE_BOOL,
       "Do not wait for the application to finish checkpointing before returning" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       's', NULL, "status", 
       0,
       &orte_checkpoint_globals.status, OPAL_CMD_LINE_TYPE_BOOL,
       "Display status messages describing the progression of the checkpoint" },
 
-    { "hnp-jobid", NULL, NULL,
+    { "hnp-jobid",
       '\0', NULL, "hnp-jobid", 
       1,
       &orte_checkpoint_globals.req_hnp, OPAL_CMD_LINE_TYPE_INT,
       "This should be the jobid of the HNP whose applications you wish "
       "to checkpoint." },
 
-    { "hnp-pid", NULL, NULL,
+    { "hnp-pid",
       '\0', NULL, "hnp-pid", 
       1,
       &orte_checkpoint_globals.pid, OPAL_CMD_LINE_TYPE_INT,
       "This should be the pid of the mpirun whose applications you wish "
       "to checkpoint." },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'l', NULL, "list", 
       0,
       &orte_checkpoint_globals.list_only, OPAL_CMD_LINE_TYPE_BOOL,
       "Display a list of checkpoint files available on this machine" },
 
 #if OPAL_ENABLE_CRDEBUG == 1
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "crdebug", "crdebug",
       0,
       &orte_checkpoint_globals.enable_crdebug, OPAL_CMD_LINE_TYPE_BOOL,
       "Enable C/R Enhanced Debugging" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "attach", "attach", 
       0,
       &(orte_checkpoint_globals.attach_debugger), OPAL_CMD_LINE_TYPE_BOOL,
       "Wait for the debugger to attach directly after taking the checkpoint." },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "detach", "detach", 
       0,
       &(orte_checkpoint_globals.detach_debugger), OPAL_CMD_LINE_TYPE_BOOL,
@@ -230,7 +230,7 @@ opal_cmd_line_init_t cmd_line_opts[] = {
 #endif
 
     /* End of list */
-    { NULL, NULL, NULL, '\0', NULL, NULL, 0,
+    { NULL, '\0', NULL, NULL, 0,
       NULL, OPAL_CMD_LINE_TYPE_NULL,
       NULL }
 };

orte/tools/orte-clean/orte-clean.c

@@ -90,26 +90,26 @@ typedef struct {
 orte_clean_globals_t orte_clean_globals;
 
 opal_cmd_line_init_t cmd_line_opts[] = {
-    { NULL, NULL, NULL, 
+    { NULL,
       'h', NULL, "help", 
       0,
       &orte_clean_globals.help, OPAL_CMD_LINE_TYPE_BOOL,
       "This help message" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'v', NULL, "verbose", 
       0,
       &orte_clean_globals.verbose, OPAL_CMD_LINE_TYPE_BOOL,
       "Generate verbose output" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'd', NULL, "debug", 
       0,
       &orte_clean_globals.debug, OPAL_CMD_LINE_TYPE_BOOL,
       "Extra debug output for developers to ensure that orte-clean is working" },
 
     /* End of list */
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', NULL, NULL, 
       0,
       NULL, OPAL_CMD_LINE_TYPE_NULL,

orte/tools/orte-migrate/orte-migrate.c

@@ -124,51 +124,51 @@ typedef struct {
 orte_migrate_globals_t orte_migrate_globals;
 
 opal_cmd_line_init_t cmd_line_opts[] = {
-    { NULL, NULL, NULL, 
+    { NULL,
       'h', NULL, "help", 
       0,
       &orte_migrate_globals.help, OPAL_CMD_LINE_TYPE_BOOL,
       "This help message" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'v', NULL, "verbose", 
       0,
       &orte_migrate_globals.verbose, OPAL_CMD_LINE_TYPE_BOOL,
       "Be Verbose" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'V', NULL, NULL, 
       1,
       &orte_migrate_globals.verbose_level, OPAL_CMD_LINE_TYPE_INT,
       "Set the verbosity level (For additional debugging information)" },
 
-    { "hnp-pid", NULL, NULL,
+    { "hnp-pid",
       '\0', NULL, "hnp-pid", 
       1,
       &orte_migrate_globals.pid, OPAL_CMD_LINE_TYPE_INT,
       "This should be the pid of the mpirun whose applications you wish "
       "to migrate." },
 
-    { NULL, NULL, NULL,
+    { NULL,
       'x', NULL, "off", 
       1,
       &orte_migrate_globals.off_nodes, OPAL_CMD_LINE_TYPE_STRING,
       "List of nodes to migrate off of (comma separated)" },
 
-    { NULL, NULL, NULL,
+    { NULL,
       'r', NULL, "ranks", 
       1,
       &orte_migrate_globals.off_procs, OPAL_CMD_LINE_TYPE_STRING,
       "List of MPI_COMM_WORLD ranks to migrate (comma separated)" },
 
-    { NULL, NULL, NULL,
+    { NULL,
       't', NULL, "onto", 
       1,
       &orte_migrate_globals.onto_nodes, OPAL_CMD_LINE_TYPE_STRING,
       "List of nodes to migrate onto (comma separated)" },
 
     /* End of list */
-    { NULL, NULL, NULL, '\0', NULL, NULL, 0,
+    { NULL, '\0', NULL, NULL, 0,
       NULL, OPAL_CMD_LINE_TYPE_NULL,
       NULL }
 };

orte/tools/orte-ps/orte-ps.c

@@ -167,50 +167,50 @@ typedef struct {
 orte_ps_globals_t orte_ps_globals;
 
 opal_cmd_line_init_t cmd_line_opts[] = {
-    { NULL, NULL, NULL, 
+    { NULL,
       'h', NULL, "help", 
       0,
       &orte_ps_globals.help, OPAL_CMD_LINE_TYPE_BOOL,
       "This help message" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'v', NULL, "verbose", 
       0,
       &orte_ps_globals.verbose, OPAL_CMD_LINE_TYPE_BOOL,
       "Be Verbose" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', NULL, "parseable", 
       0,
       &orte_ps_globals.parseable, OPAL_CMD_LINE_TYPE_BOOL,
       "Provide parseable output" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', NULL, "daemons", 
       0,
      &orte_ps_globals.daemons, OPAL_CMD_LINE_TYPE_INT,
       "Display daemon job information" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'j', NULL, "jobid", 
       1,
       &orte_ps_globals.jobid, OPAL_CMD_LINE_TYPE_INT,
       "Specify a local jobid for the given mpirun - a value from 0 to N" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'p', NULL, "pid", 
       1,
       &orte_ps_globals.pid, OPAL_CMD_LINE_TYPE_INT,
       "Specify mpirun pid" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'n', NULL, "nodes", 
       0,
       &orte_ps_globals.nodes, OPAL_CMD_LINE_TYPE_INT,
       "Display Node Information" },
 
     /* End of list */
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', NULL, NULL, 
       0,
       NULL, OPAL_CMD_LINE_TYPE_NULL,

orte/tools/orte-restart/orte-restart.c

@@ -109,70 +109,70 @@ typedef struct {
 orte_restart_globals_t orte_restart_globals;
 
 opal_cmd_line_init_t cmd_line_opts[] = {
-    { NULL, NULL, NULL, 
+    { NULL,
       'h', NULL, "help", 
       0,
       &orte_restart_globals.help, OPAL_CMD_LINE_TYPE_BOOL,
       "This help message" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'v', NULL, "verbose", 
       0,
       &orte_restart_globals.verbose, OPAL_CMD_LINE_TYPE_BOOL,
       "Be Verbose" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', NULL, "fork", 
       0,
       &orte_restart_globals.forked, OPAL_CMD_LINE_TYPE_BOOL,
       "Fork off a new process which is the restarted process instead of "
       "replacing orte_restart" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       's', NULL, "seq", 
       1,
       &orte_restart_globals.seq_number, OPAL_CMD_LINE_TYPE_INT,
       "The sequence number of the checkpoint to start from. "
       "(Default: -1, or most recent)" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "hostfile", "hostfile", 
       1,
       &orte_restart_globals.hostfile, OPAL_CMD_LINE_TYPE_STRING,
       "Provide a hostfile to use for launch" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "machinefile", "machinefile", 
       1,
       &orte_restart_globals.hostfile, OPAL_CMD_LINE_TYPE_STRING,
       "Provide a hostfile to use for launch" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'i', NULL, "info", 
       0,
       &orte_restart_globals.info_only, OPAL_CMD_LINE_TYPE_BOOL,
       "Display information about the checkpoint" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       'a', NULL, "apponly", 
       0,
       &orte_restart_globals.app_only, OPAL_CMD_LINE_TYPE_BOOL,
       "Only create the app context file, do not restart from it" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', NULL, "showme", 
       0,
       &orte_restart_globals.showme, OPAL_CMD_LINE_TYPE_BOOL,
       "Display the full command line that would have been exec'ed." },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "mpirun_opts", "mpirun_opts", 
       1,
       &orte_restart_globals.mpirun_opts, OPAL_CMD_LINE_TYPE_STRING,
       "Command line options to pass directly to mpirun (be sure to quote long strings, and escape internal quotes)" },
 
 #if OPAL_ENABLE_CRDEBUG == 1
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "crdebug", "crdebug",
       0,
       &orte_restart_globals.enable_crdebug, OPAL_CMD_LINE_TYPE_BOOL,
@@ -180,7 +180,7 @@ opal_cmd_line_init_t cmd_line_opts[] = {
 #endif
 
     /* End of list */
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', NULL, NULL, 
       0,
       NULL, OPAL_CMD_LINE_TYPE_NULL,

orte/tools/orte-top/orte-top.c

@@ -108,56 +108,56 @@ static bool p_found = false;
 #define MAX_LINES 20
 
 opal_cmd_line_init_t cmd_line_opts[] = {
-    { NULL, NULL, NULL, 
+    { NULL,
       'h', NULL, "help", 
       0,
       &help, OPAL_CMD_LINE_TYPE_BOOL,
       "This help message" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "pid", "pid", 
       1,
       &hnppidstr, OPAL_CMD_LINE_TYPE_STRING,
       "The pid of the mpirun that you wish to query/monitor" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "uri", "uri", 
       1,
       &hnpuristr, OPAL_CMD_LINE_TYPE_STRING,
       "The uri of the mpirun that you wish to query/monitor" },
     
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "rank", "rank", 
       1,
       &ranks, OPAL_CMD_LINE_TYPE_STRING,
       "Rank whose resource usage is to be displayed/monitored" },
 
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "update-rate", "update-rate", 
       1,
       &update_rate, OPAL_CMD_LINE_TYPE_INT,
       "Number of seconds between updates" },
     
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "timestamp", "timestamp", 
       0,
       &timestamp, OPAL_CMD_LINE_TYPE_BOOL,
       "Time stamp each sample" },
     
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "log-file", "log-file", 
       1,
       &logfile, OPAL_CMD_LINE_TYPE_STRING,
       "Output file for returned statistics" },
  
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', "bynode", "bynode", 
       0,
       &bynode, OPAL_CMD_LINE_TYPE_BOOL,
       "Group statistics by node, sorted by rank within each node" },
 
     /* End of list */
-    { NULL, NULL, NULL, 
+    { NULL,
       '\0', NULL, NULL, 
       0,
       NULL, OPAL_CMD_LINE_TYPE_NULL,

orte/tools/orterun/orterun.c

@@ -159,374 +159,374 @@ static bool globals_init = false;
 
 static opal_cmd_line_init_t cmd_line_init[] = {
     /* Various "obvious" options */
-    { NULL, NULL, NULL, 'h', NULL, "help", 0,
+    { NULL, 'h', NULL, "help", 0,
       &orterun_globals.help, OPAL_CMD_LINE_TYPE_BOOL,
       "This help message" },
-    { NULL, NULL, NULL, 'V', NULL, "version", 0,
+    { NULL, 'V', NULL, "version", 0,
       &orterun_globals.version, OPAL_CMD_LINE_TYPE_BOOL,
       "Print version and exit" },
-    { NULL, NULL, NULL, 'v', NULL, "verbose", 0,
+    { NULL, 'v', NULL, "verbose", 0,
       &orterun_globals.verbose, OPAL_CMD_LINE_TYPE_BOOL,
       "Be verbose" },
-    { "orte", "execute", "quiet", 'q', NULL, "quiet", 0,
+    { "orte_execute_quiet", 'q', NULL, "quiet", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Suppress helpful messages" },
-    { NULL, NULL, NULL, '\0', "report-pid", "report-pid", 1,
+    { NULL, '\0', "report-pid", "report-pid", 1,
       &orterun_globals.report_pid, OPAL_CMD_LINE_TYPE_STRING,
       "Printout pid on stdout [-], stderr [+], or a file [anything else]" },
-    { NULL, NULL, NULL, '\0', "report-uri", "report-uri", 1,
+    { NULL, '\0', "report-uri", "report-uri", 1,
       &orterun_globals.report_uri, OPAL_CMD_LINE_TYPE_STRING,
       "Printout URI on stdout [-], stderr [+], or a file [anything else]" },
     
     /* exit status reporting */
-    { "orte", "report", "child_jobs_separately", '\0', "report-child-jobs-separately", "report-child-jobs-separately", 0,
+    { "orte_report_child_jobs_separately", '\0', "report-child-jobs-separately", "report-child-jobs-separately", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Return the exit status of the primary job only" },
     
     /* hetero apps */
-    { "orte", "hetero", "apps", '\0', NULL, "hetero-apps", 0,
+    { "orte_hetero_apps", '\0', NULL, "hetero-apps", 0,
         NULL, OPAL_CMD_LINE_TYPE_BOOL,
     "Indicates that multiple app_contexts are being provided that are a mix of 32/64 bit binaries" },
     
     /* select XML output */
-    { "orte", "xml", "output", '\0', "xml", "xml", 0,
+    { "orte_xml_output", '\0', "xml", "xml", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Provide all output in XML format" },
-    { "orte", "xml", "file", '\0', "xml-file", "xml-file", 1,
+    { "orte_xml_file", '\0', "xml-file", "xml-file", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Provide all output in XML format to the specified file" },
 
     /* tag output */
-    { "orte", "tag", "output", '\0', "tag-output", "tag-output", 0,
+    { "orte_tag_output", '\0', "tag-output", "tag-output", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Tag all output with [job,rank]" },
-    { "orte", "timestamp", "output", '\0', "timestamp-output", "timestamp-output", 0,
+    { "orte_timestamp_output", '\0', "timestamp-output", "timestamp-output", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Timestamp all application process output" },
-    { "orte", "output", "filename", '\0', "output-filename", "output-filename", 1,
+    { "orte_output_filename", '\0', "output-filename", "output-filename", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Redirect output from application processes into filename.rank" },
-    { "orte", "xterm", NULL, '\0', "xterm", "xterm", 1,
+    { "orte_xterm", '\0', "xterm", "xterm", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Create a new xterm window and display output from the specified ranks there" },
 
     /* select stdin option */
-    { NULL, NULL, NULL, '\0', "stdin", "stdin", 1,
+    { NULL, '\0', "stdin", "stdin", 1,
       &orterun_globals.stdin_target, OPAL_CMD_LINE_TYPE_STRING,
       "Specify procs to receive stdin [rank, all, none] (default: 0, indicating rank 0)" },
     
     /* Specify the launch agent to be used */
-    { "orte", "launch", "agent", '\0', "launch-agent", "launch-agent", 1,
+    { "orte_launch_agent", '\0', "launch-agent", "launch-agent", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Command used to start processes on remote nodes (default: orted)" },
     
     /* Preload the binary on the remote machine */
-    { NULL, NULL, NULL, 's', NULL, "preload-binary", 0,
+    { NULL, 's', NULL, "preload-binary", 0,
       &orterun_globals.preload_binaries, OPAL_CMD_LINE_TYPE_BOOL,
       "Preload the binary on the remote machine before starting the remote process." },
 
     /* Preload files on the remote machine */
-    { NULL, NULL, NULL, '\0', NULL, "preload-files", 1,
+    { NULL, '\0', NULL, "preload-files", 1,
       &orterun_globals.preload_files, OPAL_CMD_LINE_TYPE_STRING,
       "Preload the comma separated list of files to the remote machines current working directory before starting the remote process." },
 
 #if OPAL_ENABLE_FT_CR == 1
     /* Tell SStore to preload a snapshot before launch */
-    { NULL, NULL, NULL, '\0', NULL, "sstore-load", 1,
+    { NULL, '\0', NULL, "sstore-load", 1,
       &orterun_globals.sstore_load, OPAL_CMD_LINE_TYPE_STRING,
       "Internal Use Only! Tell SStore to preload a snapshot before launch." },
 #endif
 
     /* Use an appfile */
-    { NULL, NULL, NULL, '\0', NULL, "app", 1,
+    { NULL, '\0', NULL, "app", 1,
       &orterun_globals.appfile, OPAL_CMD_LINE_TYPE_STRING,
       "Provide an appfile; ignore all other command line options" },
 
     /* Number of processes; -c, -n, --n, -np, and --np are all
        synonyms */
-    { NULL, NULL, NULL, 'c', "np", "np", 1,
+    { NULL, 'c', "np", "np", 1,
       &orterun_globals.num_procs, OPAL_CMD_LINE_TYPE_INT,
       "Number of processes to run" },
-    { NULL, NULL, NULL, '\0', "n", "n", 1,
+    { NULL, '\0', "n", "n", 1,
       &orterun_globals.num_procs, OPAL_CMD_LINE_TYPE_INT,
       "Number of processes to run" },
     
     /* maximum size of VM - typically used to subdivide an allocation */
-    { "orte", "max", "vm_size", '\0', "max-vm-size", "max-vm-size", 1,
+    { "orte_max_vm_size", '\0', "max-vm-size", "max-vm-size", 1,
       NULL, OPAL_CMD_LINE_TYPE_INT,
       "Number of processes to run" },
 
     /* Set a hostfile */
-    { NULL, NULL, NULL, '\0', "hostfile", "hostfile", 1,
+    { NULL, '\0', "hostfile", "hostfile", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Provide a hostfile" },
-    { NULL, NULL, NULL, '\0', "machinefile", "machinefile", 1,
+    { NULL, '\0', "machinefile", "machinefile", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Provide a hostfile" },
-    { "orte", "default", "hostfile", '\0', "default-hostfile", "default-hostfile", 1,
+    { "orte_default_hostfile", '\0', "default-hostfile", "default-hostfile", 1,
         NULL, OPAL_CMD_LINE_TYPE_STRING,
     "Provide a default hostfile" },
-    { "opal", "if", "do_not_resolve", '\0', "do-not-resolve", "do-not-resolve", 0,
+    { "opal_if_do_not_resolve", '\0', "do-not-resolve", "do-not-resolve", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Do not attempt to resolve interfaces" },
     
     /* uri of Open MPI server, or at least where to get it */
-    { NULL, NULL, NULL, '\0', "ompi-server", "ompi-server", 1,
+    { NULL, '\0', "ompi-server", "ompi-server", 1,
       &orterun_globals.ompi_server, OPAL_CMD_LINE_TYPE_STRING,
       "Specify the URI of the Open MPI server, or the name of the file (specified as file:filename) that contains that info" },
-    { NULL, NULL, NULL, '\0', "wait-for-server", "wait-for-server", 0,
+    { NULL, '\0', "wait-for-server", "wait-for-server", 0,
       &orterun_globals.wait_for_server, OPAL_CMD_LINE_TYPE_BOOL,
       "If ompi-server is not already running, wait until it is detected (default: false)" },
-    { NULL, NULL, NULL, '\0', "server-wait-time", "server-wait-time", 1,
+    { NULL, '\0', "server-wait-time", "server-wait-time", 1,
       &orterun_globals.server_wait_timeout, OPAL_CMD_LINE_TYPE_INT,
       "Time in seconds to wait for ompi-server (default: 10 sec)" },
     
-    { "carto", "file", "path", '\0', "cf", "cartofile", 1,
+    { "carto_file_path", '\0', "cf", "cartofile", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Provide a cartography file" },
 
-    { "orte", "rankfile", NULL, '\0', "rf", "rankfile", 1,
+    { "orte_rankfile", '\0', "rf", "rankfile", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Provide a rankfile file" },
 
     /* Export environment variables; potentially used multiple times,
        so it does not make sense to set into a variable */
-    { NULL, NULL, NULL, 'x', NULL, NULL, 1,
+    { NULL, 'x', NULL, NULL, 1,
       NULL, OPAL_CMD_LINE_TYPE_NULL,
       "Export an environment variable, optionally specifying a value (e.g., \"-x foo\" exports the environment variable foo and takes its value from the current environment; \"-x foo=bar\" exports the environment variable name foo and sets its value to \"bar\" in the started processes)" },
 
       /* Mapping controls */
-    { "rmaps", "base", "display_map", '\0', "display-map", "display-map", 0,
+    { "rmaps_base_display_map", '\0', "display-map", "display-map", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Display the process map just before launch"},
-    { "rmaps", "base", "display_devel_map", '\0', "display-devel-map", "display-devel-map", 0,
+    { "rmaps_base_display_devel_map", '\0', "display-devel-map", "display-devel-map", 0,
        NULL, OPAL_CMD_LINE_TYPE_BOOL,
        "Display a detailed process map (mostly intended for developers) just before launch"},
-    { "rmaps", "base", "display_topo_with_map", '\0', "display-topo", "display-topo", 0,
+    { "rmaps_base_display_topo_with_map", '\0', "display-topo", "display-topo", 0,
        NULL, OPAL_CMD_LINE_TYPE_BOOL,
        "Display the topology as part of the process map (mostly intended for developers) just before launch"},
-    { "rmaps", "base", "display_diffable_map", '\0', "display-diffable-map", "display-diffable-map", 0,
+    { "rmaps_base_display_diffable_map", '\0', "display-diffable-map", "display-diffable-map", 0,
        NULL, OPAL_CMD_LINE_TYPE_BOOL,
        "Display a diffable process map (mostly intended for developers) just before launch"},
-    { NULL, NULL, NULL, 'H', "host", "host", 1,
+    { NULL, 'H', "host", "host", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "List of hosts to invoke processes on" },
-    { "rmaps", "base", "no_schedule_local", '\0', "nolocal", "nolocal", 0,
+    { "rmaps_base_no_schedule_local", '\0', "nolocal", "nolocal", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Do not run any MPI applications on the local node" },
-    { "rmaps", "base", "no_oversubscribe", '\0', "nooversubscribe", "nooversubscribe", 0,
+    { "rmaps_base_no_oversubscribe", '\0', "nooversubscribe", "nooversubscribe", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Nodes are not to be oversubscribed, even if the system supports such operation"},
-    { "rmaps", "base", "oversubscribe", '\0', "oversubscribe", "oversubscribe", 0,
+    { "rmaps_base_oversubscribe", '\0', "oversubscribe", "oversubscribe", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Nodes are allowed to be oversubscribed, even on a managed system"},
 #if 0
-    { "rmaps", "base", "cpus_per_rank", '\0', "cpus-per-proc", "cpus-per-proc", 1,
+    { "rmaps_base_cpus_per_rank", '\0', "cpus-per-proc", "cpus-per-proc", 1,
       NULL, OPAL_CMD_LINE_TYPE_INT,
       "Number of cpus to use for each process [default=1]" },
-    { "rmaps", "base", "cpus_per_rank", '\0', "cpus-per-rank", "cpus-per-rank", 1,
+    { "rmaps_base_cpus_per_rank", '\0', "cpus-per-rank", "cpus-per-rank", 1,
       NULL, OPAL_CMD_LINE_TYPE_INT,
       "Synonym for cpus-per-proc" },
 #endif
 
     /* backward compatiblity */
-    { "rmaps", "base", "bynode", '\0', "bynode", "bynode", 0,
+    { "rmaps_base_bynode", '\0', "bynode", "bynode", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Whether to map and rank processes round-robin by node" },
-    { "rmaps", "base", "byslot", '\0', "byslot", "byslot", 0,
+    { "rmaps_base_byslot", '\0', "byslot", "byslot", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Whether to map and rank processes round-robin by slot" },
 
     /* Nperxxx options that do not require topology and are always
      * available - included for backwards compatibility
      */
-    { "rmaps", "ppr", "pernode", '\0', "pernode", "pernode", 0,
+    { "rmaps_ppr_pernode", '\0', "pernode", "pernode", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Launch one process per available node" },
-    { "rmaps", "ppr", "n_pernode", '\0', "npernode", "npernode", 1,
+    { "rmaps_ppr_n_pernode", '\0', "npernode", "npernode", 1,
         NULL, OPAL_CMD_LINE_TYPE_INT,
         "Launch n processes per node on all allocated nodes" },
-    { "rmaps", "ppr", "n_pernode", '\0', "N", NULL, 1,
+    { "rmaps_ppr_n_pernode", '\0', "N", NULL, 1,
         NULL, OPAL_CMD_LINE_TYPE_INT,
         "Launch n processes per node on all allocated nodes (synonym for npernode)" },
 
 #if OPAL_HAVE_HWLOC
     /* declare hardware threads as independent cpus */
-    { "hwloc", "base", "use_hwthreads_as_cpus", '\0', "use-hwthread-cpus", "use-hwthread-cpus", 0,
+    { "hwloc_base_use_hwthreads_as_cpus", '\0', "use-hwthread-cpus", "use-hwthread-cpus", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Use hardware threads as independent cpus" },
 
     /* include npersocket for backwards compatibility */
-    { "rmaps", "ppr", "n_persocket", '\0', "npersocket", "npersocket", 1,
+    { "rmaps_ppr_n_persocket", '\0', "npersocket", "npersocket", 1,
       NULL, OPAL_CMD_LINE_TYPE_INT,
       "Launch n processes per socket on all allocated nodes" },
 
     /* Mapping options */
-    { "rmaps", "base", "mapping_policy", '\0', NULL, "map-by", 1,
+    { "rmaps_base_mapping_policy", '\0', NULL, "map-by", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Mapping Policy [slot (default) | hwthread | core | socket | numa | board | node]" },
 
       /* Ranking options */
-    { "rmaps", "base", "ranking_policy", '\0', NULL, "rank-by", 1,
+    { "rmaps_base_ranking_policy", '\0', NULL, "rank-by", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Ranking Policy [slot (default) | hwthread | core | socket | numa | board | node]" },
 
       /* Binding options */
-    { "hwloc", "base", "binding_policy", '\0', NULL, "bind-to", 1,
+    { "hwloc_base_binding_policy", '\0', NULL, "bind-to", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Policy for binding processes [none (default) | hwthread | core | socket | numa | board] (supported qualifiers: overload-allowed,if-supported)" },
 
     /* backward compatiblity */
-    { "hwloc", "base", "bind_to_core", '\0', "bind-to-core", "bind-to-core", 0,
+    { "hwloc_base_bind_to_core", '\0', "bind-to-core", "bind-to-core", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Bind processes to cores" },
-    { "hwloc", "base", "bind_to_socket", '\0', "bind-to-socket", "bind-to-socket", 0,
+    { "hwloc_base_bind_to_socket", '\0', "bind-to-socket", "bind-to-socket", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Bind processes to sockets" },
 
-    { "hwloc", "base", "report_bindings", '\0', "report-bindings", "report-bindings", 0,
+    { "hwloc_base_report_bindings", '\0', "report-bindings", "report-bindings", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Whether to report process bindings to stderr" },
 
     /* slot list option */
-    { "hwloc", "base", "slot_list", '\0', "slot-list", "slot-list", 1,
+    { "hwloc_base_slot_list", '\0', "slot-list", "slot-list", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "List of processor IDs to bind processes to [default=NULL]"},
 
     /* generalized pattern mapping option */
-    { "rmaps", "ppr", "pattern", '\0', NULL, "ppr", 1,
+    { "rmaps_ppr_pattern", '\0', NULL, "ppr", 1,
         NULL, OPAL_CMD_LINE_TYPE_STRING,
         "Comma-separated list of number of processes on a given resource type [default: none]" },
 #else
     /* Mapping options */
-    { "rmaps", "base", "mapping_policy", '\0', NULL, "map-by", 1,
+    { "rmaps_base_mapping_policy", '\0', NULL, "map-by", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Mapping Policy [slot (default) | node]" },
 
       /* Ranking options */
-    { "rmaps", "base", "ranking_policy", '\0', NULL, "rank-by", 1,
+    { "rmaps_base_ranking_policy", '\0', NULL, "rank-by", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Ranking Policy [slot (default) | node]" },
 #endif
 
     /* Allocation options */
-    { "orte", "display", "alloc", '\0', "display-allocation", "display-allocation", 0,
+    { "orte_display_alloc", '\0', "display-allocation", "display-allocation", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Display the allocation being used by this job"},
-    { "orte", "display", "devel_alloc", '\0', "display-devel-allocation", "display-devel-allocation", 0,
+    { "orte_display_devel_alloc", '\0', "display-devel-allocation", "display-devel-allocation", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Display a detailed list (mostly intended for developers) of the allocation being used by this job"},
 #if OPAL_HAVE_HWLOC
-    { "hwloc", "base", "cpu_set", '\0', "cpu-set", "cpu-set", 1,
+    { "hwloc_base_cpu_set", '\0', "cpu-set", "cpu-set", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Comma-separated list of ranges specifying logical cpus allocated to this job [default: none]"},
 #endif
-    { NULL, NULL, NULL, 'H', "host", "host", 1,
+    { NULL, 'H', "host", "host", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "List of hosts to invoke processes on" },
 
     /* mpiexec-like arguments */
-    { NULL, NULL, NULL, '\0', "wdir", "wdir", 1,
+    { NULL, '\0', "wdir", "wdir", 1,
       &orterun_globals.wdir, OPAL_CMD_LINE_TYPE_STRING,
       "Set the working directory of the started processes" },
-    { NULL, NULL, NULL, '\0', "wd", "wd", 1,
+    { NULL, '\0', "wd", "wd", 1,
       &orterun_globals.wdir, OPAL_CMD_LINE_TYPE_STRING,
       "Synonym for --wdir" },
-    { NULL, NULL, NULL, '\0', "set-cwd-to-session-dir", "set-cwd-to-session-dir", 0,
+    { NULL, '\0', "set-cwd-to-session-dir", "set-cwd-to-session-dir", 0,
       &orterun_globals.set_cwd_to_session_dir, OPAL_CMD_LINE_TYPE_BOOL,
       "Set the working directory of the started processes to their session directory" },
-    { NULL, NULL, NULL, '\0', "path", "path", 1,
+    { NULL, '\0', "path", "path", 1,
       &orterun_globals.path, OPAL_CMD_LINE_TYPE_STRING,
       "PATH to be used to look for executables to start processes" },
 
     /* User-level debugger arguments */
-    { NULL, NULL, NULL, '\0', "tv", "tv", 0,
+    { NULL, '\0', "tv", "tv", 0,
       &orterun_globals.debugger, OPAL_CMD_LINE_TYPE_BOOL,
       "Deprecated backwards compatibility flag; synonym for \"--debug\"" },
-    { NULL, NULL, NULL, '\0', "debug", "debug", 0,
+    { NULL, '\0', "debug", "debug", 0,
       &orterun_globals.debugger, OPAL_CMD_LINE_TYPE_BOOL,
       "Invoke the user-level debugger indicated by the orte_base_user_debugger MCA parameter" },
-    { "orte", "base", "user_debugger", '\0', "debugger", "debugger", 1,
+    { "orte_base_user_debugger", '\0', "debugger", "debugger", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Sequence of debuggers to search for when \"--debug\" is used" },
-    { "orte", "output", "debugger_proctable", '\0', "output-proctable", "output-proctable", 0,
+    { "orte_output_debugger_proctable", '\0', "output-proctable", "output-proctable", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Output the debugger proctable after launch" },
     
     /* OpenRTE arguments */
-    { "orte", "debug", NULL, 'd', "debug-devel", "debug-devel", 0,
+    { "orte_debug", 'd', "debug-devel", "debug-devel", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Enable debugging of OpenRTE" },
     
-    { "orte", "debug", "daemons", '\0', "debug-daemons", "debug-daemons", 0,
+    { "orte_debug_daemons", '\0', "debug-daemons", "debug-daemons", 0,
       NULL, OPAL_CMD_LINE_TYPE_INT,
       "Enable debugging of any OpenRTE daemons used by this application" },
     
-    { "orte", "debug", "daemons_file", '\0', "debug-daemons-file", "debug-daemons-file", 0,
+    { "orte_debug_daemons_file", '\0', "debug-daemons-file", "debug-daemons-file", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Enable debugging of any OpenRTE daemons used by this application, storing output in files" },
     
-    { "orte", "leave", "session_attached", '\0', "leave-session-attached", "leave-session-attached", 0,
+    { "orte_leave_session_attached", '\0', "leave-session-attached", "leave-session-attached", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Enable debugging of OpenRTE" },
 
-    { "orte", "do_not", "launch", '\0', "do-not-launch", "do-not-launch", 0,
+    { "orte_do_not_launch", '\0', "do-not-launch", "do-not-launch", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Perform all necessary operations to prepare to launch the application, but do not actually launch it" },
     
-    { NULL, NULL, NULL, '\0', NULL, "prefix", 1,
+    { NULL, '\0', NULL, "prefix", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Prefix where Open MPI is installed on remote nodes" },
-    { NULL, NULL, NULL, '\0', NULL, "noprefix", 0,
+    { NULL, '\0', NULL, "noprefix", 0,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Disable automatic --prefix behavior" },
 
-    { "orte", "report", "launch_progress", '\0', "show-progress", "show-progress", 0,
+    { "orte_report_launch_progress", '\0', "show-progress", "show-progress", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Output a brief periodic report on launch progress" },
 
-    { "orte", "use", "regexp", '\0', "use-regexp", "use-regexp", 0,
+    { "orte_use_regexp", '\0', "use-regexp", "use-regexp", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Use regular expressions for launch" },
 
-    { "orte", "report", "events", '\0', "report-events", "report-events", 1,
+    { "orte_report_events", '\0', "report-events", "report-events", 1,
       NULL, OPAL_CMD_LINE_TYPE_STRING,
       "Report events to a tool listening at the specified URI" },
 
-    { "orte", "enable", "recovery", '\0', "enable-recovery", "enable-recovery", 0,
+    { "orte_enable_recovery", '\0', "enable-recovery", "enable-recovery", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Enable recovery from process failure [Default = disabled]" },
 
-    { "orte", "max", "restarts", '\0', "max-restarts", "max-restarts", 1,
+    { "orte_max_restarts", '\0', "max-restarts", "max-restarts", 1,
       NULL, OPAL_CMD_LINE_TYPE_INT,
       "Max number of times to restart a failed process" },
 
 #if OPAL_HAVE_HWLOC
-    { "orte", "hetero", "nodes", '\0', NULL, "hetero-nodes", 0,
+    { "orte_hetero_nodes", '\0', NULL, "hetero-nodes", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Nodes in cluster may differ in topology, so send the topology back from each node [Default = false]" },
 #endif
 
 #if OPAL_ENABLE_CRDEBUG == 1
-    { "opal", "cr", "enable_crdebug", '\0', "crdebug", "crdebug", 0,
+    { "opal_cr_enable_crdebug", '\0', "crdebug", "crdebug", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Enable C/R Debugging" },
 #endif
 
-    { NULL, NULL, NULL, '\0', "disable-recovery", "disable-recovery", 0,
+    { NULL, '\0', "disable-recovery", "disable-recovery", 0,
       &orterun_globals.disable_recovery, OPAL_CMD_LINE_TYPE_BOOL,
       "Disable recovery (resets all recovery options to off)" },
 
-    { "state", "novm", "select", '\0', "novm", "novm", 0,
+    { "state_novm_select", '\0', "novm", "novm", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Execute without creating an allocation-spanning virtual machine (only start daemons on nodes hosting application procs)" },
 
-    { "state", "staged", "select", '\0', "staged", "staged", 0,
+    { "state_staged_select", '\0', "staged", "staged", 0,
       NULL, OPAL_CMD_LINE_TYPE_BOOL,
       "Used staged execution if inadequate resources are present (cannot support MPI jobs)" },
 
     /* End of list */
-    { NULL, NULL, NULL, '\0', NULL, NULL, 0,
+    { NULL, '\0', NULL, NULL, 0,
       NULL, OPAL_CMD_LINE_TYPE_NULL, NULL }
 };
 
@@ -2327,8 +2327,7 @@ static void run_debugger(char *basename, opal_cmd_line_t *cmd_line,
        launched under a debugger; not all debuggers are consistent
        about setting MPIR_being_debugged in both the launcher and the
        MPI processes */
-    env_name = mca_base_param_environ_variable("orte", 
-                                               "in_parallel_debugger", NULL);
+    env_name = mca_base_param_env_var ("orte_in_parallel_debugger");
     if (NULL != env_name) {
         opal_setenv(env_name, "1", true, &environ);
         free(env_name);
@@ -2512,8 +2511,7 @@ static void orte_debugger_init_before_spawn(orte_job_t *jdata)
     opal_output_verbose(1, orte_debug_output, "Info: Spawned by a debugger");
 
     /* tell the procs they are being debugged */
-    env_name = mca_base_param_environ_variable("orte", 
-                                               "in_parallel_debugger", NULL);
+    env_name = mca_base_param_env_var ("orte_in_parallel_debugger");
     
     for (i=0; i < jdata->apps->size; i++) {
         if (NULL == (app = (orte_app_context_t*)opal_pointer_array_get_item(jdata->apps, i))) {

orte/util/pre_condition_transports.c

@@ -161,7 +161,7 @@ int orte_pre_condition_transports(orte_job_t *jdata)
         return ORTE_ERR_OUT_OF_RESOURCE;
     }
 
-    if (NULL == (cs_env = mca_base_param_environ_variable("orte_precondition_transports",NULL,NULL))) {
+    if (NULL == (cs_env = mca_base_param_env_var ("orte_precondition_transports"))) {
         ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
         return ORTE_ERR_OUT_OF_RESOURCE;
     }