diff --git a/config/oshmem_config_files.m4 b/config/oshmem_config_files.m4 index 9f567c646a..a2c6bb35c9 100644 --- a/config/oshmem_config_files.m4 +++ b/config/oshmem_config_files.m4 @@ -19,6 +19,7 @@ AC_DEFUN([OSHMEM_CONFIG_FILES],[ oshmem/shmem/c/profile/Makefile + oshmem/tools/oshmem_info/Makefile oshmem/tools/wrappers/Makefile oshmem/tools/wrappers/shmemcc-wrapper-data.txt oshmem/tools/wrappers/shmemfort-wrapper-data.txt diff --git a/ompi/runtime/ompi_info_support.c b/ompi/runtime/ompi_info_support.c index e36232e3db..dc6d9c7438 100644 --- a/ompi/runtime/ompi_info_support.c +++ b/ompi/runtime/ompi_info_support.c @@ -25,19 +25,38 @@ #include "ompi/include/ompi/constants.h" #include "ompi/include/ompi/frameworks.h" +#include "ompi/communicator/communicator.h" #include "ompi/runtime/params.h" #include "opal/runtime/opal_info_support.h" #include "ompi/runtime/ompi_info_support.h" -#include "opal/util/show_help.h" #if OMPI_RTE_ORTE #include "orte/runtime/orte_info_support.h" #endif +#include "opal/util/show_help.h" + +const char *ompi_info_type_ompi = "ompi"; +const char *ompi_info_type_base = "base"; + static bool ompi_info_registered = false; +void ompi_info_register_types(opal_pointer_array_t *mca_types) +{ + int i; + + /* add the top-level type */ + opal_pointer_array_add(mca_types, (void *)ompi_info_type_ompi); + opal_pointer_array_add(mca_types, "mpi"); + + /* push all the types found by autogen */ + for (i=0; NULL != ompi_frameworks[i]; i++) { + opal_pointer_array_add(mca_types, ompi_frameworks[i]->framework_name); + } +} + int ompi_info_register_framework_params(opal_pointer_array_t *component_map) { int rc; @@ -48,17 +67,17 @@ int ompi_info_register_framework_params(opal_pointer_array_t *component_map) ompi_info_registered = true; - rc = opal_info_register_framework_params(component_map); - if (OPAL_SUCCESS != rc) { - return rc; - } - /* Register the MPI layer's MCA parameters */ if (OMPI_SUCCESS != (rc = ompi_mpi_register_params())) { fprintf(stderr, "ompi_info_register: ompi_mpi_register_params failed\n"); return rc; } + rc = opal_info_register_framework_params(component_map); + if (OPAL_SUCCESS != rc) { + return rc; + } + #if OMPI_RTE_ORTE rc = orte_info_register_framework_params(component_map); if (ORTE_SUCCESS != rc) { @@ -66,5 +85,65 @@ int ompi_info_register_framework_params(opal_pointer_array_t *component_map) } #endif - return opal_info_register_project_frameworks("ompi", ompi_frameworks, component_map); + return opal_info_register_project_frameworks(ompi_info_type_ompi, ompi_frameworks, component_map); +} + +void ompi_info_close_components(void) +{ + int i; + + /* Note that the order of shutdown here doesn't matter because + * we aren't *using* any components -- none were selected, so + * there are no dependencies between the frameworks. We list + * them generally "in order", but it doesn't really matter. + + * We also explicitly ignore the return values from the + * close() functions -- what would we do if there was an + * error? + */ + for (i=0; NULL != ompi_frameworks[i]; i++) { + (void) mca_base_framework_close(ompi_frameworks[i]); + } + +#if OMPI_RTE_ORTE + /* close the ORTE components */ + (void) orte_info_close_components(); +#endif +} + +void ompi_info_show_ompi_version(const char *scope) +{ + char *tmp, *tmp2; + + (void)asprintf(&tmp, "%s:version:full", ompi_info_type_ompi); + tmp2 = opal_info_make_version_str(scope, + OMPI_MAJOR_VERSION, OMPI_MINOR_VERSION, + OMPI_RELEASE_VERSION, + OMPI_GREEK_VERSION, + OMPI_WANT_REPO_REV, OMPI_REPO_REV); + opal_info_out("Open MPI", tmp, tmp2); + free(tmp); + free(tmp2); + (void)asprintf(&tmp, "%s:version:repo", ompi_info_type_ompi); + opal_info_out("Open MPI repo revision", tmp, OMPI_REPO_REV); + free(tmp); + (void)asprintf(&tmp, "%s:version:release_date", ompi_info_type_ompi); + opal_info_out("Open MPI release date", tmp, OMPI_RELEASE_DATE); + free(tmp); + +#if OMPI_RTE_ORTE + /* show the orte version */ + orte_info_show_orte_version(scope); +#endif + + /* show the opal version */ + opal_info_show_opal_version(scope); + + tmp2 = opal_info_make_version_str(scope, + MPI_VERSION, MPI_SUBVERSION, + 0, "", 0, ""); + opal_info_out("MPI API", "mpi-api:version:full", tmp2); + free(tmp2); + + opal_info_out("Ident string", "ident", OPAL_IDENT_STRING); } diff --git a/ompi/runtime/ompi_info_support.h b/ompi/runtime/ompi_info_support.h index e116a36c4e..17283182f6 100644 --- a/ompi/runtime/ompi_info_support.h +++ b/ompi/runtime/ompi_info_support.h @@ -25,6 +25,12 @@ #include "opal/class/opal_pointer_array.h" +OMPI_DECLSPEC void ompi_info_register_types(opal_pointer_array_t *mca_types); + OMPI_DECLSPEC int ompi_info_register_framework_params(opal_pointer_array_t *component_map); +OMPI_DECLSPEC void ompi_info_close_components(void); + +OMPI_DECLSPEC void ompi_info_show_ompi_version(const char *scope); + #endif /* !defined(OMPI_INFO_SUPPORT_H) */ diff --git a/ompi/tools/ompi_info/Makefile.am b/ompi/tools/ompi_info/Makefile.am index 5665d4fe13..4867908efd 100644 --- a/ompi/tools/ompi_info/Makefile.am +++ b/ompi/tools/ompi_info/Makefile.am @@ -59,9 +59,7 @@ endif ompi_info_SOURCES = \ ompi_info.h \ ompi_info.c \ - param.c \ - components.c \ - version.c + param.c ompi_info_LDADD = $(top_builddir)/ompi/libmpi.la if OMPI_RTE_ORTE diff --git a/ompi/tools/ompi_info/components.c b/ompi/tools/ompi_info/components.c deleted file mode 100644 index ae4ab71dae..0000000000 --- a/ompi/tools/ompi_info/components.c +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright (c) 2004-2010 The Trustees of Indiana University and Indiana - * University Research and Technology - * Corporation. All rights reserved. - * Copyright (c) 2004-2011 The University of Tennessee and The University - * of Tennessee Research Foundation. All rights - * reserved. - * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, - * University of Stuttgart. All rights reserved. - * Copyright (c) 2004-2005 The Regents of the University of California. - * All rights reserved. - * Copyright (c) 2006-2012 Cisco Systems, Inc. All rights reserved. - * Copyright (c) 2010-2013 Los Alamos National Security, LLC. - * All rights reserved. - * Copyright (c) 2011-2012 University of Houston. All rights reserved. - * $COPYRIGHT$ - * - * Additional copyrights may follow - * - * $HEADER$ - */ - -#include "ompi_config.h" - -#include -#include - -#include "opal/util/argv.h" -#include "opal/runtime/opal_info_support.h" - -#if OMPI_RTE_ORTE -#include "orte/runtime/runtime.h" -#include "orte/runtime/orte_info_support.h" -#endif - -#if OPAL_ENABLE_FT_CR == 1 -#include "ompi/mca/crcp/crcp.h" -#include "ompi/mca/crcp/base/base.h" -#endif -#include "ompi/include/ompi/frameworks.h" - -#include "ompi/tools/ompi_info/ompi_info.h" - - -/* - * Private variables - */ - -void ompi_info_close_components() -{ - int i; - - /* Note that the order of shutdown here doesn't matter because - * we aren't *using* any components -- none were selected, so - * there are no dependencies between the frameworks. We list - * them generally "in order", but it doesn't really matter. - - * We also explicitly ignore the return values from the - * close() functions -- what would we do if there was an - * error? - */ - for (i=0; NULL != ompi_frameworks[i]; i++) { - (void) mca_base_framework_close(ompi_frameworks[i]); - } - -#if OMPI_RTE_ORTE - /* close the ORTE components */ - (void) orte_info_close_components(); -#endif -} diff --git a/ompi/tools/ompi_info/ompi_info.c b/ompi/tools/ompi_info/ompi_info.c index 23c1eaf2b5..e577277bb5 100644 --- a/ompi/tools/ompi_info/ompi_info.c +++ b/ompi/tools/ompi_info/ompi_info.c @@ -62,9 +62,6 @@ * Public variables */ -const char *ompi_info_type_ompi = "ompi"; -const char *ompi_info_type_base = "base"; - int main(int argc, char *argv[]) { @@ -117,16 +114,9 @@ int main(int argc, char *argv[]) /* add in the orte frameworks */ orte_info_register_types(&mca_types); #endif - - /* add the top-level type */ - opal_pointer_array_add(&mca_types, "ompi"); - opal_pointer_array_add(&mca_types, "mpi"); - - /* push all the types found by autogen */ - for (i=0; NULL != ompi_frameworks[i]; i++) { - opal_pointer_array_add(&mca_types, ompi_frameworks[i]->framework_name); - } + ompi_info_register_types(&mca_types); + /* init the component map */ OBJ_CONSTRUCT(&component_map, opal_pointer_array_t); opal_pointer_array_init(&component_map, 256, INT_MAX, 128); @@ -169,6 +159,7 @@ int main(int argc, char *argv[]) /* If no command line args are specified, show default set */ if (!acted) { + opal_info_out("Package", "package", OPAL_PACKAGE_STRING); ompi_info_show_ompi_version(opal_info_ver_full); opal_info_show_path(opal_info_path_prefix, opal_install_dirs.prefix); opal_info_do_arch(); diff --git a/ompi/tools/ompi_info/ompi_info.h b/ompi/tools/ompi_info/ompi_info.h index 1774da0881..c420bb844c 100644 --- a/ompi/tools/ompi_info/ompi_info.h +++ b/ompi/tools/ompi_info/ompi_info.h @@ -37,10 +37,6 @@ BEGIN_C_DECLS extern const char *ompi_info_type_ompi; extern const char *ompi_info_type_base; -void ompi_info_show_ompi_version(const char *scope); - -void ompi_info_close_components(void); - void ompi_info_do_config(bool want_all); END_C_DECLS diff --git a/ompi/tools/ompi_info/version.c b/ompi/tools/ompi_info/version.c deleted file mode 100644 index fa7ed02788..0000000000 --- a/ompi/tools/ompi_info/version.c +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana - * University Research and Technology - * Corporation. All rights reserved. - * Copyright (c) 2004-2006 The University of Tennessee and The University - * of Tennessee Research Foundation. All rights - * reserved. - * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, - * University of Stuttgart. All rights reserved. - * Copyright (c) 2004-2005 The Regents of the University of California. - * All rights reserved. - * Copyright (c) 2007 Sun Microsystems, Inc. All rights reserved. - * Copyright (c) 2008-2011 Cisco Systems, Inc. All rights reserved. - * Copyright (c) 2012 Los Alamos National Security, LLC. - * All rights reserved. - * $COPYRIGHT$ - * - * Additional copyrights may follow - * - * $HEADER$ - */ - -#include "ompi_config.h" - -#include -#include - -#include "mpi.h" - -#include "opal/version.h" -#if OMPI_RTE_ORTE -#include "orte/version.h" -#endif -#include "ompi/version.h" -#include "opal/mca/base/base.h" -#include "opal/util/printf.h" -#include "opal/runtime/opal_info_support.h" - -#if OMPI_RTE_ORTE -#include "orte/runtime/orte_info_support.h" -#endif - -#include "ompi/tools/ompi_info/ompi_info.h" - -/* - * Show the version of Open MPI - */ -void ompi_info_show_ompi_version(const char *scope) -{ - char *tmp, *tmp2; - - opal_info_out("Package", "package", OPAL_PACKAGE_STRING); - (void)asprintf(&tmp, "%s:version:full", ompi_info_type_ompi); - tmp2 = opal_info_make_version_str(scope, - OMPI_MAJOR_VERSION, OMPI_MINOR_VERSION, - OMPI_RELEASE_VERSION, - OMPI_GREEK_VERSION, - OMPI_WANT_REPO_REV, OMPI_REPO_REV); - opal_info_out("Open MPI", tmp, tmp2); - free(tmp); - free(tmp2); - (void)asprintf(&tmp, "%s:version:repo", ompi_info_type_ompi); - opal_info_out("Open MPI repo revision", tmp, OMPI_REPO_REV); - free(tmp); - (void)asprintf(&tmp, "%s:version:release_date", ompi_info_type_ompi); - opal_info_out("Open MPI release date", tmp, OMPI_RELEASE_DATE); - free(tmp); - -#if OMPI_RTE_ORTE - /* show the orte version */ - orte_info_show_orte_version(scope); -#endif - - /* show the opal version */ - opal_info_show_opal_version(scope); - - tmp2 = opal_info_make_version_str(scope, - MPI_VERSION, MPI_SUBVERSION, - 0, "", 0, ""); - opal_info_out("MPI API", "mpi-api:version:full", tmp2); - free(tmp2); - - opal_info_out("Ident string", "ident", OPAL_IDENT_STRING); -} - - diff --git a/oshmem/runtime/Makefile.am b/oshmem/runtime/Makefile.am index b32913515b..7d789301be 100644 --- a/oshmem/runtime/Makefile.am +++ b/oshmem/runtime/Makefile.am @@ -7,7 +7,7 @@ # $HEADER$ # -# This makefile.am does not stand on its own - it is included from ompi/Makefile.am +# This makefile.am does not stand on its own - it is included from oshmem/Makefile.am dist_pkgdata_DATA += runtime/help-shmem-runtime.txt @@ -15,6 +15,7 @@ dist_pkgdata_DATA += runtime/help-shmem-runtime.txt headers += \ runtime/runtime.h \ runtime/params.h \ + runtime/oshmem_info_support.h \ runtime/oshmem_shmem_preconnect.h libshmem_la_SOURCES += \ @@ -22,7 +23,8 @@ libshmem_la_SOURCES += \ runtime/oshmem_shmem_finalize.c \ runtime/oshmem_shmem_abort.c \ runtime/oshmem_shmem_params.c \ - runtime/oshmem_shmem_exchange.c + runtime/oshmem_shmem_exchange.c \ + runtime/oshmem_info_support.c diff --git a/oshmem/runtime/oshmem_info_support.c b/oshmem/runtime/oshmem_info_support.c new file mode 100644 index 0000000000..3b8ad37155 --- /dev/null +++ b/oshmem/runtime/oshmem_info_support.c @@ -0,0 +1,100 @@ +/* + * Copyright (c) 2013 Mellanox Technologies, Inc. + * All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "oshmem_config.h" + +#include "oshmem/include/oshmem/constants.h" +#include "oshmem/include/oshmem/frameworks.h" + +#include "oshmem/runtime/params.h" +#include "oshmem/runtime/runtime.h" + +#include "opal/runtime/opal_info_support.h" +#include "ompi/runtime/ompi_info_support.h" +#include "oshmem/runtime/oshmem_info_support.h" +#include "opal/util/show_help.h" + +const char *oshmem_info_type_oshmem = "oshmem"; + +static bool oshmem_info_registered = false; + +void oshmem_info_register_types(opal_pointer_array_t *mca_types) +{ + int i; + + /* add the top-level type */ + opal_pointer_array_add(mca_types, (void *)oshmem_info_type_oshmem); + + /* push all the types found by autogen */ + for (i = 0; NULL != oshmem_frameworks[i]; i++) { + opal_pointer_array_add(mca_types, oshmem_frameworks[i]->framework_name); + } +} + +int oshmem_info_register_framework_params(opal_pointer_array_t *component_map) +{ + int rc; + + if (oshmem_info_registered) { + return OSHMEM_SUCCESS; + } + + oshmem_info_registered = true; + + /* Register the OSHMEM layer's MCA parameters */ + if (OSHMEM_SUCCESS != (rc = oshmem_shmem_register_params())) { + fprintf(stderr, "oshmem_info_register: oshmem_register_params failed\n"); + return rc; + } + + /* Do OMPI interface call */ + rc = ompi_info_register_framework_params(component_map); + if (OMPI_SUCCESS != rc) { + return rc; + } + + return opal_info_register_project_frameworks(oshmem_info_type_oshmem, oshmem_frameworks, component_map); +} + +void oshmem_info_close_components(void) +{ + int i; + + for (i = 0; NULL != oshmem_frameworks[i]; i++) { + (void) mca_base_framework_close(oshmem_frameworks[i]); + } + + /* Do OMPI interface call */ + ompi_info_close_components(); +} + +void oshmem_info_show_oshmem_version(const char *scope) +{ + char *tmp, *tmp2; + + asprintf(&tmp, "%s:version:full", oshmem_info_type_oshmem); + tmp2 = opal_info_make_version_str(scope, + OSHMEM_MAJOR_VERSION, OSHMEM_MINOR_VERSION, + OSHMEM_RELEASE_VERSION, + OSHMEM_GREEK_VERSION, + OSHMEM_WANT_REPO_REV, OSHMEM_REPO_REV); + opal_info_out("Open SHMEM", tmp, tmp2); + free(tmp); + free(tmp2); + asprintf(&tmp, "%s:version:repo", oshmem_info_type_oshmem); + opal_info_out("Open SHMEM repo revision", tmp, OSHMEM_REPO_REV); + free(tmp); + asprintf(&tmp, "%s:version:release_date", oshmem_info_type_oshmem); + opal_info_out("Open SHMEM release date", tmp, OSHMEM_RELEASE_DATE); + free(tmp); + + /* Do OMPI interface call */ + ompi_info_show_ompi_version(scope); +} diff --git a/oshmem/runtime/oshmem_info_support.h b/oshmem/runtime/oshmem_info_support.h new file mode 100644 index 0000000000..34e0ddef4a --- /dev/null +++ b/oshmem/runtime/oshmem_info_support.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2013 Mellanox Technologies, Inc. + * All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#if !defined(OSHMEM_INFO_SUPPORT_H) +#define OSHMEM_INFO_SUPPORT_H + +#include "oshmem_config.h" + +#include "opal/class/opal_pointer_array.h" + +OSHMEM_DECLSPEC void oshmem_info_register_types(opal_pointer_array_t *mca_types); + +OSHMEM_DECLSPEC int oshmem_info_register_framework_params(opal_pointer_array_t *component_map); + +OSHMEM_DECLSPEC void oshmem_info_close_components(void); + +OSHMEM_DECLSPEC void oshmem_info_show_oshmem_version(const char *scope); + +#endif /* !defined(OSHMEM_INFO_SUPPORT_H) */ diff --git a/oshmem/tools/Makefile.am b/oshmem/tools/Makefile.am index 480ebbe829..e86d8a8551 100644 --- a/oshmem/tools/Makefile.am +++ b/oshmem/tools/Makefile.am @@ -12,7 +12,9 @@ SUBDIRS += \ + tools/oshmem_info \ tools/wrappers DIST_SUBDIRS += \ + tools/oshmem_info \ tools/wrappers diff --git a/oshmem/tools/oshmem_info/Makefile.am b/oshmem/tools/oshmem_info/Makefile.am new file mode 100644 index 0000000000..14bbc7e9ce --- /dev/null +++ b/oshmem/tools/oshmem_info/Makefile.am @@ -0,0 +1,60 @@ +# +# Copyright (c) 2013 Mellanox Technologies, Inc. +# All rights reserved. +# $COPYRIGHT$ +# +# Additional copyrights may follow +# +# $HEADER$ +# + +AM_CFLAGS = \ + -DOPAL_CONFIGURE_USER="\"@OPAL_CONFIGURE_USER@\"" \ + -DOPAL_CONFIGURE_HOST="\"@OPAL_CONFIGURE_HOST@\"" \ + -DOPAL_CONFIGURE_DATE="\"@OPAL_CONFIGURE_DATE@\"" \ + -DOMPI_BUILD_USER="\"$$USER\"" \ + -DOMPI_BUILD_HOST="\"`hostname`\"" \ + -DOMPI_BUILD_DATE="\"`date`\"" \ + -DOMPI_BUILD_CFLAGS="\"@CFLAGS@\"" \ + -DOMPI_BUILD_CPPFLAGS="\"@CPPFLAGS@\"" \ + -DOMPI_BUILD_CXXFLAGS="\"@CXXFLAGS@\"" \ + -DOMPI_BUILD_CXXCPPFLAGS="\"@CXXCPPFLAGS@\"" \ + -DOMPI_BUILD_FFLAGS="\"@FFLAGS@\"" \ + -DOMPI_BUILD_FCFLAGS="\"@FCFLAGS@\"" \ + -DOMPI_BUILD_LDFLAGS="\"@LDFLAGS@\"" \ + -DOMPI_BUILD_LIBS="\"@LIBS@\"" \ + -DOPAL_CC_ABSOLUTE="\"@OPAL_CC_ABSOLUTE@\"" \ + -DOMPI_CXX_ABSOLUTE="\"@OMPI_CXX_ABSOLUTE@\"" + +include $(top_srcdir)/Makefile.man-page-rules + +man_pages = oshmem_info.1 +EXTRA_DIST = $(man_pages:.1=.1in) + +bin_PROGRAMS = oshmem_info + +nodist_man_MANS = $(man_pages) + +# Ensure that the man pages are rebuilt if the opal_config.h file +# changes; a "good enough" way to know if configure was run again (and +# therefore the release date or version may have changed) +$(nodist_man_MANS): $(top_builddir)/opal/include/opal_config.h + + +oshmem_info_SOURCES = \ + oshmem_info.h \ + oshmem_info.c \ + param.c + +oshmem_info_LDADD = $(top_builddir)/ompi/libmpi.la +oshmem_info_LDADD += $(top_builddir)/oshmem/libshmem.la +if OMPI_RTE_ORTE +oshmem_info_LDADD += $(top_builddir)/orte/libopen-rte.la +endif +oshmem_info_LDADD += $(top_builddir)/opal/libopen-pal.la + +clean-local: + test -z "$(OMPI_CXX_TEMPLATE_REPOSITORY)" || rm -rf $(OMPI_CXX_TEMPLATE_REPOSITORY) + +distclean-local: + rm -f $(man_pages) diff --git a/oshmem/tools/oshmem_info/oshmem_info.1in b/oshmem/tools/oshmem_info/oshmem_info.1in new file mode 100644 index 0000000000..7b2d076426 --- /dev/null +++ b/oshmem/tools/oshmem_info/oshmem_info.1in @@ -0,0 +1,205 @@ +.\" Man page contributed by Dirk Eddelbuettel +.\" and released under the BSD license +.\" Copyright (c) 2008 Sun Microsystems, Inc. All rights reserved. +.TH OSHMEM_INFO 1 "#OMPI_DATE#" "#PACKAGE_VERSION#" "#PACKAGE_NAME#" +.SH NAME +oshmem_info - Display information about the Open MPI installation +. +.\" ************************** +.\" Synopsis Section +.\" ************************** +.SH SYNOPSIS +.B oshmem_info [options] +. +.\" ************************** +.\" Description Section +.\" ************************** +.SH DESCRIPTION +.PP +.B oshmem_info +provides detailed information about the Open MPI/SHMEM installation. It can +be useful for at least three common scenarios: +.PP +1. Checking local configuration and seeing how Open MPI/SHMEM was installed. +.PP +2. Submitting bug reports / help requests to the Open MPI/SHMEM community +(see +.IR http://www.open-mpi.org/community/help/ ) +.PP +3. Seeing a list of installed Open MPI/SHMEM plugins and querying what +MCA parameters they support. +. +.\" ************************** +.\" Options Section +.\" ************************** +.SH OPTIONS +.B oshmem_info +accepts the following options: +.TP 8 +.I \-a|\-\-all +Show all configuration options and MCA parameters +.TP 8 +.I \-\-arch +Show architecture Open MPI/SHMEM was compiled on +.TP 8 +.I \-c|\-\-config +Show configuration options +.TP 8 +.I \-gmca|\-\-gmca +Pass global MCA parameters that are applicable to all contexts. +.TP 8 +.I \-h|\-\-help +Shows help / usage message +.TP 8 +.I \-\-hostname +Show the hostname that Open MPI/SHMEM was configured and built on +.TP 8 +.I \-\-internal +Show internal MCA parameters (not meant to be modified by users) +.TP 8 +.I \-\-level +Show only variables with at most this level (1-9). The default is 1 unless +\-\-all is specified without \-\-level in which case the default is 9. See +the LEVEL section for more information. +.TP 8 +.I \-mca|\-\-mca +Pass context-specific MCA parameters; they are considered global if --gmca is +not used and only one context is specified. +.TP 8 +.I \-\-param +Show MCA parameters. The first parameter is the type of the component +to display; the second parameter is the specific component to display +(or the keyword "all", meaning "display all components of this type"). +.TP 8 +.I \-\-parsable +When used in conjunction with other parameters, the output is +displayed in a machine-parsable format +.I \-\-parseable +Synonym for --parsable +.TP 8 +.I \-\-path +Show paths that Open MPI/SHMEM was configured with. Accepts the following +parameters: prefix, bindir, libdir, incdir, pkglibdir, sysconfdir. +.TP 8 +.I \-\-pretty +When used in conjunction with other parameters, the output is +displayed in 'prettyprint' format (default) +.TP 8 +.I \-\-selected-only +Show only variables from selected components. +.TP 8 +.I \-V|\-\-version +Show version of Open MPI/SHMEM. +. +.\" ************************** +.\" Levels Section +.\" ************************** +.SH LEVELS +.TP 4 +1 +Basic information of interest to users +. +.TP +2 +Detailed information of interest to users +. +.TP +3 +All remaining information of interest to users +. +.TP +4 +Basic information required for tuning +. +.TP +5 +Detailed information required for tuning +. +.TP +6 +All remaining information required for tuning +. +.TP +7 +Basic information for MPI implementors +. +.TP +8 +Detailed information for MPI implementors +. +.TP +9 +All remaining information for MPI implementors +. +.\" ************************** +.\" Examples Section +.\" ************************** +.SH EXAMPLES +.TP 4 +oshmem_info +Show the default output of options and listing of installed +components in a human-readable / prettyprint format. +. +. +.TP +oshmem_info --parsable +Show the default output of options and listing of installed +components in a machine-parsable format. +. +. +.TP +oshmem_info --param btl openib +Show the MCA parameters of the "openib" BTL component in a +human-readable / prettyprint format. +. +. +.TP +oshmem_info --param btl openib --parsable +Show the MCA parameters of the "openib" BTL component in a +machine-parsable format. +. +. +.TP +oshmem_info --path bindir +Show the "bindir" that Open MPI was configured with. +. +. +.TP +oshmem_info --version ompi full --parsable +Show the full version numbers of Open MPI/SHMEM (including the ORTE and OPAL +version numbers) in a machine-readable format. +. +. +.TP +oshmem_info --version btl major +Show the major version number of all BTL components in a prettyprint +format. +. +. +.TP +oshmem_info --version btl:tcp minor +Show the minor version number of the TCP BTL component in a +prettyprint format. +. +. +.TP +oshmem_info --all +Show +.I all +information about the Open MPI/SHMEM installation, including all components +that can be found, the MCA parameters that they support, versions of +Open MPI/SHMEM and the components, etc. +. +. +.\" ************************** +.\" Authors Section +.\" ************************** +.SH AUTHORS +The Open MPI/SHMEM maintainers -- see +.I http://www.openmpi.org/ +or the file +.IR AUTHORS . +.PP +This manual page was originally contributed by Dirk Eddelbuettel +, one of the Debian GNU/Linux maintainers for Open +MPI, and may be used by others. diff --git a/oshmem/tools/oshmem_info/oshmem_info.c b/oshmem/tools/oshmem_info/oshmem_info.c new file mode 100644 index 0000000000..29c836dc65 --- /dev/null +++ b/oshmem/tools/oshmem_info/oshmem_info.c @@ -0,0 +1,193 @@ +/* + * Copyright (c) 2013 Mellanox Technologies, Inc. + * All rights reserved. + * + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "oshmem_config.h" + +#include +#include +#include +#ifdef HAVE_UNISTD_H +#include +#endif +#ifdef HAVE_NETDB_H +#include +#endif +#ifdef HAVE_SYS_PARAM_H +#include +#endif +#include + +#include "opal/version.h" +#include "opal/mca/installdirs/installdirs.h" +#include "opal/class/opal_object.h" +#include "opal/class/opal_pointer_array.h" +#include "opal/runtime/opal.h" +#if OPAL_ENABLE_FT_CR == 1 +#include "opal/runtime/opal_cr.h" +#endif +#include "opal/mca/base/base.h" +#include "opal/runtime/opal_info_support.h" +#include "opal/util/argv.h" +#include "opal/util/show_help.h" + +#if OMPI_RTE_ORTE +#include "orte/runtime/orte_info_support.h" +#endif + +#include "ompi/runtime/ompi_info_support.h" + +#include "oshmem/include/oshmem/frameworks.h" +#include "oshmem/include/oshmem/constants.h" +#include "oshmem/tools/oshmem_info/oshmem_info.h" +#include "oshmem/runtime/oshmem_info_support.h" + +/* + * Public variables + */ + + +int main(int argc, char *argv[]) +{ + int ret = 0; + bool acted = false; + bool want_all = false; + char **app_env = NULL, **global_env = NULL; + int i; + opal_cmd_line_t *info_cmd_line; + opal_pointer_array_t mca_types; + opal_pointer_array_t component_map; + opal_info_component_map_t *map; + + /* Initialize the argv parsing handle */ + if (OPAL_SUCCESS != opal_init_util(&argc, &argv)) { + opal_show_help("help-opal_info.txt", "lib-call-fail", true, + "opal_init_util", __FILE__, __LINE__, NULL); + exit(ret); + } + + info_cmd_line = OBJ_NEW(opal_cmd_line_t); + if (NULL == info_cmd_line) { + ret = errno; + opal_show_help("help-opal_info.txt", "lib-call-fail", true, + "opal_cmd_line_create", __FILE__, __LINE__, NULL); + exit(ret); + } + + /* initialize the command line, parse it, and return the directives + * telling us what the user wants output + */ + if (OPAL_SUCCESS != (ret = opal_info_init(argc, argv, info_cmd_line))) { + exit(ret); + } + + if (opal_cmd_line_is_taken(info_cmd_line, "version")) { + fprintf(stdout, "Open MPI/SHMEM v%s\n\n%s\n", + OPAL_VERSION, PACKAGE_BUGREPORT); + exit(0); + } + + /* setup the mca_types array */ + OBJ_CONSTRUCT(&mca_types, opal_pointer_array_t); + opal_pointer_array_init(&mca_types, 256, INT_MAX, 128); + + /* add in the opal frameworks */ + opal_info_register_types(&mca_types); + +#if OMPI_RTE_ORTE + /* add in the orte frameworks */ + orte_info_register_types(&mca_types); +#endif + + /* add in the ompi frameworks */ + ompi_info_register_types(&mca_types); + + /* add in the oshmem frameworks */ + oshmem_info_register_types(&mca_types); + + /* init the component map */ + OBJ_CONSTRUCT(&component_map, opal_pointer_array_t); + opal_pointer_array_init(&component_map, 256, INT_MAX, 128); + + /* Register OMPI/OSHMEM's params */ + if (OSHMEM_SUCCESS != (ret = oshmem_info_register_framework_params(&component_map))) { + if (OSHMEM_ERR_BAD_PARAM == ret) { + /* output what we got */ + opal_info_do_params(true, opal_cmd_line_is_taken(info_cmd_line, "internal"), + &mca_types, NULL); + } + exit(1); + } + + /* Execute the desired action(s) */ + want_all = opal_cmd_line_is_taken(info_cmd_line, "all"); + if (want_all || opal_cmd_line_is_taken(info_cmd_line, "path")) { + opal_info_do_path(want_all, info_cmd_line); + acted = true; + } + if (want_all || opal_cmd_line_is_taken(info_cmd_line, "arch")) { + opal_info_do_arch(); + acted = true; + } + if (want_all || opal_cmd_line_is_taken(info_cmd_line, "hostname")) { + opal_info_do_hostname(); + acted = true; + } + if (want_all || opal_cmd_line_is_taken(info_cmd_line, "config")) { + oshmem_info_do_config(true); + acted = true; + } + if (want_all || opal_cmd_line_is_taken(info_cmd_line, "param") || + opal_cmd_line_is_taken(info_cmd_line, "params")) { + opal_info_do_params(want_all, opal_cmd_line_is_taken(info_cmd_line, "internal"), + &mca_types, info_cmd_line); + acted = true; + } + + /* If no command line args are specified, show default set */ + + if (!acted) { + opal_info_out("Package", "package", OPAL_PACKAGE_STRING); + oshmem_info_show_oshmem_version(opal_info_ver_full); + opal_info_show_path(opal_info_path_prefix, opal_install_dirs.prefix); + opal_info_do_arch(); + opal_info_do_hostname(); + oshmem_info_do_config(false); + opal_info_show_component_version(&mca_types, &component_map, opal_info_type_all, + opal_info_component_all, opal_info_ver_full, + opal_info_ver_all); + } + + /* All done */ + + if (NULL != app_env) { + opal_argv_free(app_env); + } + if (NULL != global_env) { + opal_argv_free(global_env); + } + oshmem_info_close_components(); + OBJ_RELEASE(info_cmd_line); + OBJ_DESTRUCT(&mca_types); + for (i=0; i < component_map.size; i++) { + if (NULL != (map = (opal_info_component_map_t*)opal_pointer_array_get_item(&component_map, i))) { + OBJ_RELEASE(map); + } + } + OBJ_DESTRUCT(&component_map); + + opal_info_finalize(); + + /* Put our own call to opal_finalize_util() here because we called + it up above (and it refcounts) */ + opal_finalize_util(); + + return 0; +} diff --git a/oshmem/tools/oshmem_info/oshmem_info.h b/oshmem/tools/oshmem_info/oshmem_info.h new file mode 100644 index 0000000000..30a54b71f7 --- /dev/null +++ b/oshmem/tools/oshmem_info/oshmem_info.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2013 Mellanox Technologies, Inc. + * All rights reserved. + * + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#ifndef OSHMEM_INFO_TOOL_H +#define OSHMEM_INFO_TOOL_H +#include "oshmem_config.h" + +#include "opal/class/opal_list.h" +#include "opal/class/opal_pointer_array.h" +#include "opal/util/cmd_line.h" +#include "opal/mca/mca.h" + +BEGIN_C_DECLS + +/* + * Globals + */ + +extern const char *oshmem_info_type_oshmem; + +void oshmem_info_do_config(bool want_all); + +END_C_DECLS + +#endif /* OSHMEM_INFO_TOOL_H */ diff --git a/oshmem/tools/oshmem_info/param.c b/oshmem/tools/oshmem_info/param.c new file mode 100644 index 0000000000..729c3b926b --- /dev/null +++ b/oshmem/tools/oshmem_info/param.c @@ -0,0 +1,606 @@ +/* + * Copyright (c) 2013 Mellanox Technologies, Inc. + * All rights reserved. + * + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "oshmem_config.h" +#include "mpi.h" +#include "shmem.h" + +#include +#include +#ifdef HAVE_UNISTD_H +#include +#endif +#ifdef HAVE_SYS_PARAM_H +#include +#endif +#ifdef HAVE_NETDB_H +#include +#endif + +#include MCA_timer_IMPLEMENTATION_HEADER +#include "opal/class/opal_value_array.h" +#include "opal/class/opal_pointer_array.h" +#include "opal/util/printf.h" +#include "opal/memoryhooks/memory.h" +#include "opal/runtime/opal_info_support.h" + +#if OMPI_RTE_ORTE +#include "orte/util/show_help.h" +#endif + +#include "ompi/tools/ompi_info/ompi_info.h" +#include "ompi/include/mpi_portable_platform.h" + +#include "oshmem/tools/oshmem_info/oshmem_info.h" + + +const char *ompi_info_deprecated_value = "deprecated-ompi-info-value"; + +static void append(char *dest, size_t max, int *first, char *src) +{ + size_t len; + + if (NULL == src) { + return; + } + + len = max - strlen(dest); + if (!(*first)) { + strncat(dest, ", ", len); + len = max - strlen(dest); + } + strncat(dest, src, len); + *first = 0; +} + + +/* + * do_config + * Accepts: + * - want_all: boolean flag; TRUE -> display all options + * FALSE -> display selected options + * + * This function displays all the options with which the current + * installation of ompi was configured. There are many options here + * that are carried forward from OMPI-7 and are not mca parameters + * in OMPI-10. I have to dig through the invalid options and replace + * them with OMPI-10 options. + */ +void oshmem_info_do_config(bool want_all) +{ + char *cxx; + char *fortran_mpifh; + char *fortran_usempi; + char *fortran_usempif08; + char *fortran_usempif08_compliance; + char *fortran_have_ignore_tkr; + char *fortran_have_f08_assumed_rank; + char *fortran_build_f08_subarrays; + char *fortran_have_optional_args; + char *fortran_have_bind_c; + char *fortran_have_private; + char *fortran_have_abstract; + char *fortran_have_asynchronous; + char *fortran_have_procedure; + char *fortran_08_using_wrappers_for_choice_buffer_functions; + char *java; + char *heterogeneous; + char *memprofile; + char *memdebug; + char *debug; + char *mpi_interface_warning; + char *cprofiling; + char *cxxprofiling; + char *fortran_mpifh_profiling; + char *fortran_usempi_profiling; + char *fortran_usempif08_profiling; + char *cxxexceptions; + char *threads; + char *want_libltdl; +#if OMPI_RTE_ORTE + char *mpirun_prefix_by_default; +#endif + char *sparse_groups; + char *have_mpi_io; + char *wtime_support; + char *symbol_visibility; + char *ft_support; + char *crdebug_support; + char *topology_support; + char *vt_support; + + /* Do a little preprocessor trickery here to figure opal_info_out the + * tri-state of MPI_PARAM_CHECK (which will be either 0, 1, or + * ompi_mpi_param_check). The preprocessor will only allow + * comparisons against constants, so you'll get a warning if you + * check MPI_PARAM_CHECK against 0 or 1, but its real value is the + * char *ompi_mpi_param_check. So define ompi_mpi_param_check to + * be a constant, and then all the preprocessor comparisons work + * opal_info_out ok. Note that we chose the preprocessor + * comparison ropal_info_oute because it is not sufficient to + * simply set the variable ompi_mpi_param_check to a non-0/non-1 + * value. This is because the compiler will generate a warning + * that that C variable is unused when MPI_PARAM_CHECK is + * hard-coded to 0 or 1. + */ + char *paramcheck; +#define ompi_mpi_param_check 999 +#if 0 == MPI_PARAM_CHECK + paramcheck = "never"; +#elif 1 == MPI_PARAM_CHECK + paramcheck = "always"; +#else + paramcheck = "runtime"; +#endif + + /* setup the strings that don't require allocations*/ + cxx = OMPI_BUILD_CXX_BINDINGS ? "yes" : "no"; + if (OMPI_BUILD_FORTRAN_USEMPI_BINDINGS) { + if (OMPI_FORTRAN_HAVE_IGNORE_TKR) { + fortran_usempi = "yes (full: ignore TKR)"; + } else { + fortran_usempi = "yes (limited: overloading)"; + } + } else { + fortran_usempi = "no"; + } + fortran_usempif08 = OMPI_BUILD_FORTRAN_USEMPIF08_BINDINGS ? "yes" : "no"; + fortran_have_f08_assumed_rank = OMPI_FORTRAN_HAVE_F08_ASSUMED_RANK ? + "yes" : "no"; + fortran_build_f08_subarrays = OMPI_BUILD_FORTRAN_F08_SUBARRAYS ? + "yes" : "no"; + fortran_have_optional_args = OMPI_FORTRAN_HAVE_OPTIONAL_ARGS ? + "yes" : "no"; + fortran_have_bind_c = OMPI_FORTRAN_HAVE_BIND_C ? "yes" : "no"; + fortran_have_private = OMPI_FORTRAN_HAVE_PRIVATE ? "yes" : "no"; + fortran_have_abstract = OMPI_FORTRAN_HAVE_ABSTRACT ? "yes" : "no"; + fortran_have_asynchronous = OMPI_FORTRAN_HAVE_ASYNCHRONOUS ? "yes" : "no"; + fortran_have_procedure = OMPI_FORTRAN_HAVE_PROCEDURE ? "yes" : "no"; + fortran_08_using_wrappers_for_choice_buffer_functions = + OMPI_FORTRAN_NEED_WRAPPER_ROUTINES ? "yes" : "no"; + + /* Build a string describing what level of compliance the mpi_f08 + module has */ + if (OMPI_BUILD_FORTRAN_USEMPIF08_BINDINGS) { + + /* Do we have everything? */ + if (OMPI_BUILD_FORTRAN_F08_SUBARRAYS && + OMPI_FORTRAN_HAVE_PRIVATE && + OMPI_FORTRAN_HAVE_ABSTRACT && + OMPI_FORTRAN_HAVE_ASYNCHRONOUS && + OMPI_FORTRAN_HAVE_PROCEDURE && + OMPI_FORTRAN_NEED_WRAPPER_ROUTINES) { + fortran_usempif08_compliance = strdup("The mpi_f08 module is available, and is fully compliant. w00t!"); + } else { + char f08[1024]; + int first = 1; + snprintf(f08, sizeof(f08), + "The mpi_f08 module is available, but due to limitations in the %s compiler, does not support the following: ", + OMPI_FC); + if (!OMPI_BUILD_FORTRAN_F08_SUBARRAYS) { + append(f08, sizeof(f08), &first, "array subsections"); + } + if (!OMPI_FORTRAN_HAVE_PRIVATE) { + append(f08, sizeof(f08), &first, "private MPI_Status members"); + } + if (!OMPI_FORTRAN_HAVE_ABSTRACT) { + append(f08, sizeof(f08), &first, "ABSTRACT INTERFACE function pointers"); + } + if (!OMPI_FORTRAN_HAVE_ASYNCHRONOUS) { + append(f08, sizeof(f08), &first, "Fortran '08-specified ASYNCHRONOUS behavior"); + } + if (!OMPI_FORTRAN_HAVE_PROCEDURE) { + append(f08, sizeof(f08), &first, "PROCEDUREs"); + } + if (OMPI_FORTRAN_NEED_WRAPPER_ROUTINES) { + append(f08, sizeof(f08), &first, "direct passthru (where possible) to underlying Open MPI's C functionality"); + } + fortran_usempif08_compliance = strdup(f08); + } + } else { + fortran_usempif08_compliance = strdup("The mpi_f08 module was not built"); + } + + java = OMPI_WANT_JAVA_BINDINGS ? "yes" : "no"; + heterogeneous = OPAL_ENABLE_HETEROGENEOUS_SUPPORT ? "yes" : "no"; + memprofile = OPAL_ENABLE_MEM_PROFILE ? "yes" : "no"; + memdebug = OPAL_ENABLE_MEM_DEBUG ? "yes" : "no"; + debug = OPAL_ENABLE_DEBUG ? "yes" : "no"; + mpi_interface_warning = OMPI_WANT_MPI_INTERFACE_WARNING ? "yes" : "no"; + cprofiling = OMPI_ENABLE_MPI_PROFILING ? "yes" : "no"; + cxxprofiling = (OMPI_BUILD_CXX_BINDINGS && OMPI_ENABLE_MPI_PROFILING) ? "yes" : "no"; + cxxexceptions = (OMPI_BUILD_CXX_BINDINGS && OMPI_HAVE_CXX_EXCEPTION_SUPPORT) ? "yes" : "no"; + fortran_mpifh_profiling = (OMPI_ENABLE_MPI_PROFILING && OMPI_BUILD_FORTRAN_MPIFH_BINDINGS) ? "yes" : "no"; + fortran_usempi_profiling = (OMPI_ENABLE_MPI_PROFILING && OMPI_BUILD_FORTRAN_USEMPI_BINDINGS) ? "yes" : "no"; + fortran_usempif08_profiling = (OMPI_ENABLE_MPI_PROFILING && OMPI_BUILD_FORTRAN_USEMPIF08_BINDINGS) ? "yes" : "no"; + want_libltdl = OPAL_WANT_LIBLTDL ? "yes" : "no"; +#if OMPI_RTE_ORTE + mpirun_prefix_by_default = ORTE_WANT_ORTERUN_PREFIX_BY_DEFAULT ? "yes" : "no"; +#endif + sparse_groups = OMPI_GROUP_SPARSE ? "yes" : "no"; + have_mpi_io = OMPI_PROVIDE_MPI_FILE_INTERFACE ? "yes" : "no"; + wtime_support = OPAL_TIMER_USEC_NATIVE ? "native" : "gettimeofday"; + symbol_visibility = OPAL_C_HAVE_VISIBILITY ? "yes" : "no"; + topology_support = OPAL_HAVE_HWLOC ? "yes" : "no"; + vt_support = OMPI_ENABLE_CONTRIB_vt ? "yes" : "no"; + + /* setup strings that require allocation */ + if (OMPI_BUILD_FORTRAN_MPIFH_BINDINGS) { + (void)asprintf(&fortran_mpifh, "yes (%s)", + (OPAL_HAVE_WEAK_SYMBOLS ? "all" : + (OMPI_FORTRAN_CAPS ? "caps" : + (OMPI_FORTRAN_PLAIN ? "lower case" : + (OMPI_FORTRAN_SINGLE_UNDERSCORE ? "single underscore" : "double underscore"))))); + } else { + fortran_mpifh = strdup("no"); + } + + if (OMPI_FORTRAN_HAVE_IGNORE_TKR) { + /* OMPI_FORTRAN_IGNORE_TKR_PREDECL is already in quotes; it + didn't work consistently to put it in _STRINGIFY because + sometimes the compiler would actually interpret the pragma + in there before stringify-ing it. */ + (void)asprintf(&fortran_have_ignore_tkr, "yes (%s)", + OMPI_FORTRAN_IGNORE_TKR_PREDECL); + } else { + fortran_have_ignore_tkr = strdup("no"); + } + + if (OPAL_HAVE_SOLARIS_THREADS || OPAL_HAVE_POSIX_THREADS) { /* should just test OPAL_HAVE_THREADS */ +#if OMPI_RTE_ORTE + (void)asprintf(&threads, "%s (MPI_THREAD_MULTIPLE: %s, OPAL support: %s, OMPI progress: %s, ORTE progress: yes, Event lib: yes)", + OPAL_HAVE_SOLARIS_THREADS ? "solaris" : + (OPAL_HAVE_POSIX_THREADS ? "posix" : "type unknown"), /* "type unknown" can presumably never happen */ + OMPI_ENABLE_THREAD_MULTIPLE ? "yes" : "no", + OPAL_ENABLE_MULTI_THREADS ? "yes" : "no", + OMPI_ENABLE_PROGRESS_THREADS ? "yes" : "no"); +#else + (void)asprintf(&threads, "%s (MPI_THREAD_MULTIPLE: %s, OPAL support: %s, OMPI progress: %s, Event lib: yes)", + OPAL_HAVE_SOLARIS_THREADS ? "solaris" : + (OPAL_HAVE_POSIX_THREADS ? "posix" : "type unknown"), /* "type unknown" can presumably never happen */ + OMPI_ENABLE_THREAD_MULTIPLE ? "yes" : "no", + OPAL_ENABLE_MULTI_THREADS ? "yes" : "no", + OMPI_ENABLE_PROGRESS_THREADS ? "yes" : "no"); +#endif + } else { + threads = strdup("no"); + } + + (void)asprintf(&ft_support, "%s (checkpoint thread: %s)", + OPAL_ENABLE_FT ? "yes" : "no", OPAL_ENABLE_FT_THREAD ? "yes" : "no"); + + (void)asprintf(&crdebug_support, "%s", + OPAL_ENABLE_CRDEBUG ? "yes" : "no"); + + /* output values */ + opal_info_out("Configured by", "config:user", OPAL_CONFIGURE_USER); + opal_info_out("Configured on", "config:timestamp", OPAL_CONFIGURE_DATE); + opal_info_out("Configure host", "config:host", OPAL_CONFIGURE_HOST); + + opal_info_out("Built by", "build:user", OMPI_BUILD_USER); + opal_info_out("Built on", "build:timestamp", OMPI_BUILD_DATE); + opal_info_out("Built host", "build:host", OMPI_BUILD_HOST); + + opal_info_out("C bindings", "bindings:c", "yes"); + opal_info_out("C++ bindings", "bindings:cxx", cxx); + opal_info_out("Fort mpif.h", "bindings:mpif.h", fortran_mpifh); + free(fortran_mpifh); + opal_info_out("Fort use mpi", "bindings:use_mpi", + fortran_usempi); + opal_info_out("Fort use mpi size", "bindings:use_mpi:size", + ompi_info_deprecated_value); + opal_info_out("Fort use mpi_f08", "bindings:use_mpi_f08", + fortran_usempif08); + opal_info_out("Fort mpi_f08 compliance", "bindings:use_mpi_f08:compliance", + fortran_usempif08_compliance); + if (NULL != fortran_usempif08_compliance) { + free(fortran_usempif08_compliance); + } + opal_info_out("Fort mpi_f08 subarrays", "bindings:use_mpi_f08:subarrays-supported", + fortran_build_f08_subarrays); + opal_info_out("Java bindings", "bindings:java", java); + + opal_info_out("Wrapper compiler rpath", "compiler:all:rpath", + WRAPPER_RPATH_SUPPORT); + opal_info_out("C compiler", "compiler:c:command", OPAL_CC); + opal_info_out("C compiler absolute", "compiler:c:absolute", + OPAL_CC_ABSOLUTE); + opal_info_out("C compiler family name", "compiler:c:familyname", + _STRINGIFY(OPAL_BUILD_PLATFORM_COMPILER_FAMILYNAME)); + opal_info_out("C compiler version", "compiler:c:version", + _STRINGIFY(OPAL_BUILD_PLATFORM_COMPILER_VERSION_STR)); + + if (want_all) { + opal_info_out_int("C char size", "compiler:c:sizeof:char", sizeof(char)); + /* JMS: should be fixed in MPI-2.2 to differentiate between C + _Bool and C++ bool. For the moment, the code base assumes + that they are the same. Because of opal_config_bottom.h, + we can sizeof(bool) here, so we might as well -- even + though this technically isn't right. This should be fixed + when we update to MPI-2.2. See below for note about C++ + bool alignment. */ + opal_info_out_int("C bool size", "compiler:c:sizeof:bool", sizeof(bool)); + opal_info_out_int("C short size", "compiler:c:sizeof:short", sizeof(short)); + opal_info_out_int("C int size", "compiler:c:sizeof:int", sizeof(int)); + opal_info_out_int("C long size", "compiler:c:sizeof:long", sizeof(long)); + opal_info_out_int("C float size", "compiler:c:sizeof:float", sizeof(float)); + opal_info_out_int("C double size", "compiler:c:sizeof:double", sizeof(double)); + opal_info_out_int("C pointer size", "compiler:c:sizeof:pointer", sizeof(void *)); + opal_info_out_int("C char align", "compiler:c:align:char", OPAL_ALIGNMENT_CHAR); +#if OMPI_BUILD_CXX_BINDINGS + /* JMS: See above for note about C++ bool size. We don't have + the bool alignment the way configure currently runs -- need + to clean this up when we update for MPI-2.2. */ + opal_info_out_int("C bool align", "compiler:c:align:bool", OPAL_ALIGNMENT_CXX_BOOL); +#else + opal_info_out("C bool align", "compiler:c:align:bool", "skipped"); +#endif + opal_info_out_int("C int align", "compiler:c:align:int", OPAL_ALIGNMENT_INT); + opal_info_out_int("C float align", "compiler:c:align:float", OPAL_ALIGNMENT_FLOAT); + opal_info_out_int("C double align", "compiler:c:align:double", OPAL_ALIGNMENT_DOUBLE); + } + + opal_info_out("C++ compiler", "compiler:cxx:command", OMPI_CXX); + opal_info_out("C++ compiler absolute", "compiler:cxx:absolute", OMPI_CXX_ABSOLUTE); + opal_info_out("Fort compiler", "compiler:fortran:command", OMPI_FC); + opal_info_out("Fort compiler abs", "compiler:fortran:absolute", + OMPI_FC_ABSOLUTE); + opal_info_out("Fort ignore TKR", "compiler:fortran:ignore_tkr", + fortran_have_ignore_tkr); + free(fortran_have_ignore_tkr); + opal_info_out("Fort 08 assumed shape", + "compiler:fortran:f08_assumed_rank", + fortran_have_f08_assumed_rank); + opal_info_out("Fort optional args", + "compiler:fortran:optional_arguments", + fortran_have_optional_args); + opal_info_out("Fort BIND(C)", + "compiler:fortran:bind_c", + fortran_have_bind_c); + opal_info_out("Fort PRIVATE", + "compiler:fortran:private", + fortran_have_private); + opal_info_out("Fort ABSTRACT", + "compiler:fortran:abstract", + fortran_have_abstract); + opal_info_out("Fort ASYNCHRONOUS", + "compiler:fortran:asynchronous", + fortran_have_asynchronous); + opal_info_out("Fort PROCEDURE", + "compiler:fortran:procedure", + fortran_have_procedure); + opal_info_out("Fort f08 using wrappers", + "compiler:fortran:08_wrappers", + fortran_08_using_wrappers_for_choice_buffer_functions); + + if (want_all) { + + /* Will always have the size of Fortran integer */ + + opal_info_out_int("Fort integer size", "compiler:fortran:sizeof:integer", + OMPI_SIZEOF_FORTRAN_INTEGER); + + opal_info_out_int("Fort logical size", "compiler:fortran:sizeof:logical", + OMPI_SIZEOF_FORTRAN_LOGICAL); + opal_info_out_int("Fort logical value true", "compiler:fortran:value:true", + OMPI_FORTRAN_VALUE_TRUE); + + + /* May or may not have the other Fortran sizes */ + + if (OMPI_BUILD_FORTRAN_MPIFH_BINDINGS || + OMPI_BUILD_FORTRAN_USEMPI_BINDINGS || + OMPI_BUILD_FORTRAN_USEMPIF08_BINDINGS) { + opal_info_out("Fort have integer1", "compiler:fortran:have:integer1", + OMPI_HAVE_FORTRAN_INTEGER1 ? "yes" : "no"); + opal_info_out("Fort have integer2", "compiler:fortran:have:integer2", + OMPI_HAVE_FORTRAN_INTEGER2 ? "yes" : "no"); + opal_info_out("Fort have integer4", "compiler:fortran:have:integer4", + OMPI_HAVE_FORTRAN_INTEGER4 ? "yes" : "no"); + opal_info_out("Fort have integer8", "compiler:fortran:have:integer8", + OMPI_HAVE_FORTRAN_INTEGER8 ? "yes" : "no"); + opal_info_out("Fort have integer16", "compiler:fortran:have:integer16", + OMPI_HAVE_FORTRAN_INTEGER16 ? "yes" : "no"); + + opal_info_out("Fort have real4", "compiler:fortran:have:real4", + OMPI_HAVE_FORTRAN_REAL4 ? "yes" : "no"); + opal_info_out("Fort have real8", "compiler:fortran:have:real8", + OMPI_HAVE_FORTRAN_REAL8 ? "yes" : "no"); + opal_info_out("Fort have real16", "compiler:fortran:have:real16", + OMPI_HAVE_FORTRAN_REAL16 && OMPI_REAL16_MATCHES_C ? "yes" : "no"); + + opal_info_out("Fort have complex8", "compiler:fortran:have:complex8", + OMPI_HAVE_FORTRAN_COMPLEX8 ? "yes" : "no"); + opal_info_out("Fort have complex16", "compiler:fortran:have:complex16", + OMPI_HAVE_FORTRAN_COMPLEX16 ? "yes" : "no"); + opal_info_out("Fort have complex32", "compiler:fortran:have:complex32", + OMPI_HAVE_FORTRAN_COMPLEX32 && OMPI_REAL16_MATCHES_C ? "yes" : "no"); + + opal_info_out_int("Fort integer1 size", "compiler:fortran:sizeof:integer1", + OMPI_HAVE_FORTRAN_INTEGER1 ? OMPI_SIZEOF_FORTRAN_INTEGER1 : -1); + opal_info_out_int("Fort integer2 size", "compiler:fortran:sizeof:integer2", + OMPI_HAVE_FORTRAN_INTEGER2 ? OMPI_SIZEOF_FORTRAN_INTEGER2 : -1); + opal_info_out_int("Fort integer4 size", "compiler:fortran:sizeof:integer4", + OMPI_HAVE_FORTRAN_INTEGER4 ? OMPI_SIZEOF_FORTRAN_INTEGER4 : -1); + opal_info_out_int("Fort integer8 size", "compiler:fortran:sizeof:integer8", + OMPI_HAVE_FORTRAN_INTEGER8 ? OMPI_SIZEOF_FORTRAN_INTEGER8 : -1); + opal_info_out_int("Fort integer16 size", "compiler:fortran:sizeof:integer16", + OMPI_HAVE_FORTRAN_INTEGER16 ? OMPI_SIZEOF_FORTRAN_INTEGER16 : -1); + + opal_info_out_int("Fort real size", "compiler:fortran:sizeof:real", + OMPI_SIZEOF_FORTRAN_REAL); + opal_info_out_int("Fort real4 size", "compiler:fortran:sizeof:real4", + OMPI_HAVE_FORTRAN_REAL4 ? OMPI_SIZEOF_FORTRAN_REAL4 : -1); + opal_info_out_int("Fort real8 size", "compiler:fortran:sizeof:real8", + OMPI_HAVE_FORTRAN_REAL8 ? OMPI_SIZEOF_FORTRAN_REAL8 : -1); + opal_info_out_int("Fort real16 size", "compiler:fortran:sizeof:real17", + OMPI_HAVE_FORTRAN_REAL16 ? OMPI_SIZEOF_FORTRAN_REAL16 : -1); + + opal_info_out_int("Fort dbl prec size", + "compiler:fortran:sizeof:double_precision", + OMPI_SIZEOF_FORTRAN_DOUBLE_PRECISION); + + opal_info_out_int("Fort cplx size", "compiler:fortran:sizeof:complex", + OMPI_SIZEOF_FORTRAN_COMPLEX); + opal_info_out_int("Fort dbl cplx size", + "compiler:fortran:sizeof:double_complex", + OMPI_HAVE_FORTRAN_DOUBLE_COMPLEX ? OMPI_SIZEOF_FORTRAN_DOUBLE_COMPLEX : -1); + opal_info_out_int("Fort cplx8 size", "compiler:fortran:sizeof:complex8", + OMPI_HAVE_FORTRAN_COMPLEX8 ? OMPI_SIZEOF_FORTRAN_COMPLEX8 : -1); + opal_info_out_int("Fort cplx16 size", "compiler:fortran:sizeof:complex16", + OMPI_HAVE_FORTRAN_COMPLEX16 ? OMPI_SIZEOF_FORTRAN_COMPLEX16 : -1); + opal_info_out_int("Fort cplx32 size", "compiler:fortran:sizeof:complex32", + OMPI_HAVE_FORTRAN_COMPLEX32 ? OMPI_SIZEOF_FORTRAN_COMPLEX32 : -1); + + opal_info_out_int("Fort integer align", "compiler:fortran:align:integer", + OMPI_ALIGNMENT_FORTRAN_INTEGER); + opal_info_out_int("Fort integer1 align", "compiler:fortran:align:integer1", + OMPI_HAVE_FORTRAN_INTEGER1 ? OMPI_ALIGNMENT_FORTRAN_INTEGER1 : -1); + opal_info_out_int("Fort integer2 align", "compiler:fortran:align:integer2", + OMPI_HAVE_FORTRAN_INTEGER2 ? OMPI_ALIGNMENT_FORTRAN_INTEGER2 : -1); + opal_info_out_int("Fort integer4 align", "compiler:fortran:align:integer4", + OMPI_HAVE_FORTRAN_INTEGER4 ? OMPI_ALIGNMENT_FORTRAN_INTEGER4 : -1); + opal_info_out_int("Fort integer8 align", "compiler:fortran:align:integer8", + OMPI_HAVE_FORTRAN_INTEGER8 ? OMPI_ALIGNMENT_FORTRAN_INTEGER8 : -1); + opal_info_out_int("Fort integer16 align", "compiler:fortran:align:integer16", + OMPI_HAVE_FORTRAN_INTEGER16 ? OMPI_ALIGNMENT_FORTRAN_INTEGER16 : -1); + + opal_info_out_int("Fort real align", "compiler:fortran:align:real", + OMPI_ALIGNMENT_FORTRAN_REAL); + opal_info_out_int("Fort real4 align", "compiler:fortran:align:real4", + OMPI_HAVE_FORTRAN_REAL4 ? OMPI_ALIGNMENT_FORTRAN_REAL4 : -1); + opal_info_out_int("Fort real8 align", "compiler:fortran:align:real8", + OMPI_HAVE_FORTRAN_REAL8 ? OMPI_ALIGNMENT_FORTRAN_REAL8 : -1); + opal_info_out_int("Fort real16 align", "compiler:fortran:align:real16", + OMPI_HAVE_FORTRAN_REAL16 ? OMPI_ALIGNMENT_FORTRAN_REAL16 : -1); + + opal_info_out_int("Fort dbl prec align", + "compiler:fortran:align:double_precision", + OMPI_ALIGNMENT_FORTRAN_DOUBLE_PRECISION); + + opal_info_out_int("Fort cplx align", "compiler:fortran:align:complex", + OMPI_ALIGNMENT_FORTRAN_COMPLEX); + opal_info_out_int("Fort dbl cplx align", + "compiler:fortran:align:double_complex", + OMPI_HAVE_FORTRAN_DOUBLE_COMPLEX ? OMPI_ALIGNMENT_FORTRAN_DOUBLE_COMPLEX : -1); + opal_info_out_int("Fort cplx8 align", "compiler:fortran:align:complex8", + OMPI_HAVE_FORTRAN_COMPLEX8 ? OMPI_ALIGNMENT_FORTRAN_COMPLEX8 : -1); + opal_info_out_int("Fort cplx16 align", "compiler:fortran:align:complex16", + OMPI_HAVE_FORTRAN_COMPLEX16 ? OMPI_ALIGNMENT_FORTRAN_COMPLEX16 : -1); + opal_info_out_int("Fort cplx32 align", "compiler:fortran:align:complex32", + OMPI_HAVE_FORTRAN_COMPLEX32 ? OMPI_ALIGNMENT_FORTRAN_COMPLEX32 : -1); + + } else { + opal_info_out("Fort real size", "compiler:fortran:sizeof:real", "skipped"); + opal_info_out("Fort dbl prec size", + "compiler:fortran:sizeof:double_precision", "skipped"); + opal_info_out("Fort cplx size", "compiler:fortran:sizeof:complex", "skipped"); + opal_info_out("Fort dbl cplx size", + "compiler:fortran:sizeof:double_complex", "skipped"); + + opal_info_out("Fort integer align", "compiler:fortran:align:integer", "skipped"); + opal_info_out("Fort real align", "compiler:fortran:align:real", "skipped"); + opal_info_out("Fort dbl prec align", + "compiler:fortran:align:double_precision","skipped"); + opal_info_out("Fort cplx align", "compiler:fortran:align:complex", "skipped"); + opal_info_out("Fort dbl cplx align", + "compiler:fortran:align:double_complex", "skipped"); + } + } + + opal_info_out("C profiling", "option:profiling:c", cprofiling); + opal_info_out("C++ profiling", "option:profiling:cxx", cxxprofiling); + opal_info_out("Fort mpif.h profiling", "option:profiling:mpif.h", + fortran_mpifh_profiling); + opal_info_out("Fort use mpi profiling", "option:profiling:use_mpi", + fortran_usempi_profiling); + opal_info_out("Fort use mpi_f08 prof", + "option:profiling:use_mpi_f08", + fortran_usempif08_profiling); + + opal_info_out("C++ exceptions", "option:cxx_exceptions", cxxexceptions); + opal_info_out("Thread support", "option:threads", threads); + free(threads); + opal_info_out("Sparse Groups", "option:sparse:groups", sparse_groups); + + if (want_all) { + + /* Don't display the build CPPFLAGS or CXXCPPFLAGS because they're + * just -I$(top_srcdir)/include, etc. Hence, they're a) boring, + * and c) specific for ompi_info. + */ + + opal_info_out("Build CFLAGS", "option:build:cflags", OMPI_BUILD_CFLAGS); + opal_info_out("Build CXXFLAGS", "option:build:cxxflags", OMPI_BUILD_CXXFLAGS); + opal_info_out("Build FCFLAGS", "option:build:fcflags", OMPI_BUILD_FCFLAGS); + opal_info_out("Build LDFLAGS", "option:build:ldflags", OMPI_BUILD_LDFLAGS); + opal_info_out("Build LIBS", "option:build:libs", OMPI_BUILD_LIBS); + + opal_info_out("Wrapper extra CFLAGS", "option:wrapper:extra_cflags", + WRAPPER_EXTRA_CFLAGS); + opal_info_out("Wrapper extra CXXFLAGS", "option:wrapper:extra_cxxflags", + WRAPPER_EXTRA_CXXFLAGS); + opal_info_out("Wrapper extra FCFLAGS", "option:wrapper:extra_fcflags", + WRAPPER_EXTRA_FCFLAGS); + opal_info_out("Wrapper extra LDFLAGS", "option:wrapper:extra_ldflags", + WRAPPER_EXTRA_LDFLAGS); + opal_info_out("Wrapper extra LIBS", "option:wrapper:extra_libs", + WRAPPER_EXTRA_LIBS); + } + + opal_info_out("Internal debug support", "option:debug", debug); + opal_info_out("MPI interface warnings", "option:mpi-interface-warning", mpi_interface_warning); + opal_info_out("MPI parameter check", "option:mpi-param-check", paramcheck); + opal_info_out("Memory profiling support", "option:mem-profile", memprofile); + opal_info_out("Memory debugging support", "option:mem-debug", memdebug); + opal_info_out("libltdl support", "option:dlopen", want_libltdl); + opal_info_out("Heterogeneous support", "options:heterogeneous", heterogeneous); +#if OMPI_RTE_ORTE + opal_info_out("mpirun default --prefix", "mpirun:prefix_by_default", + mpirun_prefix_by_default); +#endif + opal_info_out("MPI I/O support", "options:mpi-io", have_mpi_io); + opal_info_out("MPI_WTIME support", "options:mpi-wtime", wtime_support); + opal_info_out("Symbol vis. support", "options:visibility", symbol_visibility); + opal_info_out("Host topology support", "options:host-topology", + topology_support); + + opal_info_out("MPI extensions", "options:mpi_ext", OMPI_MPIEXT_COMPONENTS); + + opal_info_out("FT Checkpoint support", "options:ft_support", ft_support); + free(ft_support); + + opal_info_out("C/R Enabled Debugging", "options:crdebug_support", crdebug_support); + free(crdebug_support); + + opal_info_out("VampirTrace support", "options:vt", vt_support); + + opal_info_out_int("MPI_MAX_PROCESSOR_NAME", "options:mpi-max-processor-name", + MPI_MAX_PROCESSOR_NAME); + opal_info_out_int("MPI_MAX_ERROR_STRING", "options:mpi-max-error-string", + MPI_MAX_ERROR_STRING); + opal_info_out_int("MPI_MAX_OBJECT_NAME", "options:mpi-max-object-name", + MPI_MAX_OBJECT_NAME); + opal_info_out_int("MPI_MAX_INFO_KEY", "options:mpi-max-info-key", + MPI_MAX_INFO_KEY); + opal_info_out_int("MPI_MAX_INFO_VAL", "options:mpi-max-info-val", + MPI_MAX_INFO_VAL); + opal_info_out_int("MPI_MAX_PORT_NAME", "options:mpi-max-port-name", + MPI_MAX_PORT_NAME); +#if OMPI_PROVIDE_MPI_FILE_INTERFACE + opal_info_out_int("MPI_MAX_DATAREP_STRING", "options:mpi-max-datarep-string", + MPI_MAX_DATAREP_STRING); +#else + opal_info_out("MPI_MAX_DATAREP_STRING", "options:mpi-max-datarep-string", + "IO interface not provided"); +#endif + +} diff --git a/oshmem/tools/wrappers/Makefile.am b/oshmem/tools/wrappers/Makefile.am index f8fe308388..1ee380b3b1 100644 --- a/oshmem/tools/wrappers/Makefile.am +++ b/oshmem/tools/wrappers/Makefile.am @@ -25,7 +25,6 @@ install-exec-hook: (cd $(DESTDIR)$(bindir); rm -f oshcc$(EXEEXT); $(LN_S) mpicc oshcc) (cd $(DESTDIR)$(bindir); rm -f shmemfort$(EXEEXT); $(LN_S) mpifort shmemfort) (cd $(DESTDIR)$(bindir); rm -f oshfort$(EXEEXT); $(LN_S) mpifort oshfort) - (cd $(DESTDIR)$(bindir); rm -f shmem_info$(EXEEXT); $(LN_S) ompi_info shmem_info) install-data-hook: (cd $(DESTDIR)$(pkgdatadir); rm -f oshcc-wrapper-data.txt; $(LN_S) shmemcc-wrapper-data.txt oshcc-wrapper-data.txt) @@ -38,7 +37,6 @@ uninstall-local: $(DESTDIR)$(bindir)/oshcc$(EXEEXT) \ $(DESTDIR)$(bindir)/shmemfort$(EXEEXT) \ $(DESTDIR)$(bindir)/oshfort$(EXEEXT) \ - $(DESTDIR)$(bindir)/shmem_info$(EXEEXT) \ $(DESTDIR)$(pkgdatadir)/shmemcc-wrapper-data.txt \ $(DESTDIR)$(pkgdatadir)/oshcc-wrapper-data.txt \ $(DESTDIR)$(pkgdatadir)/shmemfort-wrapper-data.txt \