ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

Sync with PMIx tarball, bringing across the warning fixes pointed out by Gilles

Просмотр исходного кода
Этот коммит содержится в:
Ralph Castain 2015-08-30 21:13:55 -07:00
родитель 7e6a213465
Коммит bcabd1e282
26 изменённых файлов: 407 добавлений и 264 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

4
opal/mca/pmix/pmix1xx/pmix/VERSION
Просмотреть файл

@ -30,7 +30,7 @@ greek=a1
# command, or with the date (if "git describe" fails) in the form of
# "date<date>".
repo_rev=gitebb9a6a
repo_rev=git11e7b06
# If tarball_version is not empty, it is used as the version string in
# the tarball filename, regardless of all other versions listed in
@ -44,7 +44,7 @@ tarball_version=
# The date when this release was created
date="Aug 28, 2015"
date="Aug 30, 2015"
# The shared library version of each of PMIx's public libraries.
# These versions are maintained in accordance with the "Library

11
opal/mca/pmix/pmix1xx/pmix/config/Makefile.am
Просмотреть файл

@ -1,5 +1,5 @@
# PMIx copyrights:
# Copyright (c) 2013 Intel, Inc. All rights reserved
# Copyright (c) 2013-2015 Intel, Inc. All rights reserved
#
#########################
#
@ -9,22 +9,23 @@
# Copyright (c) 2004-2005 The University of Tennessee and The University
# of Tennessee Research Foundation. All rights
# reserved.
# Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
# 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-2010 Cisco Systems, Inc. All rights reserved.
# Copyright (c) 2010 Oracle and/or its affiliates. All rights
# Copyright (c) 2010 Oracle and/or its affiliates. All rights
# reserved.
#########################
# $COPYRIGHT$
#
#
# Additional copyrights may follow
#
#
# $HEADER$
#
EXTRA_DIST += \
config/c_get_alignment.m4 \
config/pmix_get_version.sh \
config/distscript.sh \
config/pmix_check_attributes.m4 \

72
opal/mca/pmix/pmix1xx/pmix/config/c_get_alignment.m4 Обычный файл
Просмотреть файл

@ -0,0 +1,72 @@
dnl -*- shell-script -*-
dnl
dnl Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
dnl University Research and Technology
dnl Corporation. All rights reserved.
dnl Copyright (c) 2004-2005 The University of Tennessee and The University
dnl of Tennessee Research Foundation. All rights
dnl reserved.
dnl Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
dnl University of Stuttgart. All rights reserved.
dnl Copyright (c) 2004-2005 The Regents of the University of California.
dnl All rights reserved.
dnl Copyright (c) 2009 Sun Microsystems, Inc. All rights reserved.
dnl Copyright (c) 2014-2015 Intel, Inc. All rights reserved.
dnl Copyright (c) 2015 Research Organization for Information Science
dnl and Technology (RIST). All rights reserved.
dnl $COPYRIGHT$
dnl
dnl Additional copyrights may follow
dnl
dnl $HEADER$
dnl
# PMIX_C_GET_ALIGN(type, config_var)
# ----------------------------------
# Determine datatype alignment.
# First arg is type, 2nd arg is config var to define.
# Now that we require C99 compilers, we include stdbool.h
# in the alignment test so that we can find the definition
# of "bool" when we test for its alignment. We might be able
# to avoid this if we test for alignment of _Bool, but
# since we use "bool" in the code, let's be safe and check
# what we use. Yes, they should be the same - but "should" and
# "are" frequently differ
AC_DEFUN([PMIX_C_GET_ALIGNMENT],[
AC_CACHE_CHECK([alignment of $1],
[AS_TR_SH([pmix_cv_c_align_$1])],
[AC_RUN_IFELSE([AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT
#include <stdbool.h> ],
[[
struct foo { char c; $1 x; };
struct foo *p = (struct foo *) malloc(sizeof(struct foo));
int diff;
FILE *f=fopen("conftestval", "w");
if (!f) exit(1);
diff = ((char *)&p->x) - ((char *)&p->c);
fprintf(f, "%d\n", (diff >= 0) ? diff : -diff);
]])], [AS_TR_SH([pmix_cv_c_align_$1])=`cat conftestval`],
[AC_MSG_WARN([*** Problem running configure test!])
AC_MSG_WARN([*** See config.log for details.])
AC_MSG_ERROR([*** Cannot continue.])],
[ # cross compile - do a non-executable test. Trick
# taken from the Autoconf 2.59c. Switch to using
# AC_CHECK_ALIGNOF when we can require Autoconf 2.60.
_AC_COMPUTE_INT([(long int) offsetof (pmix__type_alignof_, y)],
[AS_TR_SH([pmix_cv_c_align_$1])],
[AC_INCLUDES_DEFAULT
#include <stdbool.h>
#ifndef offsetof
# define offsetof(type, member) ((char *) &((type *) 0)->member - (char *) 0)
#endif
typedef struct { char x; $1 y; } pmix__type_alignof_;
],
[AC_MSG_WARN([*** Problem running configure test!])
AC_MSG_WARN([*** See config.log for details.])
AC_MSG_ERROR([*** Cannot continue.])])])])
AC_DEFINE_UNQUOTED([$2], [$AS_TR_SH([pmix_cv_c_align_$1])], [Alignment of type $1])
eval "$2=$AS_TR_SH([pmix_cv_c_align_$1])"
rm -rf conftest* ]) dnl

62
opal/mca/pmix/pmix1xx/pmix/config/pmix.m4
Просмотреть файл

@ -146,7 +146,6 @@ AC_DEFUN([PMIX_SETUP_CORE],[
##################################
# Does the compiler support "ident"-like constructs?
PMIX_CHECK_IDENT([CC], [CFLAGS], [c], [C])
PMIX_SETUP_CC
#
# Check for some types
@ -193,6 +192,31 @@ AC_DEFUN([PMIX_SETUP_CORE],[
AC_CHECK_SIZEOF(pid_t)
#
# Check for type alignments
#
PMIX_C_GET_ALIGNMENT(bool, PMIX_ALIGNMENT_BOOL)
PMIX_C_GET_ALIGNMENT(int8_t, PMIX_ALIGNMENT_INT8)
PMIX_C_GET_ALIGNMENT(int16_t, PMIX_ALIGNMENT_INT16)
PMIX_C_GET_ALIGNMENT(int32_t, PMIX_ALIGNMENT_INT32)
PMIX_C_GET_ALIGNMENT(int64_t, PMIX_ALIGNMENT_INT64)
PMIX_C_GET_ALIGNMENT(char, PMIX_ALIGNMENT_CHAR)
PMIX_C_GET_ALIGNMENT(short, PMIX_ALIGNMENT_SHORT)
PMIX_C_GET_ALIGNMENT(wchar_t, PMIX_ALIGNMENT_WCHAR)
PMIX_C_GET_ALIGNMENT(int, PMIX_ALIGNMENT_INT)
PMIX_C_GET_ALIGNMENT(long, PMIX_ALIGNMENT_LONG)
if test "$ac_cv_type_long_long" = yes; then
PMIX_C_GET_ALIGNMENT(long long, PMIX_ALIGNMENT_LONG_LONG)
fi
PMIX_C_GET_ALIGNMENT(float, PMIX_ALIGNMENT_FLOAT)
PMIX_C_GET_ALIGNMENT(double, PMIX_ALIGNMENT_DOUBLE)
if test "$ac_cv_type_long_double" = yes; then
PMIX_C_GET_ALIGNMENT(long double, PMIX_ALIGNMENT_LONG_DOUBLE)
fi
PMIX_C_GET_ALIGNMENT(void *, PMIX_ALIGNMENT_VOID_P)
PMIX_C_GET_ALIGNMENT(size_t, PMIX_ALIGNMENT_SIZE_T)
#
# Does the C compiler native support "bool"? (i.e., without
@ -265,18 +289,18 @@ AC_DEFUN([PMIX_SETUP_CORE],[
pmix_show_title "Header file tests"
AC_CHECK_HEADERS([arpa/inet.h \
fcntl.h inttypes.h libgen.h \
netinet/in.h \
stdint.h stddef.h \
stdlib.h string.h strings.h \
sys/param.h \
sys/select.h sys/socket.h \
stdarg.h sys/stat.h sys/time.h \
sys/types.h sys/un.h sys/uio.h net/uio.h \
sys/wait.h syslog.h \
time.h unistd.h \
crt_externs.h signal.h \
ioLib.h sockLib.h hostLib.h limits.h])
fcntl.h inttypes.h libgen.h \
netinet/in.h \
stdint.h stddef.h \
stdlib.h string.h strings.h \
sys/param.h \
sys/select.h sys/socket.h \
stdarg.h sys/stat.h sys/time.h \
sys/types.h sys/un.h sys/uio.h net/uio.h \
sys/wait.h syslog.h \
time.h unistd.h \
crt_externs.h signal.h \
ioLib.h sockLib.h hostLib.h limits.h])
# Note that sometimes we have <stdbool.h>, but it doesn't work (e.g.,
# have both Portland and GNU installed; using pgcc will find GNU's
@ -547,7 +571,7 @@ AC_DEFUN([PMIX_SETUP_CORE],[
# final compiler config
############################################################################
pmix_show_subtitle "Compiler flags"
pmix_show_subtitle "Set path-related compiler flags"
#
# This is needed for VPATH builds, so that it will -I the appropriate
@ -569,14 +593,6 @@ AC_DEFUN([PMIX_SETUP_CORE],[
CPPFLAGS='-I$(PMIX_top_srcdir) -I$(PMIX_top_srcdir)/src -I$(PMIX_top_srcdir)/include'" $CPPFLAGS"
fi
#
# Delayed the substitution of CFLAGS and CXXFLAGS until now because
# they may have been modified throughout the course of this script.
#
AC_SUBST(CFLAGS)
AC_SUBST(CPPFLAGS)
# pmixdatadir, pmixlibdir, and pmixinclude are essentially the same as
# pkg*dir, but will always be */pmix.
pmixdatadir='${datadir}/pmix'
@ -639,7 +655,7 @@ else
WANT_PICKY_COMPILER=0
fi
#################### Early development override ####################
if test "$WANT_PICKY_COMPILER" = "0" -a -z "$enable_picky" -a "$PMIX_DEVEL" = 1; then
if test "$WANT_PICKY_COMPILER" = "0" -a -z "$enable_picky" -a "$PMIX_DEVEL" = "1"; then
WANT_PICKY_COMPILER=1
echo "--> developer override: enable picky compiler by default"
fi

152
opal/mca/pmix/pmix1xx/pmix/config/pmix_setup_cc.m4
Просмотреть файл

@ -1,12 +1,5 @@
dnl -*- shell-script -*-
dnl
dnl PMIx copyrights:
dnl Copyright (c) 2013 Intel, Inc. All rights reserved
dnl
dnl########################
dnl This code has been adapted from pmix_setup_cc.m4 in the Open MPI
dnl code base - per the Open MPI license, all copyrights are retained below.
dnl
dnl Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
dnl University Research and Technology
dnl Corporation. All rights reserved.
@ -21,7 +14,9 @@ dnl Copyright (c) 2007-2009 Sun Microsystems, Inc. All rights reserved.
dnl Copyright (c) 2008-2015 Cisco Systems, Inc. All rights reserved.
dnl Copyright (c) 2012 Los Alamos National Security, LLC. All rights
dnl reserved.
dnl########################
dnl Copyright (c) 2015 Research Organization for Information Science
dnl and Technology (RIST). All rights reserved.
dnl Copyright (c) 2015 Intel, Inc. All rights reserved
dnl $COPYRIGHT$
dnl
dnl Additional copyrights may follow
@ -42,11 +37,11 @@ AC_DEFUN([PMIX_SETUP_CC],[
AC_REQUIRE([_PMIX_PROG_CC])
AC_REQUIRE([AM_PROG_CC_C_O])
# require a C99 compiant compiler
# We require a C99 compiant compiler
AC_PROG_CC_C99
# The result of AC_PROG_CC_C99 is stored in ac_cv_prog_cc_c99
if test "x$ac_cv_prog_cc_c99" = xno ; then
AC_MSG_WARN([Open MPI requires a C99 compiler])
AC_MSG_WARN([PMIx requires a C99 compiler])
AC_MSG_ERROR([Aborting.])
fi
@ -73,55 +68,9 @@ AC_DEFUN([PMIX_SETUP_CC],[
#endif])
AC_DEFINE([_GNU_SOURCE])])
# Do we want code coverage
if test "$WANT_COVERAGE" = "1"; then
if test "$pmix_c_vendor" = "gnu" ; then
# For compilers > gcc-4.x, use --coverage for
# compiling and linking to circumvent trouble with
# libgcov.
CFLAGS_orig="$CFLAGS"
LDFLAGS_orig="$LDFLAGS"
CFLAGS="$CFLAGS_orig --coverage"
LDFLAGS="$LDFLAGS_orig --coverage"
PMIX_COVERAGE_FLAGS=
AC_CACHE_CHECK([if $CC supports --coverage],
[pmix_cv_cc_coverage],
[AC_TRY_COMPILE([], [],
[pmix_cv_cc_coverage="yes"],
[pmix_cv_cc_coverage="no"])])
if test "$pmix_cv_cc_coverage" = "yes" ; then
PMIX_COVERAGE_FLAGS="--coverage"
CLEANFILES="*.gcno ${CLEANFILES}"
CONFIG_CLEAN_FILES="*.gcda *.gcov ${CONFIG_CLEAN_FILES}"
else
PMIX_COVERAGE_FLAGS="-ftest-coverage -fprofile-arcs"
CLEANFILES="*.bb *.bbg ${CLEANFILES}"
CONFIG_CLEAN_FILES="*.da *.*.gcov ${CONFIG_CLEAN_FILES}"
fi
CFLAGS="$CFLAGS_orig $PMIX_COVERAGE_FLAGS"
LDFLAGS="$LDFLAGS_orig $PMIX_COVERAGE_FLAGS"
PMIX_UNIQ(CFLAGS)
PMIX_UNIQ(LDFLAGS)
AC_MSG_WARN([$PMIX_COVERAGE_FLAGS has been added to CFLAGS (--enable-coverage)])
WANT_DEBUG=1
else
AC_MSG_WARN([Code coverage functionality is currently available only with GCC])
AC_MSG_ERROR([Configure: Cannot continue])
fi
fi
# Do we want debugging?
if test "$WANT_DEBUG" = "1" -a "$enable_debug_symbols" != "no" ; then
if test "$pmix_c_vendor" = "gnu"; then
CFLAGS="$CFLAGS -g" # keep the -g3 for when it will become a standard option.
else
CFLAGS="$CFLAGS -g"
fi
if test "$WANT_DEBUG" = "1" && test "$enable_debug_symbols" != "no" ; then
CFLAGS="$CFLAGS -g"
PMIX_UNIQ(CFLAGS)
AC_MSG_WARN([-g has been added to CFLAGS (--enable-debug)])
@ -130,13 +79,65 @@ AC_DEFUN([PMIX_SETUP_CC],[
# These flags are generally gcc-specific; even the
# gcc-impersonating compilers won't accept them.
PMIX_CFLAGS_BEFORE_PICKY="$CFLAGS"
if test "$WANT_PICKY_COMPILER" = 1 -a "$pmix_c_vendor" = "gnu" ; then
add="-Wall -Wundef -Wsign-compare"
add="$add -Wmissing-prototypes -Wstrict-prototypes"
add="$add -Wcomment -pedantic"
add="$add -Werror-implicit-function-declaration "
CFLAGS="$CFLAGS $add"
if test $WANT_PICKY_COMPILER -eq 1; then
CFLAGS_orig=$CFLAGS
add=
# These flags are likely GCC-specific (or, more specifically,
# we don't have general tests for each one, and we know they
# work with all versions of GCC that we have used throughout
# the years, so we'll keep them limited just to GCC).
if test "$pmix_c_vendor" = "gnu" ; then
add="$add -Wall -Wundef -Wno-long-long -Wsign-compare"
add="$add -Wmissing-prototypes -Wstrict-prototypes"
add="$add -Wcomment -pedantic"
fi
# see if -Wno-long-double works...
# Starting with GCC-4.4, the compiler complains about not
# knowing -Wno-long-double, only if -Wstrict-prototypes is set, too.
#
# Actually, this is not real fix, as GCC will pass on any -Wno- flag,
# have fun with the warning: -Wno-britney
CFLAGS="$CFLAGS_orig $add -Wno-long-double -Wstrict-prototypes"
AC_CACHE_CHECK([if $CC supports -Wno-long-double],
[pmix_cv_cc_wno_long_double],
[AC_TRY_COMPILE([], [],
[
dnl So -Wno-long-double did not produce any errors...
dnl We will try to extract a warning regarding
dnl unrecognized or ignored options
AC_TRY_COMPILE([], [long double test;],
[
pmix_cv_cc_wno_long_double="yes"
if test -s conftest.err ; then
dnl Yes, it should be "ignor", in order to catch ignoring and ignore
for i in unknown invalid ignor unrecognized ; do
$GREP -iq $i conftest.err
if test "$?" = "0" ; then
pmix_cv_cc_wno_long_double="no"
break;
fi
done
fi
],
[pmix_cv_cc_wno_long_double="no"])],
[pmix_cv_cc_wno_long_double="no"])
])
if test "$pmix_cv_cc_wno_long_double" = "yes" ; then
add="$add -Wno-long-double"
fi
# Per above, we know that this flag works with GCC / haven't
# really tested it elsewhere.
if test "$pmix_c_vendor" = "gnu" ; then
add="$add -Werror-implicit-function-declaration "
fi
CFLAGS="$CFLAGS_orig $add"
PMIX_UNIQ(CFLAGS)
AC_MSG_WARN([$add has been added to CFLAGS (--enable-picky)])
unset add
@ -147,12 +148,27 @@ AC_DEFUN([PMIX_SETUP_CC],[
if test "$GCC" = "yes"; then
CFLAGS_orig="$CFLAGS"
# Note: Some versions of clang (at least >= 3.5 -- perhaps
# older versions, too?) will *warn* about -finline-functions,
# but still allow it. This is very annoying, so check for
# that warning, too. The clang warning looks like this:
# clang: warning: optimization flag '-finline-functions' is not supported
# clang: warning: argument unused during compilation: '-finline-functions'
CFLAGS="$CFLAGS_orig -finline-functions"
add=
AC_CACHE_CHECK([if $CC supports -finline-functions],
[pmix_cv_cc_finline_functions],
[AC_TRY_COMPILE([], [],
[pmix_cv_cc_finline_functions="yes"],
[pmix_cv_cc_finline_functions="yes"
if test -s conftest.err ; then
for i in unused 'not supported' ; do
if $GREP -iq "$i" conftest.err; then
pmix_cv_cc_finline_functions="no"
break;
fi
done
fi
],
[pmix_cv_cc_finline_functions="no"])])
if test "$pmix_cv_cc_finline_functions" = "yes" ; then
add=" -finline-functions"
@ -287,7 +303,7 @@ AC_DEFUN([PMIX_SETUP_CC],[
AC_DEFUN([_PMIX_START_SETUP_CC],[
pmix_show_subtitle "C compiler and preprocessor"
# $%@#!@#% AIX!! This has to be called before anything invokes the C
# $%@#!@#% AIX!! This has to be called before anything invokes the C
# compiler.
dnl AC_AIX
])
@ -297,13 +313,15 @@ AC_DEFUN([_PMIX_PROG_CC],[
#
# Check for the compiler
#
PMIX_VAR_SCOPE_PUSH([pmix_cflags_save dummy pmix_cc_arvgv0])
pmix_cflags_save="$CFLAGS"
AC_PROG_CC
BASECC="`basename $CC`"
CFLAGS="$pmix_cflags_save"
AC_DEFINE_UNQUOTED(PMIX_CC, "$CC", [PMIX underlying C compiler])
AC_DEFINE_UNQUOTED(PMIX_CC, "$CC", [PMIx underlying C compiler])
set dummy $CC
pmix_cc_argv0=[$]2
PMIX_WHICH([$pmix_cc_argv0], [PMIX_CC_ABSOLUTE])
AC_SUBST(PMIX_CC_ABSOLUTE)
PMIX_VAR_SCOPE_POP
])

2
opal/mca/pmix/pmix1xx/pmix/config/pmix_setup_hwloc.m4
Просмотреть файл

@ -39,7 +39,7 @@ AC_DEFUN([_PMIX_HWLOC_EMBEDDED_MODE],[
AC_MSG_CHECKING([for hwloc])
AC_MSG_RESULT([assumed available (embedded mode)])
PMIX_HWLOC_HEADER=$with_hwloc_header
PMIX_HWLOC_HEADER="$with_hwloc_header"
PMIX_HWLOC_CPPFLAGS=
PMIX_HWLOC_LIB=
PMIX_HWLOC_LDFLAGS=

7
opal/mca/pmix/pmix1xx/pmix/config/pmix_setup_libevent.m4
Просмотреть файл

@ -39,12 +39,13 @@ AC_DEFUN([_PMIX_LIBEVENT_EMBEDDED_MODE],[
AC_MSG_CHECKING([for libevent])
AC_MSG_RESULT([assumed available (embedded mode)])
PMIX_EVENT_HEADER=$with_libevent_header
PMIX_EVENT2_THREAD_HEADER=$with_libevent_header
PMIX_EVENT_HEADER="$with_libevent_header"
PMIX_EVENT2_THREAD_HEADER="$with_libevent_header"
PMIX_EVENT_CPPFLAGS=
PMIX_EVENT_LIB=
PMIX_EVENT_LDFLAGS=
])
])
AC_DEFUN([_PMIX_LIBEVENT_EXTERNAL],[
PMIX_VAR_SCOPE_PUSH([pmix_event_dir pmix_event_libdir])

47
opal/mca/pmix/pmix1xx/pmix/configure.ac
Просмотреть файл

@ -146,19 +146,6 @@ LT_INIT()
LT_LANG([C])
LT_LANG([C++])
####################################################################
# Setup C compiler
####################################################################
CFLAGS_save="$CFLAGS"
AC_PROG_CC
CFLAGS="$CFLAGS_save"
AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])
AS_IF([test -z "$CC_FOR_BUILD"],[
AC_SUBST([CC_FOR_BUILD], [$CC])
])
############################################################################
# Configuration options
############################################################################
@ -182,6 +169,37 @@ PMIX_SETUP_CORE([])
# Run the AM_CONDITIONALs
PMIX_DO_AM_CONDITIONALS
####################################################################
# Setup C compiler
####################################################################
CFLAGS_save="$CFLAGS"
AC_PROG_CC
CFLAGS="$CFLAGS_save"
AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])
AS_IF([test -z "$CC_FOR_BUILD"],[
AC_SUBST([CC_FOR_BUILD], [$CC])
])
PMIX_SETUP_CC
#
# Delayed the substitution of CFLAGS and CXXFLAGS until now because
# they may have been modified throughout the course of this script.
#
AC_SUBST(CFLAGS)
AC_SUBST(CPPFLAGS)
pmix_show_title "Final compiler flags"
AC_MSG_CHECKING([final CPPFLAGS])
AC_MSG_RESULT([$CPPFLAGS])
AC_MSG_CHECKING([final CFLAGS])
AC_MSG_RESULT([$CFLAGS])
####################################################################
# Version information
####################################################################
@ -197,4 +215,7 @@ AC_SUBST([libpmix_so_version])
AC_CONFIG_FILES(pmix_config_prefix[test/Makefile]
pmix_config_prefix[test/simple/Makefile]
pmix_config_prefix[examples/Makefile])
pmix_show_title "Configuration complete"
AC_OUTPUT

40
opal/mca/pmix/pmix1xx/pmix/examples/client.c
Просмотреть файл

@ -24,6 +24,8 @@
*/
#include <pmix/autogen/config.h>
#define _GNU_SOURCE
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
@ -45,26 +47,26 @@ int main(int argc, char **argv)
/* init us */
if (PMIX_SUCCESS != (rc = PMIx_Init(&myproc))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Init failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Init failed: %d\n", myproc.nspace, myproc.rank, rc);
exit(0);
}
pmix_output(0, "Client ns %s rank %d: Running", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: Running\n", myproc.nspace, myproc.rank);
/* get our universe size */
if (PMIX_SUCCESS != (rc = PMIx_Get(&myproc, PMIX_UNIV_SIZE, NULL, 0, &val))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get universe size failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get universe size failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
nprocs = val->data.uint32;
PMIX_VALUE_RELEASE(val);
pmix_output(0, "Client %s:%d universe size %d", myproc.nspace, myproc.rank, nprocs);
fprintf(stderr, "Client %s:%d universe size %d\n", myproc.nspace, myproc.rank, nprocs);
/* put a few values */
(void)asprintf(&tmp, "%s-%d-internal", myproc.nspace, myproc.rank);
value.type = PMIX_UINT32;
value.data.uint32 = 1234;
if (PMIX_SUCCESS != (rc = PMIx_Store_internal(&myproc, tmp, &value))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Store_internal failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Store_internal failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
@ -72,7 +74,7 @@ int main(int argc, char **argv)
value.type = PMIX_UINT64;
value.data.uint64 = 1234;
if (PMIX_SUCCESS != (rc = PMIx_Put(PMIX_LOCAL, tmp, &value))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Put internal failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Put internal failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
@ -80,12 +82,12 @@ int main(int argc, char **argv)
value.type = PMIX_STRING;
value.data.string = "1234";
if (PMIX_SUCCESS != (rc = PMIx_Put(PMIX_REMOTE, tmp, &value))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Put internal failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Put internal failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
if (PMIX_SUCCESS != (rc = PMIx_Commit())) {
pmix_output(0, "Client ns %s rank %d: PMIx_Commit failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Commit failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
@ -96,7 +98,7 @@ int main(int argc, char **argv)
PMIX_INFO_CREATE(info, 1);
(void)strncpy(info->key, PMIX_COLLECT_DATA, PMIX_MAX_KEYLEN);
if (PMIX_SUCCESS != (rc = PMIx_Fence(&proc, 1, info, 1))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Fence failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Fence failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
PMIX_INFO_FREE(info, 1);
@ -105,49 +107,49 @@ int main(int argc, char **argv)
for (n=0; n < nprocs; n++) {
(void)asprintf(&tmp, "%s-%d-local", myproc.nspace, myproc.rank);
if (PMIX_SUCCESS != (rc = PMIx_Get(&myproc, tmp, NULL, 0, &val))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get %s failed: %d", myproc.nspace, myproc.rank, tmp, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get %s failed: %d\n", myproc.nspace, myproc.rank, tmp, rc);
goto done;
}
if (PMIX_UINT64 != val->type) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get %s returned wrong type: %d", myproc.nspace, myproc.rank, tmp, val->type);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get %s returned wrong type: %d\n", myproc.nspace, myproc.rank, tmp, val->type);
PMIX_VALUE_RELEASE(val);
free(tmp);
goto done;
}
if (1234 != val->data.uint64) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get %s returned wrong value: %d", myproc.nspace, myproc.rank, tmp, (int)val->data.uint64);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get %s returned wrong value: %d\n", myproc.nspace, myproc.rank, tmp, (int)val->data.uint64);
PMIX_VALUE_RELEASE(val);
free(tmp);
goto done;
}
pmix_output(0, "Client ns %s rank %d: PMIx_Get %s returned correct", myproc.nspace, myproc.rank, tmp);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get %s returned correct\n", myproc.nspace, myproc.rank, tmp);
PMIX_VALUE_RELEASE(val);
free(tmp);
(void)asprintf(&tmp, "%s-%d-remote", myproc.nspace, myproc.rank);
if (PMIX_SUCCESS != (rc = PMIx_Get(&myproc, tmp, NULL, 0, &val))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get %s failed: %d", myproc.nspace, myproc.rank, tmp, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get %s failed: %d\n", myproc.nspace, myproc.rank, tmp, rc);
goto done;
}
if (PMIX_STRING != val->type) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get %s returned wrong type: %d", myproc.nspace, myproc.rank, tmp, val->type);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get %s returned wrong type: %d\n", myproc.nspace, myproc.rank, tmp, val->type);
PMIX_VALUE_RELEASE(val);
free(tmp);
goto done;
}
if (0 != strcmp(val->data.string, "1234")) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get %s returned wrong value: %s", myproc.nspace, myproc.rank, tmp, val->data.string);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get %s returned wrong value: %s\n", myproc.nspace, myproc.rank, tmp, val->data.string);
PMIX_VALUE_RELEASE(val);
free(tmp);
goto done;
}
pmix_output(0, "Client ns %s rank %d: PMIx_Get %s returned correct", myproc.nspace, myproc.rank, tmp);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get %s returned correct\n", myproc.nspace, myproc.rank, tmp);
PMIX_VALUE_RELEASE(val);
free(tmp);
}
done:
/* finalize us */
pmix_output(0, "Client ns %s rank %d: Finalizing", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: Finalizing\n", myproc.nspace, myproc.rank);
if (PMIX_SUCCESS != (rc = PMIx_Finalize())) {
fprintf(stderr, "Client ns %s rank %d:PMIx_Finalize failed: %d\n", myproc.nspace, myproc.rank, rc);
} else {

45
opal/mca/pmix/pmix1xx/pmix/examples/dmodex.c
Просмотреть файл

@ -25,7 +25,10 @@
#include <pmix/autogen/config.h>
#include <stdbool.h>
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
@ -47,7 +50,7 @@ static void opcbfunc(pmix_status_t status, void *cbdata)
{
bool *active = (bool*)cbdata;
pmix_output(0, "%s:%d completed fence_nb", myproc.nspace, myproc.rank);
fprintf(stderr, "%s:%d completed fence_nb\n", myproc.nspace, myproc.rank);
*active = false;
}
@ -59,29 +62,29 @@ static void valcbfunc(pmix_status_t status,
if (PMIX_SUCCESS == status) {
if (NULL != strstr(key, "local")) {
if (PMIX_UINT64 != val->type) {
pmix_output(0, "%s:%d: PMIx_Get_nb Key %s returned wrong type: %d", myproc.nspace, myproc.rank, key, val->type);
fprintf(stderr, "%s:%d: PMIx_Get_nb Key %s returned wrong type: %d\n", myproc.nspace, myproc.rank, key, val->type);
goto done;
}
if (1234 != val->data.uint64) {
pmix_output(0, "%s:%d: PMIx_Get_nb Key %s returned wrong value: %d", myproc.nspace, myproc.rank, key, (int)val->data.uint64);
fprintf(stderr, "%s:%d: PMIx_Get_nb Key %s returned wrong value: %d\n", myproc.nspace, myproc.rank, key, (int)val->data.uint64);
goto done;
}
} else if (NULL != strstr(key, "remote")) {
if (PMIX_STRING != val->type) {
pmix_output(0, "%s:%d: PMIx_Get_nb Key %s returned wrong type: %d", myproc.nspace, myproc.rank, key, val->type);
fprintf(stderr, "%s:%d: PMIx_Get_nb Key %s returned wrong type: %d\n", myproc.nspace, myproc.rank, key, val->type);
goto done;
}
if (0 != strcmp(val->data.string, "1234")) {
pmix_output(0, "%s:%d: PMIx_Get_nb Key %s returned wrong value: %s", myproc.nspace, myproc.rank, key, val->data.string);
fprintf(stderr, "%s:%d: PMIx_Get_nb Key %s returned wrong value: %s\n", myproc.nspace, myproc.rank, key, val->data.string);
goto done;
}
} else {
pmix_output(0, "%s:%d PMIx_Get_nb returned wrong key: %s", myproc.nspace, myproc.rank, key);
fprintf(stderr, "%s:%d PMIx_Get_nb returned wrong key: %s\n", myproc.nspace, myproc.rank, key);
goto done;
}
pmix_output(0, "%s:%d PMIx_Get_nb Key %s returned correctly", myproc.nspace, myproc.rank, key);
fprintf(stderr, "%s:%d PMIx_Get_nb Key %s returned correctly\n", myproc.nspace, myproc.rank, key);
} else {
pmix_output(0, "%s:%d PMIx_Get_nb Key %s failed", myproc.nspace, myproc.rank, key);
fprintf(stderr, "%s:%d PMIx_Get_nb Key %s failed\n", myproc.nspace, myproc.rank, key);
}
done:
free(key);
@ -100,26 +103,26 @@ int main(int argc, char **argv)
/* init us */
if (PMIX_SUCCESS != (rc = PMIx_Init(&myproc))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Init failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Init failed: %d\n", myproc.nspace, myproc.rank, rc);
exit(0);
}
pmix_output(0, "Client ns %s rank %d: Running", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: Running\n", myproc.nspace, myproc.rank);
/* get our universe size */
if (PMIX_SUCCESS != (rc = PMIx_Get(&myproc, PMIX_UNIV_SIZE, NULL, 0, &val))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get universe size failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get universe size failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
nprocs = val->data.uint32;
PMIX_VALUE_RELEASE(val);
pmix_output(0, "Client %s:%d universe size %d", myproc.nspace, myproc.rank, nprocs);
fprintf(stderr, "Client %s:%d universe size %d\n", myproc.nspace, myproc.rank, nprocs);
/* put a few values */
(void)asprintf(&tmp, "%s-%d-internal", myproc.nspace, myproc.rank);
value.type = PMIX_UINT32;
value.data.uint32 = 1234;
if (PMIX_SUCCESS != (rc = PMIx_Store_internal(&myproc, tmp, &value))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Store_internal failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Store_internal failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
@ -127,7 +130,7 @@ int main(int argc, char **argv)
value.type = PMIX_UINT64;
value.data.uint64 = 1234;
if (PMIX_SUCCESS != (rc = PMIx_Put(PMIX_LOCAL, tmp, &value))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Put internal failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Put internal failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
@ -135,7 +138,7 @@ int main(int argc, char **argv)
value.type = PMIX_STRING;
value.data.string = "1234";
if (PMIX_SUCCESS != (rc = PMIx_Put(PMIX_REMOTE, tmp, &value))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Put internal failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Put internal failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
@ -147,7 +150,7 @@ int main(int argc, char **argv)
/* commit the data to the server */
if (PMIX_SUCCESS != (rc = PMIx_Commit())) {
pmix_output(0, "Client ns %s rank %d: PMIx_Commit failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Commit failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
@ -157,7 +160,7 @@ int main(int argc, char **argv)
proc.rank = PMIX_RANK_WILDCARD;
active = true;
if (PMIX_SUCCESS != (rc = PMIx_Fence_nb(&proc, 1, NULL, 0, opcbfunc, &active))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Fence failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Fence failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
@ -169,7 +172,7 @@ int main(int argc, char **argv)
proc.rank = n;
if (PMIX_SUCCESS != (rc = PMIx_Get_nb(&proc, tmp,
NULL, 0, valcbfunc, tmp))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get %s failed: %d", myproc.nspace, n, tmp, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get %s failed: %d\n", myproc.nspace, n, tmp, rc);
goto done;
}
++num_gets;
@ -177,7 +180,7 @@ int main(int argc, char **argv)
(void)strncpy(proc.nspace, tmp, PMIX_MAX_NSLEN);
if (PMIX_SUCCESS != (rc = PMIx_Get_nb(&proc, tmp,
NULL, 0, valcbfunc, tmp))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get %s failed: %d", myproc.nspace, n, tmp, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get %s failed: %d\n", myproc.nspace, n, tmp, rc);
goto done;
}
++num_gets;
@ -198,13 +201,13 @@ int main(int argc, char **argv)
(void)strncpy(proc.nspace, myproc.nspace, PMIX_MAX_NSLEN);
proc.rank = PMIX_RANK_WILDCARD;
if (PMIX_SUCCESS != (rc = PMIx_Fence(&proc, 1, NULL, 0))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Fence failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Fence failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
done:
/* finalize us */
pmix_output(0, "Client ns %s rank %d: Finalizing", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: Finalizing", myproc.nspace, myproc.rank);
if (PMIX_SUCCESS != (rc = PMIx_Finalize())) {
fprintf(stderr, "Client ns %s rank %d:PMIx_Finalize failed: %d\n", myproc.nspace, myproc.rank, rc);
} else {

84
opal/mca/pmix/pmix1xx/pmix/examples/dynamic.c
Просмотреть файл

@ -25,6 +25,8 @@
#include <pmix/autogen/config.h>
#include <stdbool.h>
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
@ -32,6 +34,7 @@
#include <pmix.h>
static pmix_proc_t myproc;
int main(int argc, char **argv)
@ -47,43 +50,48 @@ int main(int argc, char **argv)
pmix_proc_t *peers;
size_t npeers, ntmp=0;
char *nodelist;
gethostname(hostname, 1024);
/* init us */
if (PMIX_SUCCESS != (rc = PMIx_Init(&myproc))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Init failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Init failed: %d\n", myproc.nspace, myproc.rank, rc);
exit(0);
}
pmix_output(0, "Client ns %s rank %d: Running", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: Running\n", myproc.nspace, myproc.rank);
/* get our universe size */
if (PMIX_SUCCESS != (rc = PMIx_Get(&myproc, PMIX_UNIV_SIZE, NULL, 0, &val))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get universe size failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get universe size failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
nprocs = val->data.uint32;
PMIX_VALUE_RELEASE(val);
pmix_output(0, "Client %s:%d universe size %d", myproc.nspace, myproc.rank, nprocs);
fprintf(stderr, "Client %s:%d universe size %d\n", myproc.nspace, myproc.rank, nprocs);
/* call fence to sync */
PMIX_PROC_CONSTRUCT(&proc);
(void)strncpy(proc.nspace, myproc.nspace, PMIX_MAX_NSLEN);
proc.rank = PMIX_RANK_WILDCARD;
if (PMIX_SUCCESS != (rc = PMIx_Fence(&proc, 1, NULL, 0))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Fence failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Fence failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
/* rank=0 calls spawn */
if (0 == myproc.rank) {
PMIX_APP_CREATE(app, 1);
app->cmd = strdup("gumby");
app->maxprocs = 2;
pmix_argv_append(&app->argc, &app->argv, "gumby");
pmix_argv_append(&app->argc, &app->argv, "-n");
pmix_argv_append(&app->argc, &app->argv, "2");
pmix_setenv("PMIX_ENV_VALUE", "3", true, &app->env);
app->argc = 3;
app->argv = (char**)malloc(4 * sizeof(char*));
app->argv[0] = strdup("gumby");
app->argv[1] = strdup("-n");
app->argv[2] = strdup("2");
app->argv[3] = NULL;
app->env = (char**)malloc(2 * sizeof(char*));
app->env[0] = strdup("PMIX_ENV_VALUE=3");
app->env[1] = NULL;
PMIX_INFO_CREATE(app->info, 2);
(void)strncpy(app->info[0].key, "DARTH", PMIX_MAX_KEYLEN);
app->info[0].value.type = PMIX_INT8;
@ -92,19 +100,19 @@ int main(int argc, char **argv)
app->info[1].value.type = PMIX_DOUBLE;
app->info[1].value.data.dval = 12.34;
pmix_output(0, "Client ns %s rank %d: calling PMIx_Spawn", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: calling PMIx_Spawn\n", myproc.nspace, myproc.rank);
if (PMIX_SUCCESS != (rc = PMIx_Spawn(NULL, 0, app, 1, nsp2))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Spawn failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Spawn failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
PMIX_APP_FREE(app, 1);
/* check to see if we got the expected info back */
if (0 != strncmp(nsp2, "DYNSPACE", PMIX_MAX_NSLEN)) {
pmix_output(0, "Client ns %s rank %d: PMIx_Spawn returned incorrect nspace: %s", myproc.nspace, myproc.rank, nsp2);
fprintf(stderr, "Client ns %s rank %d: PMIx_Spawn returned incorrect nspace: %s\n", myproc.nspace, myproc.rank, nsp2);
goto done;
} else {
pmix_output(0, "Client ns %s rank %d: PMIx_Spawn succeeded returning nspace: %s", myproc.nspace, myproc.rank, nsp2);
fprintf(stderr, "Client ns %s rank %d: PMIx_Spawn succeeded returning nspace: %s\n", myproc.nspace, myproc.rank, nsp2);
}
/* get their universe size */
val = NULL;
@ -112,76 +120,76 @@ int main(int argc, char **argv)
proc.rank = PMIX_RANK_WILDCARD;
if (PMIX_SUCCESS != (rc = PMIx_Get(&proc, PMIX_UNIV_SIZE, NULL, 0, &val)) ||
NULL == val) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get universe size failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get universe size failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
ntmp = val->data.uint32;
PMIX_VALUE_RELEASE(val);
pmix_output(0, "Client %s:%d universe %s size %d", myproc.nspace, myproc.rank, nsp2, (int)ntmp);
fprintf(stderr, "Client %s:%d universe %s size %d\n", myproc.nspace, myproc.rank, nsp2, (int)ntmp);
}
/* just cycle the connect/disconnect functions */
(void)strncpy(proc.nspace, myproc.nspace, PMIX_MAX_NSLEN);
proc.rank = PMIX_RANK_WILDCARD;
if (PMIX_SUCCESS != (rc = PMIx_Connect(&proc, 1, NULL, 0))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Connect failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Connect failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
pmix_output(0, "Client ns %s rank %d: PMIx_Connect succeeded", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: PMIx_Connect succeeded\n", myproc.nspace, myproc.rank);
if (PMIX_SUCCESS != (rc = PMIx_Disconnect(&proc, 1, NULL, 0))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Disonnect failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Disonnect failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
pmix_output(0, "Client ns %s rank %d: PMIx_Disconnect succeeded", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: PMIx_Disconnect succeeded\n", myproc.nspace, myproc.rank);
/* finally, test the resolve functions */
if (0 == myproc.rank) {
if (PMIX_SUCCESS != (rc = PMIx_Resolve_peers(hostname, NULL, &peers, &npeers))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Resolve_peers failed for nspace %s: %d", myproc.nspace, myproc.rank, nsp2, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Resolve_peers failed for nspace %s: %d\n", myproc.nspace, myproc.rank, nsp2, rc);
goto done;
}
if ((nprocs+ntmp) != npeers) {
pmix_output(0, "Client ns %s rank %d: PMIx_Resolve_peers returned incorrect npeers: %d vs %d", myproc.nspace, myproc.rank, (int)(nprocs+ntmp), (int)npeers);
fprintf(stderr, "Client ns %s rank %d: PMIx_Resolve_peers returned incorrect npeers: %d vs %d\n", myproc.nspace, myproc.rank, (int)(nprocs+ntmp), (int)npeers);
goto done;
}
pmix_output(0, "Client ns %s rank %d: PMIx_Resolve_peers returned %d npeers", myproc.nspace, myproc.rank, (int)npeers);
fprintf(stderr, "Client ns %s rank %d: PMIx_Resolve_peers returned %d npeers\n", myproc.nspace, myproc.rank, (int)npeers);
if (PMIX_SUCCESS != (rc = PMIx_Resolve_nodes(nsp2, &nodelist))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Resolve_nodes failed for nspace %s: %d", myproc.nspace, myproc.rank, nsp2, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Resolve_nodes failed for nspace %s: %d\n", myproc.nspace, myproc.rank, nsp2, rc);
goto done;
}
pmix_output(0, "Client ns %s rank %d: PMIx_Resolve_nodes %s", myproc.nspace, myproc.rank, nodelist);
fprintf(stderr, "Client ns %s rank %d: PMIx_Resolve_nodes %s", myproc.nspace, myproc.rank, nodelist);
} else {
if (PMIX_SUCCESS != (rc = PMIx_Resolve_peers(hostname, myproc.nspace, &peers, &npeers))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Resolve_peers failed for nspace %s: %d", myproc.nspace, myproc.rank, myproc.nspace, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Resolve_peers failed for nspace %s: %d\n", myproc.nspace, myproc.rank, myproc.nspace, rc);
goto done;
}
if (nprocs != npeers) {
pmix_output(0, "Client ns %s rank %d: PMIx_Resolve_peers returned incorrect npeers: %d vs %d", myproc.nspace, myproc.rank, nprocs, (int)npeers);
fprintf(stderr, "Client ns %s rank %d: PMIx_Resolve_peers returned incorrect npeers: %d vs %d\n", myproc.nspace, myproc.rank, nprocs, (int)npeers);
goto done;
}
pmix_output(0, "Client ns %s rank %d: PMIx_Resolve_peers returned %d npeers", myproc.nspace, myproc.rank, (int)npeers);
fprintf(stderr, "Client ns %s rank %d: PMIx_Resolve_peers returned %d npeers\n", myproc.nspace, myproc.rank, (int)npeers);
if (PMIX_SUCCESS != (rc = PMIx_Resolve_nodes(myproc.nspace, &nodelist))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Resolve_nodes failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Resolve_nodes failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
pmix_output(0, "Client ns %s rank %d: PMIx_Resolve_nodes %s", myproc.nspace, myproc.rank, nodelist);
fprintf(stderr, "Client ns %s rank %d: PMIx_Resolve_nodes %s\n", myproc.nspace, myproc.rank, nodelist);
}
PMIX_PROC_FREE(peers, npeers);
free(nodelist);
done:
/* call fence to sync */
PMIX_PROC_CONSTRUCT(&proc);
(void)strncpy(proc.nspace, myproc.nspace, PMIX_MAX_NSLEN);
proc.rank = PMIX_RANK_WILDCARD;
if (PMIX_SUCCESS != (rc = PMIx_Fence(&proc, 1, NULL, 0))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Fence failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Fence failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
/* finalize us */
pmix_output(0, "Client ns %s rank %d: Finalizing", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: Finalizing\n", myproc.nspace, myproc.rank);
if (PMIX_SUCCESS != (rc = PMIx_Finalize())) {
fprintf(stderr, "Client ns %s rank %d:PMIx_Finalize failed: %d\n", myproc.nspace, myproc.rank, rc);
} else {

26
opal/mca/pmix/pmix1xx/pmix/examples/fault.c
Просмотреть файл

@ -39,7 +39,7 @@ static void notification_fn(pmix_status_t status,
pmix_proc_t procs[], size_t nprocs,
pmix_info_t info[], size_t ninfo)
{
pmix_output(0, "Client %s:%d NOTIFIED with status %d", myproc.nspace, myproc.rank, status);
fprintf(stderr, "Client %s:%d NOTIFIED with status %d\n", myproc.nspace, myproc.rank, status);
completed = true;
}
@ -50,41 +50,41 @@ int main(int argc, char **argv)
pmix_value_t *val = &value;
pmix_proc_t proc;
uint32_t nprocs;
/* init us */
if (PMIX_SUCCESS != (rc = PMIx_Init(&myproc))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Init failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Init failed: %d\n", myproc.nspace, myproc.rank, rc);
exit(0);
}
pmix_output(0, "Client ns %s rank %d: Running", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: Running\n", myproc.nspace, myproc.rank);
/* get our universe size */
if (PMIX_SUCCESS != (rc = PMIx_Get(&myproc, PMIX_UNIV_SIZE, NULL, 0, &val))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get universe size failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get universe size failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
nprocs = val->data.uint32;
PMIX_VALUE_RELEASE(val);
pmix_output(0, "Client %s:%d universe size %d", myproc.nspace, myproc.rank, nprocs);
fprintf(stderr, "Client %s:%d universe size %d\n", myproc.nspace, myproc.rank, nprocs);
completed = false;
/* register our errhandler */
PMIx_Register_errhandler(NULL, 0, notification_fn);
/* call fence to sync */
PMIX_PROC_CONSTRUCT(&proc);
(void)strncpy(proc.nspace, myproc.nspace, PMIX_MAX_NSLEN);
proc.rank = PMIX_RANK_WILDCARD;
if (PMIX_SUCCESS != (rc = PMIx_Fence(&proc, 1, NULL, 0))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Fence failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Fence failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
/* rank=0 calls abort */
if (0 == myproc.rank) {
PMIx_Abort(PMIX_ERR_OUT_OF_RESOURCE, "Eat rocks",
&proc, 1);
pmix_output(0, "Client ns %s rank %d: Abort called", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: Abort called\n", myproc.nspace, myproc.rank);
}
/* everyone simply waits */
while (!completed) {
@ -96,9 +96,9 @@ int main(int argc, char **argv)
done:
/* finalize us */
pmix_output(0, "Client ns %s rank %d: Finalizing", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: Finalizing\n", myproc.nspace, myproc.rank);
PMIx_Deregister_errhandler();
if (PMIX_SUCCESS != (rc = PMIx_Finalize())) {
fprintf(stderr, "Client ns %s rank %d:PMIx_Finalize failed: %d\n", myproc.nspace, myproc.rank, rc);
} else {

50
opal/mca/pmix/pmix1xx/pmix/examples/pub.c
Просмотреть файл

@ -45,29 +45,29 @@ int main(int argc, char **argv)
/* init us */
if (PMIX_SUCCESS != (rc = PMIx_Init(&myproc))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Init failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Init failed: %d\n", myproc.nspace, myproc.rank, rc);
exit(0);
}
pmix_output(0, "Client ns %s rank %d: Running", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: Running\n", myproc.nspace, myproc.rank);
/* get our universe size */
if (PMIX_SUCCESS != (rc = PMIx_Get(&myproc, PMIX_UNIV_SIZE, NULL, 0, &val))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Get universe size failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Get universe size failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
nprocs = val->data.uint32;
PMIX_VALUE_RELEASE(val);
pmix_output(0, "Client %s:%d universe size %d", myproc.nspace, myproc.rank, nprocs);
fprintf(stderr, "Client %s:%d universe size %d\n", myproc.nspace, myproc.rank, nprocs);
/* call fence to ensure the data is received */
PMIX_PROC_CONSTRUCT(&proc);
(void)strncpy(proc.nspace, myproc.nspace, PMIX_MAX_NSLEN);
proc.rank = PMIX_RANK_WILDCARD;
if (PMIX_SUCCESS != (rc = PMIx_Fence(&proc, 1, NULL, 0))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Fence failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Fence failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
/* publish something */
if (0 == myproc.rank) {
PMIX_INFO_CREATE(info, 2);
@ -78,7 +78,7 @@ int main(int argc, char **argv)
info[1].value.type = PMIX_SIZE;
info[1].value.data.size = 123456;
if (PMIX_SUCCESS != (rc = PMIx_Publish(PMIX_NAMESPACE, PMIX_PERSIST_APP, info, 2))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Publish failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Publish failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
PMIX_INFO_FREE(info, 2);
@ -87,7 +87,7 @@ int main(int argc, char **argv)
/* call fence again so all procs know the data
* has been published */
if (PMIX_SUCCESS != (rc = PMIx_Fence(&proc, 1, NULL, 0))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Fence failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Fence failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
@ -96,61 +96,65 @@ int main(int argc, char **argv)
PMIX_PDATA_CREATE(pdata, 1);
(void)strncpy(pdata[0].key, "FOOBAR", PMIX_MAX_KEYLEN);
if (PMIX_SUCCESS != (rc = PMIx_Lookup(PMIX_NAMESPACE, NULL, 0, pdata, 1))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Lookup failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Lookup failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
/* check the return for value and source */
if (0 != strncmp(myproc.nspace, pdata[0].proc.nspace, PMIX_MAX_NSLEN)) {
pmix_output(0, "Client ns %s rank %d: PMIx_Lookup returned wrong nspace: %s",
fprintf(stderr, "Client ns %s rank %d: PMIx_Lookup returned wrong nspace: %s\n",
myproc.nspace, myproc.rank, pdata[0].proc.nspace);
goto done;
}
if (0 != pdata[0].proc.rank) {
pmix_output(0, "Client ns %s rank %d: PMIx_Lookup returned wrong rank: %d",
fprintf(stderr, "Client ns %s rank %d: PMIx_Lookup returned wrong rank: %d\n",
myproc.nspace, myproc.rank, pdata[0].proc.rank);
goto done;
}
if (PMIX_UINT8 != pdata[0].value.type) {
pmix_output(0, "Client ns %s rank %d: PMIx_Lookup returned wrong type: %d",
fprintf(stderr, "Client ns %s rank %d: PMIx_Lookup returned wrong type: %d\n",
myproc.nspace, myproc.rank, pdata[0].value.type);
goto done;
}
if (1 != pdata[0].value.data.uint8) {
pmix_output(0, "Client ns %s rank %d: PMIx_Lookup returned wrong value: %d",
fprintf(stderr, "Client ns %s rank %d: PMIx_Lookup returned wrong value: %d\n",
myproc.nspace, myproc.rank, (int)pdata[0].value.data.uint8);
goto done;
}
PMIX_PDATA_FREE(pdata, 1);
pmix_output(0, "PUBLISH-LOOKUP SUCCEEDED");
fprintf(stderr, "PUBLISH-LOOKUP SUCCEEDED\n");
}
/* call fence again so rank 0 waits before leaving */
if (PMIX_SUCCESS != (rc = PMIx_Fence(&proc, 1, NULL, 0))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Fence failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Fence failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
if (0 == myproc.rank) {
char **keys = NULL;
pmix_argv_append_nosize(&keys, "FOOBAR");
pmix_argv_append_nosize(&keys, "PANDA");
char **keys;
keys = (char**)malloc(3 * sizeof(char*));
keys[0] = "FOOBAR";
keys[1] = "PANDA";
keys[2] = NULL;
if (PMIX_SUCCESS != (rc = PMIx_Unpublish(PMIX_NAMESPACE, keys))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Unpublish failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Unpublish failed: %d\n", myproc.nspace, myproc.rank, rc);
free(keys);
goto done;
}
pmix_output(0, "UNPUBLISH SUCCEEDED");
free(keys);
fprintf(stderr, "UNPUBLISH SUCCEEDED\n");
}
/* call fence again so everyone waits for rank 0 before leaving */
if (PMIX_SUCCESS != (rc = PMIx_Fence(&proc, 1, NULL, 0))) {
pmix_output(0, "Client ns %s rank %d: PMIx_Fence failed: %d", myproc.nspace, myproc.rank, rc);
fprintf(stderr, "Client ns %s rank %d: PMIx_Fence failed: %d\n", myproc.nspace, myproc.rank, rc);
goto done;
}
done:
/* finalize us */
pmix_output(0, "Client ns %s rank %d: Finalizing", myproc.nspace, myproc.rank);
fprintf(stderr, "Client ns %s rank %d: Finalizing\n", myproc.nspace, myproc.rank);
if (PMIX_SUCCESS != (rc = PMIx_Finalize())) {
fprintf(stderr, "Client ns %s rank %d:PMIx_Finalize failed: %d\n", myproc.nspace, myproc.rank, rc);
} else {

1
opal/mca/pmix/pmix1xx/pmix/examples/server.c
Просмотреть файл

@ -300,7 +300,6 @@ int main(int argc, char **argv)
static void set_namespace(int nprocs, char *ranks, char *nspace,
pmix_op_cbfunc_t cbfunc, myxfer_t *x)
{
size_t ninfo = 6;
char *regex, *ppn;
char hostname[1024];

1
opal/mca/pmix/pmix1xx/pmix/include/pmix/pmix_common.h.in
Просмотреть файл

@ -119,7 +119,6 @@ BEGIN_C_DECLS
#define PMIX_NODE_RANK "pmix.nrank" // (uint16_t) rank on this node spanning all jobs
#define PMIX_LOCALLDR "pmix.lldr" // (uint64_t) opal_identifier of lowest rank on this node within this job
#define PMIX_APPLDR "pmix.aldr" // (uint32_t) lowest rank in this app within this job
#define PMIX_LOCALITY "pmix.loc" // (uint16_t) relative locality of two procs
/* proc location-related info */
/* For PMIX_HOSTNAME, three use-cases exist for PMIx_Get:

7
opal/mca/pmix/pmix1xx/pmix/src/buffer_ops/open_close.c
Просмотреть файл

@ -409,6 +409,9 @@ void pmix_value_load(pmix_value_t *v, void *data,
switch(type) {
case PMIX_UNDEF:
break;
case PMIX_BOOL:
memcpy(&(v->data.flag), data, 1);
break;
case PMIX_BYTE:
memcpy(&(v->data.byte), data, 1);
break;
@ -498,6 +501,10 @@ int pmix_value_unload(pmix_value_t *kv, void **data,
case PMIX_UNDEF:
rc = PMIX_ERR_UNKNOWN_DATA_TYPE;
break;
case PMIX_BOOL:
memcpy(*data, &(kv->data.flag), 1);
*sz = 1;
break;
case PMIX_BYTE:
memcpy(*data, &(kv->data.byte), 1);
*sz = 1;

2
opal/mca/pmix/pmix1xx/pmix/src/buffer_ops/unpack.c
Просмотреть файл

@ -146,7 +146,7 @@ int pmix_bfrop_unpack_buffer(pmix_buffer_t *buffer, void *dst, int32_t *num_vals
int pmix_bfrop_unpack_bool(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
int32_t i, k;
int32_t i;
uint8_t *src;
bool *dst;

3
opal/mca/pmix/pmix1xx/pmix/src/class/pmix_object.h
Просмотреть файл

@ -12,8 +12,6 @@
* All rights reserved.
* Copyright (c) 2007 Cisco Systems, Inc. All rights reserved.
* Copyright (c) 2013-2015 Intel, Inc. All rights reserved
* Copyright (c) 2015 Research Organization for Information Science
* and Technology (RIST). All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
@ -129,7 +127,6 @@
#include "include/pmix/rename.h"
BEGIN_C_DECLS
#if PMIX_ENABLE_DEBUG

1
opal/mca/pmix/pmix1xx/pmix/src/client/pmix_client.c
Просмотреть файл

@ -856,7 +856,6 @@ void pmix_client_process_nspace_blob(const char *nspace, pmix_buffer_t *bptr)
pmix_nspace_t *nsptr, *nsptr2;
pmix_nrec_t *nrec, *nr2;
char **procs;
pmix_value_t *val;
/* cycle across our known nspaces */
nsptr = NULL;

10
opal/mca/pmix/pmix1xx/pmix/src/server/pmix_server.c
Просмотреть файл

@ -542,7 +542,6 @@ pmix_status_t PMIx_server_register_nspace(const char nspace[], int nlocalprocs,
pmix_op_cbfunc_t cbfunc, void *cbdata)
{
pmix_setup_caddy_t *cd;
size_t i;
cd = PMIX_NEW(pmix_setup_caddy_t);
(void)strncpy(cd->proc.nspace, nspace, PMIX_MAX_NSLEN);
@ -552,7 +551,7 @@ pmix_status_t PMIx_server_register_nspace(const char nspace[], int nlocalprocs,
/* copy across the info array, if given */
if (0 < ninfo) {
cd->ninfo = ninfo;
cd->info = info;
cd->info = info;
}
/* we have to push this into our event library to avoid
@ -569,7 +568,7 @@ static void _execute_collective(int sd, short args, void *cbdata)
pmix_server_trkr_t *trk = tcd->trk;
char *data = NULL;
size_t sz = 0;
pmix_buffer_t bucket, pbkt, xfer;
pmix_buffer_t bucket, xfer;
pmix_rank_info_t *info;
pmix_value_t *val;
@ -653,8 +652,6 @@ static void _register_client(int sd, short args, void *cbdata)
pmix_nspace_t *nptr, *tmp;
pmix_server_trkr_t *trk;
pmix_trkr_caddy_t *tcd;
bool found;
pmix_dmdx_local_t *lcd, *lcdnext;
pmix_output_verbose(2, pmix_globals.debug_output,
"pmix:server _register_client for nspace %s rank %d",
@ -781,7 +778,7 @@ static void _dmodex_req(int sd, short args, void *cbdata)
pmix_setup_caddy_t *cd = (pmix_setup_caddy_t*)cbdata;
pmix_rank_info_t *info, *iptr;
pmix_nspace_t *nptr, *ns;
pmix_buffer_t pbkt, xfer;
pmix_buffer_t pbkt;
pmix_value_t *val;
char *data = NULL;
size_t sz = 0;
@ -1567,7 +1564,6 @@ static void _mdxcbfunc(int sd, short argc, void *cbdata)
pmix_buffer_t xfer, *bptr, *databuf, *bpscope, *reply;
pmix_nspace_t *nptr, *ns;
pmix_server_caddy_t *cd;
pmix_kval_t *kp;
char *nspace;
int rank, rc;
int32_t cnt = 1;

2
opal/mca/pmix/pmix1xx/pmix/src/server/pmix_server_listener.c
Просмотреть файл

@ -362,7 +362,7 @@ static void connection_handler(int sd, short flags, void* cbdata)
pmix_status_t pmix_server_authenticate(int sd, int *out_rank, pmix_peer_t **peer,
pmix_buffer_t **reply)
{
char *msg, *nspace, *version, *cred, *ptr;
char *msg, *nspace, *version, *cred;
int rc, rank;
pmix_usock_hdr_t hdr;
pmix_nspace_t *nptr, *tmp;

22
opal/mca/pmix/pmix1xx/pmix/src/server/pmix_server_ops.c
Просмотреть файл

@ -80,8 +80,8 @@ static void relfn(void *cbdata)
free(data);
}
pmix_status_t _satisfy_local_req(pmix_nspace_t *nptr, pmix_rank_info_t *info,
pmix_modex_cbfunc_t cbfunc, void *cbdata)
static pmix_status_t _satisfy_local_req(pmix_nspace_t *nptr, pmix_rank_info_t *info,
pmix_modex_cbfunc_t cbfunc, void *cbdata)
{
int rc;
pmix_buffer_t pbkt, xfer;
@ -114,8 +114,8 @@ pmix_status_t _satisfy_local_req(pmix_nspace_t *nptr, pmix_rank_info_t *info,
return PMIX_ERR_NOT_FOUND;
}
pmix_status_t _satisfy_remote_req(pmix_nspace_t *nptr, int rank,
pmix_modex_cbfunc_t cbfunc, void *cbdata)
static pmix_status_t _satisfy_remote_req(pmix_nspace_t *nptr, int rank,
pmix_modex_cbfunc_t cbfunc, void *cbdata)
{
int rc;
pmix_buffer_t pbkt, xfer;
@ -152,10 +152,6 @@ pmix_status_t pmix_pending_request(pmix_nspace_t *nptr, int rank,
{
pmix_dmdx_local_t *lcd = NULL, *cd;
pmix_rank_info_t *iptr, *rkinfo;
pmix_buffer_t pbkt, xfer;
pmix_value_t *val;
char *data;
size_t sz;
int rc;
/* 1. Try to satisfy the request right now */
@ -292,7 +288,7 @@ pmix_status_t pmix_pending_resolve(pmix_nspace_t *nptr, int rank, pmix_dmdx_loca
if( NULL == lcd ){
PMIX_LIST_FOREACH(cd, &pmix_server_globals.local_reqs, pmix_dmdx_local_t) {
if (0 != strncmp(nptr->nspace, cd->proc.nspace, PMIX_MAX_NSLEN) ||
rank != cd->proc.rank) {
rank != cd->proc.rank) {
continue;
}
lcd = cd;
@ -510,10 +506,8 @@ static pmix_server_trkr_t* get_tracker(pmix_proc_t *procs,
size_t nprocs, pmix_cmd_t type)
{
pmix_server_trkr_t *trk;
pmix_rank_info_t *iptr, *info;
size_t i;
bool match, all_def;
pmix_nspace_t *nptr, *ns;
bool match;
pmix_output_verbose(5, pmix_globals.debug_output,
"get_tracker called with %d procs", (int)nprocs);
@ -578,7 +572,7 @@ static pmix_server_trkr_t* new_tracker(pmix_proc_t *procs,
pmix_server_trkr_t *trk;
pmix_rank_info_t *iptr, *info;
size_t i;
bool match, all_def;
bool all_def;
pmix_nspace_t *nptr, *ns;
pmix_output_verbose(5, pmix_globals.debug_output,
@ -878,7 +872,7 @@ static void _process_dmdx_reply(int fd, short args, void *cbdata)
PMIX_ERROR_LOG(PMIX_ERR_NOT_FOUND);
caddy->status = PMIX_ERR_NOT_FOUND;
PMIX_RELEASE(caddy);
return;
goto cleanup;
}
kp = PMIX_NEW(pmix_kval_t);

2
opal/mca/pmix/pmix1xx/pmix/src/util/timings.c
Просмотреть файл

@ -33,7 +33,7 @@
#endif
#if PMIX_COMPILE_TIMING
#if PMIX_ENABLE_TIMING
#include "src/class/pmix_pointer_array.h"
#include "src/class/pmix_list.h"

6
opal/mca/pmix/pmix1xx/pmix/test/pmix_client.c
Просмотреть файл

@ -41,8 +41,6 @@
int main(int argc, char **argv)
{
char nspace[PMIX_MAX_NSLEN+1];
int rank;
int rc;
pmix_value_t value;
pmix_value_t *val = &value;
@ -62,7 +60,7 @@ int main(int argc, char **argv)
/* init us */
if (PMIX_SUCCESS != (rc = PMIx_Init(&myproc))) {
TEST_ERROR(("Client ns %s rank %d: PMIx_Init failed: %d", params.nspace, rank, rc));
TEST_ERROR(("Client ns %s rank %d: PMIx_Init failed: %d", params.nspace, params.rank, rc));
FREE_TEST_PARAMS(params);
exit(0);
}
@ -73,7 +71,7 @@ int main(int argc, char **argv)
exit(0);
}
if ( NULL != params.prefix && -1 != params.ns_id) {
TEST_SET_FILE(params.prefix, params.ns_id, rank);
TEST_SET_FILE(params.prefix, params.ns_id, params.rank);
}
TEST_VERBOSE((" Client ns %s rank %d: PMIx_Init success", myproc.nspace, myproc.rank));

10
opal/mca/pmix/pmix1xx/pmix/test/simple/simptest.c
Просмотреть файл

@ -70,6 +70,8 @@ static pmix_status_t connect_fn(const pmix_proc_t procs[], size_t nprocs,
static pmix_status_t disconnect_fn(const pmix_proc_t procs[], size_t nprocs,
const pmix_info_t info[], size_t ninfo,
pmix_op_cbfunc_t cbfunc, void *cbdata);
static pmix_status_t register_event_fn(const pmix_info_t info[], size_t ninfo,
pmix_op_cbfunc_t cbfunc, void *cbdata);
static pmix_status_t listener_fn(int listening_sd,
pmix_connection_cbfunc_t cbfunc);
@ -85,7 +87,8 @@ static pmix_server_module_t mymodule = {
spawn_fn,
connect_fn,
disconnect_fn,
NULL
register_event_fn,
listener_fn
};
typedef struct {
@ -601,6 +604,11 @@ static int disconnect_fn(const pmix_proc_t procs[], size_t nprocs,
return PMIX_SUCCESS;
}
static pmix_status_t register_event_fn(const pmix_info_t info[], size_t ninfo,
pmix_op_cbfunc_t cbfunc, void *cbdata)
{
return PMIX_SUCCESS;
}
static int listener_fn(int listening_sd,
pmix_connection_cbfunc_t cbfunc)

2
opal/mca/pmix/pmix1xx/pmix/test/test_common.c
Просмотреть файл

@ -205,7 +205,7 @@ void parse_cmd(int argc, char **argv, test_params *params)
char *rankno = getenv("SLURM_LOCALID");
if( NULL != ranklist && NULL != rankno ){
char **argv = pmix_argv_split(ranklist, ',');
int i, count = pmix_argv_count(argv);
int count = pmix_argv_count(argv);
int rankidx = strtoul(rankno, NULL, 10);
if( rankidx >= count ){
fprintf(stderr, "It feels like we are running under SLURM:\n\t"