Revert "Revert r27451 and r27456 - the cmd line parser is incorrectly marking the application as an MCA parameter".

It appears the problem was not with the command line parser but the rsh plm. I don't know why this problem was not occuring before the command line parser changes but it appears to be resolved now.

This commit was SVN r27527.

The following SVN revision numbers were found above:
  r27451 --> open-mpi/ompi@d59034e6ef
  r27456 --> open-mpi/ompi@ecdbf34937

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

@@ -170,7 +170,7 @@ OBJ_CLASS_INSTANCE(opal_node_stats_t, opal_object_t,
 int opal_dss_open(void)
 {
     char *enviro_val;
-    int id, rc;
+    int rc;
     opal_data_type_t tmp;
     int def_type;
 
@@ -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",
+    (void) mca_base_param_reg_int_name ("dss", "buffer_type",
 					"Set the default mode for OpenRTE buffers (0=non-described, 1=described)",
-                                     def_type);
-    mca_base_param_lookup_int(id, &rc);
+					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

@@ -160,374 +160,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,
       &orterun_globals.staged, 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 }
 };
 
@@ -2409,8 +2409,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);
@@ -2594,8 +2593,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;
     }