Merge pull request #7671 from hjelmn/add_support_for_component_aliasing_and_reluctantly_rename_vader_to_btl_sm

Add support for component aliasing

Author: jsquyres

README

@@ -594,7 +594,6 @@ MPI Functionality and Features
       - tcp
       - ugni
       - usnic
-      - vader (shared memory)
 
   Currently, MPI File operations are not thread safe even if MPI is
   initialized for MPI_THREAD_MULTIPLE support.
@@ -675,8 +674,8 @@ Network Support
     - SMCUDA
     - Cisco usNIC
     - uGNI (Cray Gemini, Aries)
-    - vader (XPMEM, Linux CMA, Linux KNEM, and copy-in/copy-out shared
-      memory)
+    - shared memory (XPMEM, Linux CMA, Linux KNEM, and
+      copy-in/copy-out shared memory)
 
   - "cm" supports a smaller number of networks (and they cannot be
     used together), but may provide better overall MPI performance:
@@ -785,16 +784,16 @@ Network Support
   v2.6.15 with libibverbs v1.1 or later (first released as part of
   OFED v1.2), per restrictions imposed by the OFED network stack.
 
-- Linux "knem" support is used when the "vader" or "sm" (shared
-  memory) BTLs are compiled with knem support (see the --with-knem
-  configure option) and the knem Linux module is loaded in the running
-  kernel.  If the knem Linux kernel module is not loaded, the knem
-  support is (by default) silently deactivated during Open MPI jobs.
+- Linux "knem" support is used when the "sm" (shared memory) BTL is
+  compiled with knem support (see the --with-knem configure option)
+  and the knem Linux module is loaded in the running kernel.  If the
+  knem Linux kernel module is not loaded, the knem support is (by
+  default) silently deactivated during Open MPI jobs.
 
   See https://knem.gforge.inria.fr/ for details on Knem.
 
-- Linux Cross-Memory Attach (CMA) or XPMEM is used by the vader
-  shared-memory BTL when the CMA/XPMEM libraries are installedm,
+- Linux Cross-Memory Attach (CMA) or XPMEM is used by the "sm" shared
+  memory BTL when the CMA/XPMEM libraries are installedm,
   respectively.  Linux CMA and XPMEM are similar (but different)
   mechanisms for Open MPI to utilize single-copy semantics for shared
   memory.
@@ -2154,14 +2153,14 @@ comma-delimited list to the "btl" MCA parameter:
 
    shell$ mpirun --mca btl tcp,self hello_world_mpi
 
-To add shared memory support, add "vader" into the command-delimited
-list (list order does not matter):
+To add shared memory support, add "sm" into the command-delimited list
+(list order does not matter):
 
-   shell$ mpirun --mca btl tcp,vader,self hello_world_mpi
+   shell$ mpirun --mca btl tcp,sm,self hello_world_mpi
 
-(there is an "sm" shared memory BTL, too, but "vader" is a newer
-generation of shared memory support; by default, "vader" will be used
-instead of "sm")
+(there used to be a "vader" BTL for shared memory support; it was
+renamed to "sm" in Open MPI v5.0.0, but the alias "vader" still works
+as well)
 
 To specifically deactivate a specific component, the comma-delimited
 list can be prepended with a "^" to negate it:

opal/class/opal_hash_table.h

@@ -486,6 +486,13 @@ OPAL_DECLSPEC int opal_proc_table_get_next_key(opal_proc_table_t *pt, opal_proce
   for (void *_nptr=NULL;                                   \
        OPAL_SUCCESS == opal_hash_table_get_next_key_##type(ht, &key, (void **)&value, _nptr, &_nptr);)
 
+#define OPAL_HASH_TABLE_FOREACH_PTR(key, value, ht, body)		\
+  {									\
+    size_t key_size_;							\
+    for (void *_nptr=NULL;						\
+	 OPAL_SUCCESS == opal_hash_table_get_next_key_ptr (ht, &key, &key_size_, (void **)&value, _nptr, &_nptr);) \
+      body								\
+  }
 END_C_DECLS
 
 #endif  /* OPAL_HASH_TABLE_H */

opal/class/opal_list.h

@@ -215,6 +215,11 @@ typedef struct opal_list_t opal_list_t;
        item != (type *) &(list)->opal_list_sentinel ;                   \
        item = (type *) ((opal_list_item_t *) (item))->opal_list_next)
 
+#define OPAL_LIST_FOREACH_DECL(item, list, type)			\
+  for (type *item = (type *) (list)->opal_list_sentinel.opal_list_next ; \
+       item != (type *) &(list)->opal_list_sentinel ;                   \
+       item = (type *) ((opal_list_item_t *) (item))->opal_list_next)
+
 /**
  * Loop over a list in reverse.
  *

opal/mca/base/Makefile.am

@@ -10,6 +10,7 @@
 # Copyright (c) 2004-2005 The Regents of the University of California.
 #                         All rights reserved.
 # Copyright (c) 2010 Cisco Systems, Inc.  All rights reserved.
+# Copyright (c) 2020      Google LLC. All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -31,6 +32,7 @@ dist_opaldata_DATA = help-mca-base.txt help-mca-var.txt
 
 headers = \
         base.h \
+        mca_base_alias.h \
         mca_base_component_repository.h \
         mca_base_var.h \
         mca_base_pvar.h \
@@ -43,6 +45,7 @@ headers = \
 
 libmca_base_la_SOURCES = \
         $(headers) \
+        mca_base_alias.c \
         mca_base_close.c \
         mca_base_cmd_line.c \
         mca_base_component_compare.c \

opal/mca/base/mca_base_alias.c

@@ -0,0 +1,173 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2020      Google, LLC. All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "mca_base_alias.h"
+#include "opal/class/opal_hash_table.h"
+#include "opal/runtime/opal.h"
+
+static void mca_base_alias_init (mca_base_alias_t *alias)
+{
+    OBJ_CONSTRUCT(&alias->component_aliases, opal_list_t);
+}
+
+static void mca_base_alias_fini (mca_base_alias_t *alias)
+{
+    OPAL_LIST_DESTRUCT(&alias->component_aliases);
+}
+
+OBJ_CLASS_INSTANCE(mca_base_alias_t, opal_object_t, mca_base_alias_init,
+                   mca_base_alias_fini);
+
+static void mca_base_alias_item_init (mca_base_alias_item_t *alias_item) {
+    alias_item->component_alias = NULL;
+}
+
+static void mca_base_alias_item_fini (mca_base_alias_item_t *alias_item) {
+    free (alias_item->component_alias);
+}
+
+OBJ_CLASS_INSTANCE(mca_base_alias_item_t, opal_list_item_t, mca_base_alias_item_init,
+                   mca_base_alias_item_fini);
+
+/*
+ * local variables
+ */
+static opal_hash_table_t *alias_hash_table;
+
+static void mca_base_alias_cleanup (void)
+{
+    if (!alias_hash_table) {
+        return;
+    }
+
+    void *key;
+    opal_object_t *value;
+    OPAL_HASH_TABLE_FOREACH_PTR(key, value, alias_hash_table, {
+        OBJ_RELEASE(value);
+    });
+
+    OBJ_RELEASE(alias_hash_table);
+    alias_hash_table = NULL;
+}
+
+static int mca_base_alias_setup (void)
+{
+    if (NULL != alias_hash_table) {
+        return OPAL_SUCCESS;
+    }
+
+    opal_finalize_register_cleanup (mca_base_alias_cleanup);
+
+    alias_hash_table = OBJ_NEW(opal_hash_table_t);
+    if (NULL == alias_hash_table) {
+        return OPAL_ERR_OUT_OF_RESOURCE;
+    }
+
+    int ret = opal_hash_table_init (alias_hash_table, 32);
+    if (OPAL_SUCCESS != ret) {
+        OBJ_RELEASE(alias_hash_table);
+        alias_hash_table = NULL;
+        return ret;
+    }
+
+    return OPAL_SUCCESS;
+}
+
+static char *mca_base_alias_generate_name (const char *project, const char *framework, const char *component_name)
+{
+    size_t project_length = project ? strlen (project) : 0;
+    size_t framework_length = framework ? strlen (framework) : 0;
+    size_t component_name_length = strlen (component_name);
+    size_t length = project_length + framework_length + component_name_length + 2;
+    char *tmp = calloc (1, length + 1);
+    if (NULL == tmp) {
+        return tmp;
+    }
+
+    if (project_length) {
+        strncat (tmp, project, length);
+        strncat (tmp, "_", 1);
+        length -= project_length + 1;
+    }
+
+    if (framework_length) {
+        strncat (tmp, framework, length);
+        strncat (tmp, "_", 1);
+        length -= framework_length + 1;
+    }
+
+    strncat (tmp, component_name, length);
+
+    return tmp;
+}
+
+static mca_base_alias_t *mca_base_alias_lookup_internal (const char *name)
+{
+    mca_base_alias_t *alias = NULL;
+    if (NULL == alias_hash_table) {
+        return NULL;
+    }
+
+    (void) opal_hash_table_get_value_ptr (alias_hash_table, name, strlen (name), (void **) &alias);
+    return alias;
+}
+
+int mca_base_alias_register (const char *project, const char *framework, const char *component_name,
+                             const char *component_alias, uint32_t alias_flags)
+{
+    if (NULL == component_name) {
+        return OPAL_ERR_BAD_PARAM;
+    }
+
+    int ret = mca_base_alias_setup ();
+    if (OPAL_SUCCESS != ret) {
+        return ret;
+    }
+
+    char *name = mca_base_alias_generate_name (project, framework, component_name);
+    assert (NULL != name);
+
+    mca_base_alias_t *alias = mca_base_alias_lookup_internal (name);
+    if (NULL == alias) {
+        alias = OBJ_NEW(mca_base_alias_t);
+        if (NULL == alias) {
+            return OPAL_ERR_OUT_OF_RESOURCE;
+        }
+
+        opal_hash_table_set_value_ptr (alias_hash_table, name, strlen(name), alias);
+        free (name);
+    }
+
+    mca_base_alias_item_t *alias_item = OBJ_NEW(mca_base_alias_item_t);
+    if (NULL == alias_item) {
+        return OPAL_ERR_OUT_OF_RESOURCE;
+    }
+    
+    alias_item->component_alias = strdup (component_alias);
+    alias_item->alias_flags = alias_flags;
+
+    opal_list_append (&alias->component_aliases, &alias_item->super);
+
+    return OPAL_SUCCESS;
+}
+
+const mca_base_alias_t *mca_base_alias_lookup(const char *project, const char *framework, const char *component_name)
+{
+    if (NULL == component_name) {
+        return NULL;
+    }
+
+    char *name = mca_base_alias_generate_name (project, framework, component_name);
+    assert (NULL != name);
+    const mca_base_alias_t *alias = mca_base_alias_lookup_internal (name);
+    free (name);
+
+    return alias;
+}

opal/mca/base/mca_base_alias.h

@@ -0,0 +1,86 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2020      Google, LLC. All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#ifndef OPAL_MCA_BASE_ALIAS_H
+#define OPAL_MCA_BASE_ALIAS_H
+
+#include "opal_config.h"
+#include "opal/class/opal_list.h"
+
+BEGIN_C_DECLS
+
+enum mca_base_alias_flags_t {
+      MCA_BASE_ALIAS_FLAG_NONE       = 0,
+      /** The aliased name has been deprecated. */
+      MCA_BASE_ALIAS_FLAG_DEPRECATED = 1,
+};
+
+typedef enum mca_base_alias_flags_t mca_base_alias_flags_t;
+
+struct mca_base_alias_item_t {
+    opal_list_item_t super;
+    /** Name aias. */
+    char *component_alias;
+    /** Alias flags. */
+    uint32_t alias_flags;
+};
+
+typedef struct mca_base_alias_item_t mca_base_alias_item_t;
+
+OBJ_CLASS_DECLARATION(mca_base_alias_item_t);
+
+struct mca_base_alias_t {
+    opal_object_t super;
+    /** List of name aliases. */
+    opal_list_t component_aliases;
+};
+
+typedef struct mca_base_alias_t mca_base_alias_t;
+
+OBJ_CLASS_DECLARATION(mca_base_alias_t);
+
+/**
+ * @brief Create a alias for a component name.
+ *
+ * @param[in] project         Project name (may be NULL)
+ * @param[in] framework       Framework name (may be NULL)
+ * @param[in] component_name  Name of component to alias (may not be NULL)
+ * @param[in] component_alias Aliased name (may not be NULL)
+ * @param[in] alias_flags     Flags (see mca_base_alias_flags_t)
+ *
+ * This function aliases one component name to another. When aliased
+ * any variable registered with this project, framework, and
+ * component_name will have synonyms created. For example, if
+ * opal_btl_vader is aliased to sm then registers a variable
+ * named btl_vader_flags then a synonym will be created with the
+ * name btl_sm_flags. If an alias is registered early enough
+ * (during framework registration for example) then the alias can
+ * also be used for component selection. In the previous example
+ * --mca btl vader and --mca btl sm would select the same
+ * component if the synonym is registered in the btl framework
+ * registration function.
+ */
+OPAL_DECLSPEC int mca_base_alias_register (const char *project, const char *framework,
+                                           const char *component_name,
+                                           const char *component_alias,
+                                           uint32_t alias_flags);
+
+/**
+ * @brief Check for aliases for a component.
+ *
+ * @param[in] project        Project name (may be NULL)
+ * @param[in] frameworek     Framework name (may be NULL)
+ * @param[in] component_name Component name (may not be NULL)
+ */
+OPAL_DECLSPEC const mca_base_alias_t *mca_base_alias_lookup(const char *project,
+                                                            const char *framework,
+                                                            const char *component_name);
+
+#endif /* OPAL_MCA_BASE_ALIAS_H */