From 871bedb103282f5bfb7b12847bc4ea7a09eca4e6 Mon Sep 17 00:00:00 2001 From: Ralph Castain Date: Mon, 22 Aug 2016 12:54:24 -0700 Subject: [PATCH 1/2] Add missing "const" qualifiers --- ompi/mca/coll/sync/coll_sync.h | 20 +++++++++---------- ompi/mca/coll/sync/coll_sync_exscan.c | 8 ++++---- ompi/mca/coll/sync/coll_sync_gather.c | 12 +++++------ ompi/mca/coll/sync/coll_sync_gatherv.c | 12 +++++------ ompi/mca/coll/sync/coll_sync_reduce.c | 10 +++++----- ompi/mca/coll/sync/coll_sync_reduce_scatter.c | 12 +++++------ ompi/mca/coll/sync/coll_sync_scan.c | 8 ++++---- ompi/mca/coll/sync/coll_sync_scatter.c | 8 ++++---- ompi/mca/coll/sync/coll_sync_scatterv.c | 10 +++++----- 9 files changed, 50 insertions(+), 50 deletions(-) diff --git a/ompi/mca/coll/sync/coll_sync.h b/ompi/mca/coll/sync/coll_sync.h index 5e62a135d08..36b5455a833 100644 --- a/ompi/mca/coll/sync/coll_sync.h +++ b/ompi/mca/coll/sync/coll_sync.h @@ -55,13 +55,13 @@ int mca_coll_sync_bcast(void *buff, int count, struct ompi_communicator_t *comm, mca_coll_base_module_t *module); -int mca_coll_sync_exscan(void *sbuf, void *rbuf, int count, +int mca_coll_sync_exscan(const void *sbuf, void *rbuf, int count, struct ompi_datatype_t *dtype, struct ompi_op_t *op, struct ompi_communicator_t *comm, mca_coll_base_module_t *module); -int mca_coll_sync_gather(void *sbuf, int scount, +int mca_coll_sync_gather(const void *sbuf, int scount, struct ompi_datatype_t *sdtype, void *rbuf, int rcount, struct ompi_datatype_t *rdtype, @@ -69,35 +69,35 @@ int mca_coll_sync_gather(void *sbuf, int scount, struct ompi_communicator_t *comm, mca_coll_base_module_t *module); -int mca_coll_sync_gatherv(void *sbuf, int scount, +int mca_coll_sync_gatherv(const void *sbuf, int scount, struct ompi_datatype_t *sdtype, - void *rbuf, int *rcounts, int *disps, + void *rbuf, const int *rcounts, const int *disps, struct ompi_datatype_t *rdtype, int root, struct ompi_communicator_t *comm, mca_coll_base_module_t *module); -int mca_coll_sync_reduce(void *sbuf, void *rbuf, int count, +int mca_coll_sync_reduce(const void *sbuf, void *rbuf, int count, struct ompi_datatype_t *dtype, struct ompi_op_t *op, int root, struct ompi_communicator_t *comm, mca_coll_base_module_t *module); -int mca_coll_sync_reduce_scatter(void *sbuf, void *rbuf, - int *rcounts, +int mca_coll_sync_reduce_scatter(const void *sbuf, void *rbuf, + const int *rcounts, struct ompi_datatype_t *dtype, struct ompi_op_t *op, struct ompi_communicator_t *comm, mca_coll_base_module_t *module); -int mca_coll_sync_scan(void *sbuf, void *rbuf, int count, +int mca_coll_sync_scan(const void *sbuf, void *rbuf, int count, struct ompi_datatype_t *dtype, struct ompi_op_t *op, struct ompi_communicator_t *comm, mca_coll_base_module_t *module); -int mca_coll_sync_scatter(void *sbuf, int scount, +int mca_coll_sync_scatter(const void *sbuf, int scount, struct ompi_datatype_t *sdtype, void *rbuf, int rcount, struct ompi_datatype_t *rdtype, @@ -105,7 +105,7 @@ int mca_coll_sync_scatter(void *sbuf, int scount, struct ompi_communicator_t *comm, mca_coll_base_module_t *module); -int mca_coll_sync_scatterv(void *sbuf, int *scounts, int *disps, +int mca_coll_sync_scatterv(const void *sbuf, const int *scounts, const int *disps, struct ompi_datatype_t *sdtype, void *rbuf, int rcount, struct ompi_datatype_t *rdtype, diff --git a/ompi/mca/coll/sync/coll_sync_exscan.c b/ompi/mca/coll/sync/coll_sync_exscan.c index 259847b6075..3759c8ea9b4 100644 --- a/ompi/mca/coll/sync/coll_sync_exscan.c +++ b/ompi/mca/coll/sync/coll_sync_exscan.c @@ -5,15 +5,15 @@ * 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, + * 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) 2009 Cisco Systems, Inc. All rights reserved. * $COPYRIGHT$ - * + * * Additional copyrights may follow - * + * * $HEADER$ */ @@ -29,7 +29,7 @@ * Accepts: - same arguments as MPI_Exscan() * Returns: - MPI_SUCCESS or error code */ -int mca_coll_sync_exscan(void *sbuf, void *rbuf, int count, +int mca_coll_sync_exscan(const void *sbuf, void *rbuf, int count, struct ompi_datatype_t *dtype, struct ompi_op_t *op, struct ompi_communicator_t *comm, diff --git a/ompi/mca/coll/sync/coll_sync_gather.c b/ompi/mca/coll/sync/coll_sync_gather.c index 9715d80f624..2a49d93a934 100644 --- a/ompi/mca/coll/sync/coll_sync_gather.c +++ b/ompi/mca/coll/sync/coll_sync_gather.c @@ -5,15 +5,15 @@ * 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) 2009 Cisco Systems, Inc. All rights reserved. * $COPYRIGHT$ - * + * * Additional copyrights may follow - * + * * $HEADER$ */ @@ -29,7 +29,7 @@ * Accepts: - same arguments as MPI_Gather() * Returns: - MPI_SUCCESS or error code */ -int mca_coll_sync_gather(void *sbuf, int scount, +int mca_coll_sync_gather(const void *sbuf, int scount, struct ompi_datatype_t *sdtype, void *rbuf, int rcount, struct ompi_datatype_t *rdtype, @@ -39,11 +39,11 @@ int mca_coll_sync_gather(void *sbuf, int scount, mca_coll_sync_module_t *s = (mca_coll_sync_module_t*) module; if (s->in_operation) { - return s->c_coll.coll_gather(sbuf, scount, sdtype, + return s->c_coll.coll_gather(sbuf, scount, sdtype, rbuf, rcount, rdtype, root, comm, s->c_coll.coll_gather_module); } else { - COLL_SYNC(s, s->c_coll.coll_gather(sbuf, scount, sdtype, + COLL_SYNC(s, s->c_coll.coll_gather(sbuf, scount, sdtype, rbuf, rcount, rdtype, root, comm, s->c_coll.coll_gather_module)); } diff --git a/ompi/mca/coll/sync/coll_sync_gatherv.c b/ompi/mca/coll/sync/coll_sync_gatherv.c index 982c1cce1f6..9075cc3218d 100644 --- a/ompi/mca/coll/sync/coll_sync_gatherv.c +++ b/ompi/mca/coll/sync/coll_sync_gatherv.c @@ -5,15 +5,15 @@ * 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) 2009 Cisco Systems, Inc. All rights reserved. * $COPYRIGHT$ - * + * * Additional copyrights may follow - * + * * $HEADER$ */ @@ -29,9 +29,9 @@ * Accepts: - same arguments as MPI_Gatherv() * Returns: - MPI_SUCCESS or error code */ -int mca_coll_sync_gatherv(void *sbuf, int scount, +int mca_coll_sync_gatherv(const void *sbuf, int scount, struct ompi_datatype_t *sdtype, - void *rbuf, int *rcounts, int *disps, + void *rbuf, const int *rcounts, const int *disps, struct ompi_datatype_t *rdtype, int root, struct ompi_communicator_t *comm, mca_coll_base_module_t *module) @@ -44,7 +44,7 @@ int mca_coll_sync_gatherv(void *sbuf, int scount, s->c_coll.coll_gatherv_module); } else { COLL_SYNC(s, s->c_coll.coll_gatherv(sbuf, scount, sdtype, - rbuf, rcounts, disps, rdtype, + rbuf, rcounts, disps, rdtype, root, comm, s->c_coll.coll_gatherv_module)); } diff --git a/ompi/mca/coll/sync/coll_sync_reduce.c b/ompi/mca/coll/sync/coll_sync_reduce.c index 3b49e72262c..eec178c3055 100644 --- a/ompi/mca/coll/sync/coll_sync_reduce.c +++ b/ompi/mca/coll/sync/coll_sync_reduce.c @@ -5,14 +5,14 @@ * 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, + * 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$ - * + * * Additional copyrights may follow - * + * * $HEADER$ */ @@ -28,7 +28,7 @@ * Accepts: - same as MPI_Reduce() * Returns: - MPI_SUCCESS or error code */ -int mca_coll_sync_reduce(void *sbuf, void *rbuf, int count, +int mca_coll_sync_reduce(const void *sbuf, void *rbuf, int count, struct ompi_datatype_t *dtype, struct ompi_op_t *op, int root, struct ompi_communicator_t *comm, @@ -40,7 +40,7 @@ int mca_coll_sync_reduce(void *sbuf, void *rbuf, int count, return s->c_coll.coll_reduce(sbuf, rbuf, count, dtype, op, root, comm, s->c_coll.coll_reduce_module); } else { - COLL_SYNC(s, s->c_coll.coll_reduce(sbuf, rbuf, count, dtype, + COLL_SYNC(s, s->c_coll.coll_reduce(sbuf, rbuf, count, dtype, op, root, comm, s->c_coll.coll_reduce_module)); } diff --git a/ompi/mca/coll/sync/coll_sync_reduce_scatter.c b/ompi/mca/coll/sync/coll_sync_reduce_scatter.c index b45031e2d0d..3fd650561fc 100644 --- a/ompi/mca/coll/sync/coll_sync_reduce_scatter.c +++ b/ompi/mca/coll/sync/coll_sync_reduce_scatter.c @@ -5,16 +5,16 @@ * 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, + * 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) 2008 Sun Microsystems, Inc. All rights reserved. * Copyright (c) 2009 Cisco Systems, Inc. All rights reserved. * $COPYRIGHT$ - * + * * Additional copyrights may follow - * + * * $HEADER$ */ @@ -30,7 +30,7 @@ * Accepts: - same as MPI_Reduce_scatter() * Returns: - MPI_SUCCESS or error code */ -int mca_coll_sync_reduce_scatter(void *sbuf, void *rbuf, int *rcounts, +int mca_coll_sync_reduce_scatter(const void *sbuf, void *rbuf, const int *rcounts, struct ompi_datatype_t *dtype, struct ompi_op_t *op, struct ompi_communicator_t *comm, @@ -39,11 +39,11 @@ int mca_coll_sync_reduce_scatter(void *sbuf, void *rbuf, int *rcounts, mca_coll_sync_module_t *s = (mca_coll_sync_module_t*) module; if (s->in_operation) { - return s->c_coll.coll_reduce_scatter(sbuf, rbuf, rcounts, + return s->c_coll.coll_reduce_scatter(sbuf, rbuf, rcounts, dtype, op, comm, s->c_coll.coll_reduce_scatter_module); } else { - COLL_SYNC(s, s->c_coll.coll_reduce_scatter(sbuf, rbuf, rcounts, + COLL_SYNC(s, s->c_coll.coll_reduce_scatter(sbuf, rbuf, rcounts, dtype, op, comm, s->c_coll.coll_reduce_scatter_module)); } diff --git a/ompi/mca/coll/sync/coll_sync_scan.c b/ompi/mca/coll/sync/coll_sync_scan.c index 2cbf40e4d15..9608bc7e83c 100644 --- a/ompi/mca/coll/sync/coll_sync_scan.c +++ b/ompi/mca/coll/sync/coll_sync_scan.c @@ -5,14 +5,14 @@ * 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, + * 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$ - * + * * Additional copyrights may follow - * + * * $HEADER$ */ @@ -28,7 +28,7 @@ * Accepts: - same arguments as MPI_Scan() * Returns: - MPI_SUCCESS or error code */ -int mca_coll_sync_scan(void *sbuf, void *rbuf, int count, +int mca_coll_sync_scan(const void *sbuf, void *rbuf, int count, struct ompi_datatype_t *dtype, struct ompi_op_t *op, struct ompi_communicator_t *comm, diff --git a/ompi/mca/coll/sync/coll_sync_scatter.c b/ompi/mca/coll/sync/coll_sync_scatter.c index e21c4370b63..3c093d86749 100644 --- a/ompi/mca/coll/sync/coll_sync_scatter.c +++ b/ompi/mca/coll/sync/coll_sync_scatter.c @@ -5,15 +5,15 @@ * 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) 2009 Cisco Systems, Inc. All rights reserved. * $COPYRIGHT$ - * + * * Additional copyrights may follow - * + * * $HEADER$ */ @@ -29,7 +29,7 @@ * Accepts: - same arguments as MPI_Scatter() * Returns: - MPI_SUCCESS or error code */ -int mca_coll_sync_scatter(void *sbuf, int scount, +int mca_coll_sync_scatter(const void *sbuf, int scount, struct ompi_datatype_t *sdtype, void *rbuf, int rcount, struct ompi_datatype_t *rdtype, diff --git a/ompi/mca/coll/sync/coll_sync_scatterv.c b/ompi/mca/coll/sync/coll_sync_scatterv.c index 17cd5d79c41..ae6d8bb5bac 100644 --- a/ompi/mca/coll/sync/coll_sync_scatterv.c +++ b/ompi/mca/coll/sync/coll_sync_scatterv.c @@ -5,15 +5,15 @@ * 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) 2009 Cisco Systems, Inc. All rights reserved. * $COPYRIGHT$ - * + * * Additional copyrights may follow - * + * * $HEADER$ */ @@ -29,8 +29,8 @@ * Accepts: - same arguments as MPI_Scatterv() * Returns: - MPI_SUCCESS or error code */ -int mca_coll_sync_scatterv(void *sbuf, int *scounts, - int *disps, struct ompi_datatype_t *sdtype, +int mca_coll_sync_scatterv(const void *sbuf, const int *scounts, + const int *disps, struct ompi_datatype_t *sdtype, void *rbuf, int rcount, struct ompi_datatype_t *rdtype, int root, struct ompi_communicator_t *comm, From 639dbdb7ea44f63161acec63b707555fb0612d0e Mon Sep 17 00:00:00 2001 From: Ralph Castain Date: Mon, 22 Aug 2016 13:28:55 -0700 Subject: [PATCH 2/2] For maintainability, fold the external PMIx 2.x integration into the internal PMIx 2.x library component. This ensures that we always stay in sync with the two as that is becoming a problem. --- config/opal_check_pmi.m4 | 26 + opal/mca/pmix/ext114/configure.m4 | 40 +- opal/mca/pmix/ext114/pmix_ext.c | 488 +++--- opal/mca/pmix/ext114/pmix_ext.h | 1 - opal/mca/pmix/ext20/Makefile.am | 46 - opal/mca/pmix/ext20/configure.m4 | 88 -- opal/mca/pmix/ext20/pmix_ext20.c | 1390 ----------------- opal/mca/pmix/ext20/pmix_ext20.h | 323 ---- opal/mca/pmix/ext20/pmix_ext20_client.c | 1283 --------------- opal/mca/pmix/ext20/pmix_ext20_component.c | 131 -- opal/mca/pmix/ext20/pmix_ext20_server_north.c | 1003 ------------ opal/mca/pmix/ext20/pmix_ext20_server_south.c | 518 ------ opal/mca/pmix/pmix2x/Makefile.am | 6 +- opal/mca/pmix/pmix2x/configure.m4 | 46 +- 14 files changed, 324 insertions(+), 5065 deletions(-) delete mode 100644 opal/mca/pmix/ext20/Makefile.am delete mode 100644 opal/mca/pmix/ext20/configure.m4 delete mode 100644 opal/mca/pmix/ext20/pmix_ext20.c delete mode 100644 opal/mca/pmix/ext20/pmix_ext20.h delete mode 100644 opal/mca/pmix/ext20/pmix_ext20_client.c delete mode 100644 opal/mca/pmix/ext20/pmix_ext20_component.c delete mode 100644 opal/mca/pmix/ext20/pmix_ext20_server_north.c delete mode 100644 opal/mca/pmix/ext20/pmix_ext20_server_south.c diff --git a/config/opal_check_pmi.m4 b/config/opal_check_pmi.m4 index 37b73104486..a4f007f3a49 100644 --- a/config/opal_check_pmi.m4 +++ b/config/opal_check_pmi.m4 @@ -227,6 +227,8 @@ AC_DEFUN([OPAL_CHECK_PMI],[ AC_DEFUN([OPAL_CHECK_PMIX],[ + OPAL_VAR_SCOPE_PUSH([opal_external_pmix_save_CPPFLAGS opal_external_pmix_save_LDFLAGS opal_external_pmix_save_LIBS]) + AC_ARG_WITH([pmix], [AC_HELP_STRING([--with-pmix(=DIR)], [Build PMIx support. DIR can take one of three values: "internal", "external", or a valid directory name. "internal" (or no DIR value) forces Open MPI to use its internal copy of PMIx. "external" forces Open MPI to use an external installation of PMIx. Supplying a valid directory name also forces Open MPI to use an external installation of PMIx, and adds DIR/include, DIR/lib, and DIR/lib64 to the search path for headers and libraries. Note that Open MPI does not support --without-pmix.])]) @@ -241,14 +243,38 @@ AC_DEFUN([OPAL_CHECK_PMIX],[ AS_IF([test -z "$with_pmix" || test "$with_pmix" = "yes" || test "$with_pmix" = "internal"], [AC_MSG_RESULT([no]) opal_external_pmix_happy=no], + [AC_MSG_RESULT([yes]) # check for external pmix lib */ AS_IF([test "$with_pmix" = "external"], [pmix_ext_install_dir=/usr], [pmix_ext_install_dir=$with_pmix]) + # Make sure we have the headers and libs in the correct location OPAL_CHECK_WITHDIR([external-pmix], [$pmix_ext_install_dir/include], [pmix.h]) OPAL_CHECK_WITHDIR([external-libpmix], [$pmix_ext_install_dir/lib], [libpmix.*]) + + # check the version + opal_external_pmix_save_CPPFLAGS=$CPPFLAGS + opal_external_pmix_save_LDFLAGS=$LDFLAGS + opal_external_pmix_save_LIBS=$LIBS + + LDFLAGS="-L$pmix_ext_install_dir/lib $LDFLAGS" + AC_SEARCH_LIBS([PMIx_Register_event_handler], [pmix], + [opal_external_pmix_version=2], + [opal_external_pmix_version=1]) + + AC_MSG_CHECKING([PMIx version]) + AC_MSG_RESULT([$opal_external_pmix_version]) + + CPPFLAGS=$opal_external_pmix_save_CPPFLAGS + LDFLAGS=$opal_external_pmix_save_LDFLAGS + LIBS=$opal_external_pmix_save_LIBS + + opal_external_pmix_CPPFLAGS="-I$pmix_ext_install_dir/include" + opal_external_pmix_LDFLAGS=-L$pmix_ext_install_dir/lib + opal_external_pmix_LIBS=-lpmix opal_external_pmix_happy=yes]) + OPAL_VAR_SCOPE_POP ]) diff --git a/opal/mca/pmix/ext114/configure.m4 b/opal/mca/pmix/ext114/configure.m4 index 7b66af18a71..337bdc868b4 100644 --- a/opal/mca/pmix/ext114/configure.m4 +++ b/opal/mca/pmix/ext114/configure.m4 @@ -43,31 +43,29 @@ AC_DEFUN([MCA_opal_pmix_ext114_CONFIG],[ AC_MSG_WARN([LIBRARY THIS LIBRARY MUST POINT TO THE SAME ONE USED ]) AC_MSG_WARN([TO BUILD PMIX OR ELSE UNPREDICTABLE BEHAVIOR MAY RESULT]) AC_MSG_ERROR([PLEASE CORRECT THE CONFIGURE COMMAND LINE AND REBUILD])]) - external_WRAPPER_EXTRA_CPPFLAGS='-I${includedir}/openmpi/$opal_pmix_external_basedir/pmix -I${includedir}/openmpi/$opal_pmix_external_basedir/pmix/include' - # check for the 1.1.4 version by looking for a function - # which was later removed - AC_MSG_CHECKING([if external component is version 1.1.4]) - OPAL_CHECK_PACKAGE([opal_pmix_ext114], - [pmix.h], - [pmix], - [PMIx_Register_errhandler], - [-lpmix], - [$pmix_ext_install_dir], - [$pmix_ext_install_dir/lib], - [AC_MSG_RESULT([yes]) - opal_pmix_external_114_happy=yes], - [AC_MSG_RESULT([no]) - opal_pmix_external_114_happy=no]) - AC_SUBST(opal_pmix_ext114_CPPFLAGS) - AC_SUBST(opal_pmix_ext114_LDFLAGS) - AC_SUBST(opal_pmix_ext114_LIBS) + # check for the 1.1.4 version + AC_MSG_CHECKING([if external component is version 1.x]) + AS_IF([test "$opal_external_pmix_version" = "1"], + [AC_MSG_RESULT([yes]) + opal_pmix_external_114_happy=yes], + [AC_MSG_RESULT([no]) + opal_pmix_external_114_happy=no]) AS_IF([test "$opal_pmix_external_114_happy" = "yes"], [$1 - # need to set the wrapper flags for static builds - pmix_ext114_WRAPPER_EXTRA_LDFLAGS="$opal_pmix_ext114_LDFLAGS" - pmix_ext114_WRAPPER_EXTRA_LIBS="$opal_pmix_ext114_LIBS"], + # need to set the wrapper flags for static builds + pmix_ext114_WRAPPER_EXTRA_LDFLAGS=$opal_external_pmix_LDFLAGS + pmix_ext114_WRAPPER_EXTRA_LIBS=$opal_external_pmix_LIBS], [$2])], [$2]) + + opal_pmix_ext114_CPPFLAGS=$opal_external_pmix_CPPFLAGS + opal_pmix_ext114_LDFLAGS=$opal_external_pmix_LDFLAGS + opal_pmix_ext114_LIBS=$opal_external_pmix_LIBS + + AC_SUBST([opal_pmix_ext114_CPPFLAGS]) + AC_SUBST([opal_pmix_ext114_LDFLAGS]) + AC_SUBST([opal_pmix_ext114_LIBS]) + ])dnl diff --git a/opal/mca/pmix/ext114/pmix_ext.c b/opal/mca/pmix/ext114/pmix_ext.c index fe1398f0a5a..c2c50901fb9 100644 --- a/opal/mca/pmix/ext114/pmix_ext.c +++ b/opal/mca/pmix/ext114/pmix_ext.c @@ -101,9 +101,9 @@ static const char *pmix1_get_nspace(opal_jobid_t jobid) opal_pmix1_jobid_trkr_t *jptr; OPAL_LIST_FOREACH(jptr, &mca_pmix_ext114_component.jobids, opal_pmix1_jobid_trkr_t) { - if (jptr->jobid == jobid) { - return jptr->nspace; - } + if (jptr->jobid == jobid) { + return jptr->nspace; + } } return NULL; } @@ -114,9 +114,9 @@ static void pmix1_register_jobid(opal_jobid_t jobid, const char *nspace) /* if we don't already have it, add this to our jobid tracker */ OPAL_LIST_FOREACH(jptr, &mca_pmix_ext114_component.jobids, opal_pmix1_jobid_trkr_t) { - if (jptr->jobid == jobid) { - return; - } + if (jptr->jobid == jobid) { + return; + } } jptr = OBJ_NEW(opal_pmix1_jobid_trkr_t); (void)strncpy(jptr->nspace, nspace, PMIX_MAX_NSLEN); @@ -128,61 +128,61 @@ pmix_status_t pmix1_convert_opalrc(int rc) { switch (rc) { case OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER: - return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER; + return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER; case OPAL_ERR_COMM_FAILURE: - return PMIX_ERR_COMM_FAILURE; + return PMIX_ERR_COMM_FAILURE; case OPAL_ERR_NOT_IMPLEMENTED: - return PMIX_ERR_NOT_IMPLEMENTED; + return PMIX_ERR_NOT_IMPLEMENTED; case OPAL_ERR_NOT_SUPPORTED: - return PMIX_ERR_NOT_SUPPORTED; + return PMIX_ERR_NOT_SUPPORTED; case OPAL_ERR_NOT_FOUND: - return PMIX_ERR_NOT_FOUND; + return PMIX_ERR_NOT_FOUND; case OPAL_ERR_SERVER_NOT_AVAIL: - return PMIX_ERR_SERVER_NOT_AVAIL; + return PMIX_ERR_SERVER_NOT_AVAIL; case OPAL_ERR_BAD_PARAM: - return PMIX_ERR_BAD_PARAM; + return PMIX_ERR_BAD_PARAM; case OPAL_ERR_OUT_OF_RESOURCE: - return PMIX_ERR_NOMEM; + return PMIX_ERR_NOMEM; case OPAL_ERR_DATA_VALUE_NOT_FOUND: - return PMIX_ERR_DATA_VALUE_NOT_FOUND; + return PMIX_ERR_DATA_VALUE_NOT_FOUND; case OPAL_ERR_IN_ERRNO: - return PMIX_ERR_IN_ERRNO; + return PMIX_ERR_IN_ERRNO; case OPAL_ERR_UNREACH: - return PMIX_ERR_UNREACH; + return PMIX_ERR_UNREACH; case OPAL_ERR_TIMEOUT: - return PMIX_ERR_TIMEOUT; + return PMIX_ERR_TIMEOUT; case OPAL_ERR_PERM: - return PMIX_ERR_NO_PERMISSIONS; + return PMIX_ERR_NO_PERMISSIONS; case OPAL_ERR_PACK_MISMATCH: - return PMIX_ERR_PACK_MISMATCH; + return PMIX_ERR_PACK_MISMATCH; case OPAL_ERR_PACK_FAILURE: - return PMIX_ERR_PACK_FAILURE; + return PMIX_ERR_PACK_FAILURE; case OPAL_ERR_UNPACK_FAILURE: - return PMIX_ERR_UNPACK_FAILURE; + return PMIX_ERR_UNPACK_FAILURE; case OPAL_ERR_UNPACK_INADEQUATE_SPACE: - return PMIX_ERR_UNPACK_INADEQUATE_SPACE; + return PMIX_ERR_UNPACK_INADEQUATE_SPACE; case OPAL_ERR_TYPE_MISMATCH: - return PMIX_ERR_TYPE_MISMATCH; + return PMIX_ERR_TYPE_MISMATCH; case OPAL_ERR_PROC_ENTRY_NOT_FOUND: - return PMIX_ERR_PROC_ENTRY_NOT_FOUND; + return PMIX_ERR_PROC_ENTRY_NOT_FOUND; case OPAL_ERR_UNKNOWN_DATA_TYPE: - return PMIX_ERR_UNKNOWN_DATA_TYPE; + return PMIX_ERR_UNKNOWN_DATA_TYPE; case OPAL_ERR_WOULD_BLOCK: - return PMIX_ERR_WOULD_BLOCK; + return PMIX_ERR_WOULD_BLOCK; case OPAL_EXISTS: - return PMIX_EXISTS; + return PMIX_EXISTS; case OPAL_ERR_SILENT: - return PMIX_ERR_SILENT; + return PMIX_ERR_SILENT; case OPAL_ERROR: - return PMIX_ERROR; + return PMIX_ERROR; case OPAL_SUCCESS: - return PMIX_SUCCESS; + return PMIX_SUCCESS; default: - return PMIX_ERROR; + return PMIX_ERROR; } } @@ -190,17 +190,17 @@ int pmix1_convert_rc(pmix_status_t rc) { switch (rc) { case PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER: - return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER; + return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER; case PMIX_ERR_COMM_FAILURE: - return OPAL_ERR_COMM_FAILURE; + return OPAL_ERR_COMM_FAILURE; case PMIX_ERR_NOT_IMPLEMENTED: - return OPAL_ERR_NOT_IMPLEMENTED; + return OPAL_ERR_NOT_IMPLEMENTED; case PMIX_ERR_NOT_SUPPORTED: - return OPAL_ERR_NOT_SUPPORTED; + return OPAL_ERR_NOT_SUPPORTED; case PMIX_ERR_NOT_FOUND: - return OPAL_ERR_NOT_FOUND; + return OPAL_ERR_NOT_FOUND; case PMIX_ERR_SERVER_NOT_AVAIL: - return OPAL_ERR_SERVER_NOT_AVAIL; + return OPAL_ERR_SERVER_NOT_AVAIL; case PMIX_ERR_INVALID_NAMESPACE: case PMIX_ERR_INVALID_SIZE: @@ -214,276 +214,276 @@ int pmix1_convert_rc(pmix_status_t rc) case PMIX_ERR_INVALID_KEY_LENGTH: case PMIX_ERR_INVALID_KEY: case PMIX_ERR_INVALID_ARG: - return OPAL_ERR_BAD_PARAM; + return OPAL_ERR_BAD_PARAM; case PMIX_ERR_NOMEM: - return OPAL_ERR_OUT_OF_RESOURCE; + return OPAL_ERR_OUT_OF_RESOURCE; case PMIX_ERR_INIT: - return OPAL_ERROR; + return OPAL_ERROR; case PMIX_ERR_DATA_VALUE_NOT_FOUND: - return OPAL_ERR_DATA_VALUE_NOT_FOUND; + return OPAL_ERR_DATA_VALUE_NOT_FOUND; case PMIX_ERR_OUT_OF_RESOURCE: - return OPAL_ERR_OUT_OF_RESOURCE; + return OPAL_ERR_OUT_OF_RESOURCE; case PMIX_ERR_RESOURCE_BUSY: - return OPAL_ERR_TEMP_OUT_OF_RESOURCE; + return OPAL_ERR_TEMP_OUT_OF_RESOURCE; case PMIX_ERR_BAD_PARAM: - return OPAL_ERR_BAD_PARAM; + return OPAL_ERR_BAD_PARAM; case PMIX_ERR_IN_ERRNO: - return OPAL_ERR_IN_ERRNO; + return OPAL_ERR_IN_ERRNO; case PMIX_ERR_UNREACH: - return OPAL_ERR_UNREACH; + return OPAL_ERR_UNREACH; case PMIX_ERR_TIMEOUT: - return OPAL_ERR_TIMEOUT; + return OPAL_ERR_TIMEOUT; case PMIX_ERR_NO_PERMISSIONS: - return OPAL_ERR_PERM; + return OPAL_ERR_PERM; case PMIX_ERR_PACK_MISMATCH: - return OPAL_ERR_PACK_MISMATCH; + return OPAL_ERR_PACK_MISMATCH; case PMIX_ERR_PACK_FAILURE: - return OPAL_ERR_PACK_FAILURE; + return OPAL_ERR_PACK_FAILURE; case PMIX_ERR_UNPACK_FAILURE: - return OPAL_ERR_UNPACK_FAILURE; + return OPAL_ERR_UNPACK_FAILURE; case PMIX_ERR_UNPACK_INADEQUATE_SPACE: - return OPAL_ERR_UNPACK_INADEQUATE_SPACE; + return OPAL_ERR_UNPACK_INADEQUATE_SPACE; case PMIX_ERR_TYPE_MISMATCH: - return OPAL_ERR_TYPE_MISMATCH; + return OPAL_ERR_TYPE_MISMATCH; case PMIX_ERR_PROC_ENTRY_NOT_FOUND: - return OPAL_ERR_PROC_ENTRY_NOT_FOUND; + return OPAL_ERR_PROC_ENTRY_NOT_FOUND; case PMIX_ERR_UNKNOWN_DATA_TYPE: - return OPAL_ERR_UNKNOWN_DATA_TYPE; + return OPAL_ERR_UNKNOWN_DATA_TYPE; case PMIX_ERR_WOULD_BLOCK: - return OPAL_ERR_WOULD_BLOCK; + return OPAL_ERR_WOULD_BLOCK; case PMIX_ERR_READY_FOR_HANDSHAKE: case PMIX_ERR_HANDSHAKE_FAILED: case PMIX_ERR_INVALID_CRED: - return OPAL_ERR_COMM_FAILURE; + return OPAL_ERR_COMM_FAILURE; case PMIX_EXISTS: - return OPAL_EXISTS; + return OPAL_EXISTS; case PMIX_ERR_SILENT: - return OPAL_ERR_SILENT; + return OPAL_ERR_SILENT; case PMIX_ERROR: - return OPAL_ERROR; + return OPAL_ERROR; case PMIX_SUCCESS: - return OPAL_SUCCESS; + return OPAL_SUCCESS; default: - return OPAL_ERROR; + return OPAL_ERROR; } } pmix_scope_t pmix1_convert_opalscope(opal_pmix_scope_t scope) { switch(scope) { case OPAL_PMIX_LOCAL: - return PMIX_LOCAL; + return PMIX_LOCAL; case OPAL_PMIX_REMOTE: - return PMIX_REMOTE; + return PMIX_REMOTE; case OPAL_PMIX_GLOBAL: - return PMIX_GLOBAL; + return PMIX_GLOBAL; default: - return PMIX_SCOPE_UNDEF; + return PMIX_SCOPE_UNDEF; } } void pmix1_value_load(pmix_value_t *v, - opal_value_t *kv) + opal_value_t *kv) { switch(kv->type) { - case OPAL_UNDEF: - v->type = PMIX_UNDEF; - opal_output(0, "TYPE WAS UNDEF"); - break; - case OPAL_BOOL: - v->type = PMIX_BOOL; - memcpy(&(v->data.flag), &kv->data.flag, 1); - break; - case OPAL_BYTE: - v->type = PMIX_BYTE; - memcpy(&(v->data.byte), &kv->data.byte, 1); - break; - case OPAL_STRING: - v->type = PMIX_STRING; - if (NULL != kv->data.string) { - v->data.string = strdup(kv->data.string); - } else { - v->data.string = NULL; - } - break; - case OPAL_SIZE: - v->type = PMIX_SIZE; - v->data.size = (size_t)kv->data.size; - break; - case OPAL_PID: - v->type = PMIX_PID; - memcpy(&(v->data.pid), &kv->data.pid, sizeof(pid_t)); - break; - case OPAL_INT: - v->type = PMIX_INT; - memcpy(&(v->data.integer), &kv->data.integer, sizeof(int)); - break; - case OPAL_INT8: - v->type = PMIX_INT8; - memcpy(&(v->data.int8), &kv->data.int8, 1); - break; - case OPAL_INT16: - v->type = PMIX_INT16; - memcpy(&(v->data.int16), &kv->data.int16, 2); - break; - case OPAL_INT32: - v->type = PMIX_INT32; - memcpy(&(v->data.int32), &kv->data.int32, 4); - break; - case OPAL_INT64: - v->type = PMIX_INT64; - memcpy(&(v->data.int64), &kv->data.int64, 8); - break; - case OPAL_UINT: - v->type = PMIX_UINT; - memcpy(&(v->data.uint), &kv->data.uint, sizeof(int)); - break; - case OPAL_UINT8: - v->type = PMIX_UINT8; - memcpy(&(v->data.uint8), &kv->data.uint8, 1); - break; - case OPAL_UINT16: - v->type = PMIX_UINT16; - memcpy(&(v->data.uint16), &kv->data.uint16, 2); - break; - case OPAL_UINT32: - v->type = PMIX_UINT32; - memcpy(&(v->data.uint32), &kv->data.uint32, 4); - break; - case OPAL_UINT64: - v->type = PMIX_UINT64; - memcpy(&(v->data.uint64), &kv->data.uint64, 8); - break; - case OPAL_FLOAT: - v->type = PMIX_FLOAT; - memcpy(&(v->data.fval), &kv->data.fval, sizeof(float)); - break; - case OPAL_DOUBLE: - v->type = PMIX_DOUBLE; - memcpy(&(v->data.dval), &kv->data.dval, sizeof(double)); - break; - case OPAL_TIMEVAL: - v->type = PMIX_TIMEVAL; - memcpy(&(v->data.tv), &kv->data.tv, sizeof(struct timeval)); - break; - case OPAL_BYTE_OBJECT: - v->type = PMIX_BYTE_OBJECT; - if (NULL != kv->data.bo.bytes) { - v->data.bo.bytes = (char*)malloc(kv->data.bo.size); - memcpy(v->data.bo.bytes, kv->data.bo.bytes, kv->data.bo.size); - v->data.bo.size = (size_t)kv->data.bo.size; - } else { - v->data.bo.bytes = NULL; - v->data.bo.size = 0; - } - break; - default: - /* silence warnings */ - break; + case OPAL_UNDEF: + v->type = PMIX_UNDEF; + opal_output(0, "TYPE WAS UNDEF"); + break; + case OPAL_BOOL: + v->type = PMIX_BOOL; + memcpy(&(v->data.flag), &kv->data.flag, 1); + break; + case OPAL_BYTE: + v->type = PMIX_BYTE; + memcpy(&(v->data.byte), &kv->data.byte, 1); + break; + case OPAL_STRING: + v->type = PMIX_STRING; + if (NULL != kv->data.string) { + v->data.string = strdup(kv->data.string); + } else { + v->data.string = NULL; + } + break; + case OPAL_SIZE: + v->type = PMIX_SIZE; + v->data.size = (size_t)kv->data.size; + break; + case OPAL_PID: + v->type = PMIX_PID; + memcpy(&(v->data.pid), &kv->data.pid, sizeof(pid_t)); + break; + case OPAL_INT: + v->type = PMIX_INT; + memcpy(&(v->data.integer), &kv->data.integer, sizeof(int)); + break; + case OPAL_INT8: + v->type = PMIX_INT8; + memcpy(&(v->data.int8), &kv->data.int8, 1); + break; + case OPAL_INT16: + v->type = PMIX_INT16; + memcpy(&(v->data.int16), &kv->data.int16, 2); + break; + case OPAL_INT32: + v->type = PMIX_INT32; + memcpy(&(v->data.int32), &kv->data.int32, 4); + break; + case OPAL_INT64: + v->type = PMIX_INT64; + memcpy(&(v->data.int64), &kv->data.int64, 8); + break; + case OPAL_UINT: + v->type = PMIX_UINT; + memcpy(&(v->data.uint), &kv->data.uint, sizeof(int)); + break; + case OPAL_UINT8: + v->type = PMIX_UINT8; + memcpy(&(v->data.uint8), &kv->data.uint8, 1); + break; + case OPAL_UINT16: + v->type = PMIX_UINT16; + memcpy(&(v->data.uint16), &kv->data.uint16, 2); + break; + case OPAL_UINT32: + v->type = PMIX_UINT32; + memcpy(&(v->data.uint32), &kv->data.uint32, 4); + break; + case OPAL_UINT64: + v->type = PMIX_UINT64; + memcpy(&(v->data.uint64), &kv->data.uint64, 8); + break; + case OPAL_FLOAT: + v->type = PMIX_FLOAT; + memcpy(&(v->data.fval), &kv->data.fval, sizeof(float)); + break; + case OPAL_DOUBLE: + v->type = PMIX_DOUBLE; + memcpy(&(v->data.dval), &kv->data.dval, sizeof(double)); + break; + case OPAL_TIMEVAL: + v->type = PMIX_TIMEVAL; + memcpy(&(v->data.tv), &kv->data.tv, sizeof(struct timeval)); + break; + case OPAL_BYTE_OBJECT: + v->type = PMIX_BYTE_OBJECT; + if (NULL != kv->data.bo.bytes) { + v->data.bo.bytes = (char*)malloc(kv->data.bo.size); + memcpy(v->data.bo.bytes, kv->data.bo.bytes, kv->data.bo.size); + v->data.bo.size = (size_t)kv->data.bo.size; + } else { + v->data.bo.bytes = NULL; + v->data.bo.size = 0; + } + break; + default: + /* silence warnings */ + break; } } int pmix1_value_unload(opal_value_t *kv, - const pmix_value_t *v) + const pmix_value_t *v) { int rc=OPAL_SUCCESS; switch(v->type) { case PMIX_UNDEF: - rc = OPAL_ERR_UNKNOWN_DATA_TYPE; - break; + rc = OPAL_ERR_UNKNOWN_DATA_TYPE; + break; case PMIX_BOOL: - kv->type = OPAL_BOOL; - memcpy(&kv->data.flag, &(v->data.flag), 1); - break; + kv->type = OPAL_BOOL; + memcpy(&kv->data.flag, &(v->data.flag), 1); + break; case PMIX_BYTE: - kv->type = OPAL_BYTE; - memcpy(&kv->data.byte, &(v->data.byte), 1); - break; + kv->type = OPAL_BYTE; + memcpy(&kv->data.byte, &(v->data.byte), 1); + break; case PMIX_STRING: - kv->type = OPAL_STRING; - if (NULL != v->data.string) { - kv->data.string = strdup(v->data.string); - } - break; + kv->type = OPAL_STRING; + if (NULL != v->data.string) { + kv->data.string = strdup(v->data.string); + } + break; case PMIX_SIZE: - kv->type = OPAL_SIZE; - kv->data.size = (int)v->data.size; - break; + kv->type = OPAL_SIZE; + kv->data.size = (int)v->data.size; + break; case PMIX_PID: - kv->type = OPAL_PID; - memcpy(&kv->data.pid, &(v->data.pid), sizeof(pid_t)); - break; + kv->type = OPAL_PID; + memcpy(&kv->data.pid, &(v->data.pid), sizeof(pid_t)); + break; case PMIX_INT: - kv->type = OPAL_INT; - memcpy(&kv->data.integer, &(v->data.integer), sizeof(int)); - break; + kv->type = OPAL_INT; + memcpy(&kv->data.integer, &(v->data.integer), sizeof(int)); + break; case PMIX_INT8: - kv->type = OPAL_INT8; - memcpy(&kv->data.int8, &(v->data.int8), 1); - break; + kv->type = OPAL_INT8; + memcpy(&kv->data.int8, &(v->data.int8), 1); + break; case PMIX_INT16: - kv->type = OPAL_INT16; - memcpy(&kv->data.int16, &(v->data.int16), 2); - break; + kv->type = OPAL_INT16; + memcpy(&kv->data.int16, &(v->data.int16), 2); + break; case PMIX_INT32: - kv->type = OPAL_INT32; - memcpy(&kv->data.int32, &(v->data.int32), 4); - break; + kv->type = OPAL_INT32; + memcpy(&kv->data.int32, &(v->data.int32), 4); + break; case PMIX_INT64: - kv->type = OPAL_INT64; - memcpy(&kv->data, &(v->data.int64), 8); - break; + kv->type = OPAL_INT64; + memcpy(&kv->data, &(v->data.int64), 8); + break; case PMIX_UINT: - kv->type = OPAL_UINT; - memcpy(&kv->data, &(v->data.uint), sizeof(int)); - break; + kv->type = OPAL_UINT; + memcpy(&kv->data, &(v->data.uint), sizeof(int)); + break; case PMIX_UINT8: - kv->type = OPAL_UINT8; - memcpy(&kv->data, &(v->data.uint8), 1); - break; + kv->type = OPAL_UINT8; + memcpy(&kv->data, &(v->data.uint8), 1); + break; case PMIX_UINT16: - kv->type = OPAL_UINT16; - memcpy(&kv->data, &(v->data.uint16), 2); - break; + kv->type = OPAL_UINT16; + memcpy(&kv->data, &(v->data.uint16), 2); + break; case PMIX_UINT32: - kv->type = OPAL_UINT32; - memcpy(&kv->data, &(v->data.uint32), 4); - break; + kv->type = OPAL_UINT32; + memcpy(&kv->data, &(v->data.uint32), 4); + break; case PMIX_UINT64: - kv->type = OPAL_UINT64; - memcpy(&kv->data, &(v->data.uint64), 8); - break; + kv->type = OPAL_UINT64; + memcpy(&kv->data, &(v->data.uint64), 8); + break; case PMIX_FLOAT: - kv->type = OPAL_FLOAT; - memcpy(&kv->data, &(v->data.fval), sizeof(float)); - break; + kv->type = OPAL_FLOAT; + memcpy(&kv->data, &(v->data.fval), sizeof(float)); + break; case PMIX_DOUBLE: - kv->type = OPAL_DOUBLE; - memcpy(&kv->data, &(v->data.dval), sizeof(double)); - break; + kv->type = OPAL_DOUBLE; + memcpy(&kv->data, &(v->data.dval), sizeof(double)); + break; case PMIX_TIMEVAL: - kv->type = OPAL_TIMEVAL; - memcpy(&kv->data, &(v->data.tv), sizeof(struct timeval)); - break; + kv->type = OPAL_TIMEVAL; + memcpy(&kv->data, &(v->data.tv), sizeof(struct timeval)); + break; case PMIX_BYTE_OBJECT: - kv->type = OPAL_BYTE_OBJECT; - if (NULL != v->data.bo.bytes && 0 < v->data.bo.size) { - kv->data.bo.bytes = (uint8_t*)malloc(v->data.bo.size); - memcpy(kv->data.bo.bytes, v->data.bo.bytes, v->data.bo.size); - kv->data.bo.size = (int)v->data.bo.size; - } else { - kv->data.bo.bytes = NULL; - kv->data.bo.size = 0; - } - break; + kv->type = OPAL_BYTE_OBJECT; + if (NULL != v->data.bo.bytes && 0 < v->data.bo.size) { + kv->data.bo.bytes = (uint8_t*)malloc(v->data.bo.size); + memcpy(kv->data.bo.bytes, v->data.bo.bytes, v->data.bo.size); + kv->data.bo.size = (int)v->data.bo.size; + } else { + kv->data.bo.bytes = NULL; + kv->data.bo.size = 0; + } + break; default: - /* silence warnings */ - rc = OPAL_ERROR; - break; + /* silence warnings */ + rc = OPAL_ERROR; + break; } return rc; } @@ -491,8 +491,8 @@ int pmix1_value_unload(opal_value_t *kv, /**** INSTANTIATE INTERNAL CLASSES ****/ OBJ_CLASS_INSTANCE(opal_pmix1_jobid_trkr_t, - opal_list_item_t, - NULL, NULL); + opal_list_item_t, + NULL, NULL); static void opcon(pmix1_opcaddy_t *p) { @@ -515,21 +515,21 @@ static void opcon(pmix1_opcaddy_t *p) static void opdes(pmix1_opcaddy_t *p) { if (NULL != p->procs) { - PMIX_PROC_FREE(p->procs, p->nprocs); + PMIX_PROC_FREE(p->procs, p->nprocs); } if (NULL != p->error_procs) { - PMIX_PROC_FREE(p->error_procs, p->nerror_procs); + PMIX_PROC_FREE(p->error_procs, p->nerror_procs); } if (NULL != p->info) { - PMIX_INFO_FREE(p->info, p->sz); + PMIX_INFO_FREE(p->info, p->sz); } if (NULL != p->apps) { - PMIX_APP_FREE(p->apps, p->sz); + PMIX_APP_FREE(p->apps, p->sz); } } OBJ_CLASS_INSTANCE(pmix1_opcaddy_t, - opal_object_t, - opcon, opdes); + opal_object_t, + opcon, opdes); static void ocadcon(pmix1_opalcaddy_t *p) { @@ -552,5 +552,5 @@ static void ocaddes(pmix1_opalcaddy_t *p) OPAL_LIST_DESTRUCT(&p->apps); } OBJ_CLASS_INSTANCE(pmix1_opalcaddy_t, - opal_object_t, - ocadcon, ocaddes); + opal_object_t, + ocadcon, ocaddes); diff --git a/opal/mca/pmix/ext114/pmix_ext.h b/opal/mca/pmix/ext114/pmix_ext.h index a5ec4bad0bf..03c3d4c9e71 100644 --- a/opal/mca/pmix/ext114/pmix_ext.h +++ b/opal/mca/pmix/ext114/pmix_ext.h @@ -29,7 +29,6 @@ #include "opal/mca/pmix/pmix.h" #include "pmix_server.h" -#include "pmix_server.h" #include "pmix/pmix_common.h" BEGIN_C_DECLS diff --git a/opal/mca/pmix/ext20/Makefile.am b/opal/mca/pmix/ext20/Makefile.am deleted file mode 100644 index 3a62d32452b..00000000000 --- a/opal/mca/pmix/ext20/Makefile.am +++ /dev/null @@ -1,46 +0,0 @@ -# -# Copyright (c) 2014-2016 Intel, Inc. All rights reserved. -# Copyright (c) 2015 Cisco Systems, Inc. All rights reserved. -# Copyright (c) 2014-2015 Mellanox Technologies, Inc. -# All rights reserved. -# $COPYRIGHT$ -# -# Additional copyrights may follow -# -# $HEADER$ -# - -sources = \ - pmix_ext20.h \ - pmix_ext20_component.c \ - pmix_ext20.c \ - pmix_ext20_client.c \ - pmix_ext20_server_south.c \ - pmix_ext20_server_north.c - -# Make the output library in this directory, and name it either -# mca__.la (for DSO builds) or libmca__.la -# (for static builds). - -if MCA_BUILD_opal_pmix_ext20_DSO -component_noinst = -component_install = mca_pmix_ext20.la -else -component_noinst = libmca_pmix_ext20.la -component_install = -endif - -mcacomponentdir = $(opallibdir) -mcacomponent_LTLIBRARIES = $(component_install) -mca_pmix_ext20_la_SOURCES = $(sources) -mca_pmix_ext20_la_CFLAGS = -mca_pmix_ext20_la_CPPFLAGS = $(opal_pmix_ext20_CPPFLAGS) -mca_pmix_ext20_la_LDFLAGS = -module -avoid-version $(opal_pmix_ext20_LDFLAGS) -mca_pmix_ext20_la_LIBADD = $(opal_pmix_ext20_LIBS) - -noinst_LTLIBRARIES = $(component_noinst) -libmca_pmix_ext20_la_SOURCES =$(sources) -libmca_pmix_ext20_la_CFLAGS = -libmca_pmix_ext20_la_CPPFLAGS = $(opal_pmix_ext20_CPPFLAGS) -libmca_pmix_ext20_la_LDFLAGS = -module -avoid-version $(opal_pmix_ext20_LDFLAGS) -libmca_pmix_ext20_la_LIBADD = $(opal_pmix_ext20_LIBS) diff --git a/opal/mca/pmix/ext20/configure.m4 b/opal/mca/pmix/ext20/configure.m4 deleted file mode 100644 index 423d670bfcd..00000000000 --- a/opal/mca/pmix/ext20/configure.m4 +++ /dev/null @@ -1,88 +0,0 @@ -# -*- shell-script -*- -# -# Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana -# University Research and Technology -# Corporation. All rights reserved. -# 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, -# University of Stuttgart. All rights reserved. -# Copyright (c) 2004-2005 The Regents of the University of California. -# All rights reserved. -# Copyright (c) 2011-2013 Los Alamos National Security, LLC. -# All rights reserved. -# Copyright (c) 2010-2015 Cisco Systems, Inc. All rights reserved. -# Copyright (c) 2013-2016 Intel, Inc. All rights reserved. -# Copyright (c) 2015 Research Organization for Information Science -# and Technology (RIST). All rights reserved. -# Copyright (c) 2014-2015 Mellanox Technologies, Inc. -# All rights reserved. -# $COPYRIGHT$ -# -# Additional copyrights may follow -# -# $HEADER$ -# - -# MCA_pmix_ext20_CONFIG([action-if-found], [action-if-not-found]) -# ----------------------------------------------------------- -AC_DEFUN([MCA_opal_pmix_ext20_CONFIG],[ - AC_CONFIG_FILES([opal/mca/pmix/ext20/Makefile]) - - AC_REQUIRE([OPAL_CHECK_PMIX]) - - AS_IF([test "$opal_external_pmix_happy" = "yes"], - [AS_IF([test "$opal_event_external_support" != "yes"], - [AC_MSG_WARN([EXTERNAL PMIX SUPPORT REQUIRES USE OF EXTERNAL LIBEVENT]) - AC_MSG_WARN([LIBRARY. THIS LIBRARY MUST POINT TO THE SAME ONE USED]) - AC_MSG_WARN([TO BUILD PMIX OR ELSE UNPREDICTABLE BEHAVIOR MAY RESULT]) - AC_MSG_ERROR([PLEASE CORRECT THE CONFIGURE COMMAND LINE AND REBUILD])]) - AS_IF([test "$opal_hwloc_external_support" != "yes"], - [AC_MSG_WARN([EXTERNAL PMIX SUPPORT REQUIRES USE OF EXTERNAL HWLOC]) - AC_MSG_WARN([LIBRARY THIS LIBRARY MUST POINT TO THE SAME ONE USED ]) - AC_MSG_WARN([TO BUILD PMIX OR ELSE UNPREDICTABLE BEHAVIOR MAY RESULT]) - AC_MSG_ERROR([PLEASE CORRECT THE CONFIGURE COMMAND LINE AND REBUILD])]) - external_WRAPPER_EXTRA_CPPFLAGS='-I${includedir}/openmpi/$opal_pmix_external_basedir/pmix -I${includedir}/openmpi/$opal_pmix_external_basedir/pmix/include' - # check for the 2.0 series by looking for a function - # that was added in that series - AC_MSG_CHECKING([if external component is series 2.0]) - OPAL_CHECK_PACKAGE([opal_pmix_ext20], - [pmix.h], - [pmix], - [PMIx_Register_event_handler], - [-lpmix], - [$pmix_ext_install_dir], - [$pmix_ext_install_dir/lib], - [AC_MSG_RESULT([yes]) - opal_pmix_ext20_happy=yes], - [AC_MSG_RESULT([no]) - opal_pmix_ext20_happy=no]) - - # if we have 2.0, then check further to see if we have - # the PMIx_Query_info function as that is even newer - AS_IF([test "$opal_pmix_ext20_happy" = "yes"], - [AC_MSG_CHECKING([if external component is series 2.0]) - OPAL_CHECK_PACKAGE([opal_pmix_ext20], - [pmix.h], - [pmix], - [PMIx_Query_info_nb], - [-lpmix], - [$pmix_ext_install_dir], - [$pmix_ext_install_dir/lib], - [AC_MSG_RESULT([yes]) - opal_pmix_query_happy=1], - [AC_MSG_RESULT([no]) - opal_pmix_query_happy=0])]) - - AC_DEFINE_UNQUOTED([HAVE_PMIX_QUERY_FUNCTION], [$opal_pmix_query_happy], - [Whether or not the external library has the PMIx_Query_info function]) - AC_SUBST(opal_pmix_ext20_CPPFLAGS) - AC_SUBST(opal_pmix_ext20_LDFLAGS) - AC_SUBST(opal_pmix_ext20_LIBS) - - AS_IF([test "$opal_pmix_ext20_happy" = "yes"], - [$1], - [$2])], - [$2]) -])dnl diff --git a/opal/mca/pmix/ext20/pmix_ext20.c b/opal/mca/pmix/ext20/pmix_ext20.c deleted file mode 100644 index 486ef27393e..00000000000 --- a/opal/mca/pmix/ext20/pmix_ext20.c +++ /dev/null @@ -1,1390 +0,0 @@ -/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */ -/* - * Copyright (c) 2014-2016 Intel, Inc. All rights reserved. - * Copyright (c) 2014-2016 Research Organization for Information Science - * and Technology (RIST). All rights reserved. - * Copyright (c) 2014-2015 Mellanox Technologies, Inc. - * All rights reserved. - * Copyright (c) 2016 Cisco Systems, Inc. All rights reserved. - * $COPYRIGHT$ - * - * Additional copyrights may follow - * - * $HEADER$ - */ - -#include "opal_config.h" -#include "opal/constants.h" -#include "opal/types.h" - -#ifdef HAVE_STRING_H -#include -#endif -#ifdef HAVE_UNISTD_H -#include -#endif - -#include "opal/dss/dss.h" -#include "opal/mca/event/event.h" -#include "opal/mca/hwloc/base/base.h" -#include "opal/runtime/opal.h" -#include "opal/runtime/opal_progress_threads.h" -#include "opal/util/argv.h" -#include "opal/util/error.h" -#include "opal/util/output.h" -#include "opal/util/proc.h" -#include "opal/util/show_help.h" - -#include "pmix_ext20.h" -#include "opal/mca/pmix/base/base.h" -#include "opal/mca/pmix/pmix_types.h" - -#include - -/**** C.O.M.M.O.N I.N.T.E.R.F.A.C.E.S ****/ - -/* These are functions used by both client and server to - * access common functions in the embedded PMIx library */ - -static const char *ext20_get_nspace(opal_jobid_t jobid); -static void ext20_register_jobid(opal_jobid_t jobid, const char *nspace); -static void register_handler(opal_list_t *event_codes, - opal_list_t *info, - opal_pmix_notification_fn_t evhandler, - opal_pmix_evhandler_reg_cbfunc_t cbfunc, - void *cbdata); -static void deregister_handler(size_t evhandler, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata); -static int notify_event(int status, - const opal_process_name_t *source, - opal_pmix_data_range_t range, - opal_list_t *info, - opal_pmix_op_cbfunc_t cbfunc, void *cbdata); - -const opal_pmix_base_module_t opal_pmix_ext20_module = { - /* client APIs */ - .init = ext20_client_init, - .finalize = ext20_client_finalize, - .initialized = ext20_initialized, - .abort = ext20_abort, - .commit = ext20_commit, - .fence = ext20_fence, - .fence_nb = ext20_fencenb, - .put = ext20_put, - .get = ext20_get, - .get_nb = ext20_getnb, - .publish = ext20_publish, - .publish_nb = ext20_publishnb, - .lookup = ext20_lookup, - .lookup_nb = ext20_lookupnb, - .unpublish = ext20_unpublish, - .unpublish_nb = ext20_unpublishnb, - .spawn = ext20_spawn, - .spawn_nb = ext20_spawnnb, - .connect = ext20_connect, - .connect_nb = ext20_connectnb, - .disconnect = ext20_disconnect, - .disconnect_nb = ext20_disconnectnb, - .resolve_peers = ext20_resolve_peers, - .resolve_nodes = ext20_resolve_nodes, - /* server APIs */ - .server_init = ext20_server_init, - .server_finalize = ext20_server_finalize, - .generate_regex = ext20_server_gen_regex, - .generate_ppn = ext20_server_gen_ppn, - .server_register_nspace = ext20_server_register_nspace, - .server_deregister_nspace = ext20_server_deregister_nspace, - .server_register_client = ext20_server_register_client, - .server_deregister_client = ext20_server_deregister_client, - .server_setup_fork = ext20_server_setup_fork, - .server_dmodex_request = ext20_server_dmodex, - .server_notify_event = ext20_server_notify_event, - /* utility APIs */ - .get_version = PMIx_Get_version, - .register_evhandler = register_handler, - .deregister_evhandler = deregister_handler, - .notify_event = notify_event, - .store_local = ext20_store_local, - .get_nspace = ext20_get_nspace, - .register_jobid = ext20_register_jobid -}; - -static const char *ext20_get_nspace(opal_jobid_t jobid) -{ - opal_ext20_jobid_trkr_t *jptr; - - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == jobid) { - return jptr->nspace; - } - } - return NULL; -} - -static void ext20_register_jobid(opal_jobid_t jobid, const char *nspace) -{ - opal_ext20_jobid_trkr_t *jptr; - - /* if we don't already have it, add this to our jobid tracker */ - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == jobid) { - return; - } - } - jptr = OBJ_NEW(opal_ext20_jobid_trkr_t); - (void)strncpy(jptr->nspace, nspace, PMIX_MAX_NSLEN); - jptr->jobid = jobid; - opal_list_append(&mca_pmix_ext20_component.jobids, &jptr->super); -} - -static void completion_handler(int status, void *cbdata) -{ - opal_ext20_event_chain_t *chain = (opal_ext20_event_chain_t*)cbdata; - if (NULL != chain->info) { - OPAL_LIST_RELEASE(chain->info); - } -} - -static void progress_local_event_hdlr(int status, - opal_list_t *results, - opal_pmix_op_cbfunc_t cbfunc, void *thiscbdata, - void *notification_cbdata) -{ - opal_ext20_event_chain_t *chain = (opal_ext20_event_chain_t*)notification_cbdata; - size_t n; - opal_list_item_t *nxt; - opal_ext20_single_event_t *sing; - opal_ext20_multi_event_t *multi; - opal_ext20_default_event_t *def; - - /* if the caller indicates that the chain is completed, then stop here */ - if (OPAL_ERR_HANDLERS_COMPLETE == status) { - goto complete; - } - - /* if any results were provided, then add them here */ - if (NULL != results) { - while (NULL != (nxt = opal_list_remove_first(results))) { - opal_list_append(results, nxt); - } - } - - /* see if we need to continue, starting with the single code events */ - if (NULL != chain->sing) { - /* the last handler was for a single code - see if there are - * any others that match this event */ - while (opal_list_get_end(&mca_pmix_ext20_component.single_events) != (nxt = opal_list_get_next(&chain->sing->super))) { - sing = (opal_ext20_single_event_t*)nxt; - if (sing->code == chain->status) { - OBJ_RETAIN(chain); - chain->sing = sing; - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s PROGRESS CALLING SINGLE EVHDLR", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); - sing->handler(chain->status, &chain->source, - chain->info, &chain->results, - progress_local_event_hdlr, (void*)chain); - goto complete; - } - } - /* if we get here, then there are no more single code - * events that match */ - chain->sing = NULL; - /* pickup the beginning of the multi-code event list */ - if (0 < opal_list_get_size(&mca_pmix_ext20_component.multi_events)) { - chain->multi = (opal_ext20_multi_event_t*)opal_list_get_begin(&mca_pmix_ext20_component.multi_events); - } - } - - /* see if we need to continue with the multi code events */ - if (NULL != chain->multi) { - while (opal_list_get_end(&mca_pmix_ext20_component.multi_events) != (nxt = opal_list_get_next(&chain->multi->super))) { - multi = (opal_ext20_multi_event_t*)nxt; - for (n=0; n < multi->ncodes; n++) { - if (multi->codes[n] == chain->status) { - /* found it - invoke the handler, pointing its - * callback function to our progression function */ - OBJ_RETAIN(chain); - chain->multi = multi; - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s PROGRESS CALLING MULTI EVHDLR", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); - multi->handler(chain->status, &chain->source, - chain->info, &chain->results, - progress_local_event_hdlr, (void*)chain); - goto complete; - } - } - } - /* if we get here, then there are no more multi-mode - * events that match */ - chain->multi = NULL; - /* pickup the beginning of the default event list */ - if (0 < opal_list_get_size(&mca_pmix_ext20_component.default_events)) { - chain->def = (opal_ext20_default_event_t*)opal_list_get_begin(&mca_pmix_ext20_component.default_events); - } - } - - /* if they didn't want it to go to a default handler, then we are done */ - if (chain->nondefault) { - goto complete; - } - - if (NULL != chain->def) { - if (opal_list_get_end(&mca_pmix_ext20_component.default_events) != (nxt = opal_list_get_next(&chain->def->super))) { - def = (opal_ext20_default_event_t*)nxt; - OBJ_RETAIN(chain); - chain->def = def; - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s PROGRESS CALLING DEFAULT EVHDLR", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); - def->handler(chain->status, &chain->source, - chain->info, &chain->results, - progress_local_event_hdlr, (void*)chain); - } - } - - complete: - /* we still have to call their final callback */ - if (NULL != chain->final_cbfunc) { - chain->final_cbfunc(OPAL_SUCCESS, chain->final_cbdata); - } - /* maintain acctng */ - OBJ_RELEASE(chain); - /* let the caller know that we are done with their callback */ - if (NULL != cbfunc) { - cbfunc(OPAL_SUCCESS, thiscbdata); - } -} - -static void _event_hdlr(int sd, short args, void *cbdata) -{ - ext20_threadshift_t *cd = (ext20_threadshift_t*)cbdata; - size_t n; - opal_ext20_event_chain_t *chain; - opal_ext20_single_event_t *sing; - opal_ext20_multi_event_t *multi; - opal_ext20_default_event_t *def; - - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s _EVENT_HDLR RECEIVED NOTIFICATION OF STATUS %d", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), cd->status); - - chain = OBJ_NEW(opal_ext20_event_chain_t); - /* point it at our final callback */ - chain->final_cbfunc = completion_handler; - chain->final_cbdata = chain; - - /* carry across provided info */ - chain->status = cd->status; - chain->source = cd->pname; - chain->info = cd->info; - chain->nondefault = cd->nondefault; - - /* cycle thru the single-event registrations first */ - OPAL_LIST_FOREACH(sing, &mca_pmix_ext20_component.single_events, opal_ext20_single_event_t) { - if (sing->code == chain->status) { - /* found it - invoke the handler, pointing its - * callback function to our progression function */ - OBJ_RETAIN(chain); - chain->sing = sing; - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s _EVENT_HDLR CALLING SINGLE EVHDLR", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); - sing->handler(chain->status, &chain->source, - chain->info, &chain->results, - progress_local_event_hdlr, (void*)chain); - return; - } - } - - /* if we didn't find any match in the single-event registrations, - * then cycle thru the multi-event registrations next */ - OPAL_LIST_FOREACH(multi, &mca_pmix_ext20_component.multi_events, opal_ext20_multi_event_t) { - for (n=0; n < multi->ncodes; n++) { - if (multi->codes[n] == chain->status) { - /* found it - invoke the handler, pointing its - * callback function to our progression function */ - OBJ_RETAIN(chain); - chain->multi = multi; - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s _EVENT_HDLR CALLING MULTI EVHDLR", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); - multi->handler(chain->status, &chain->source, - chain->info, &chain->results, - progress_local_event_hdlr, (void*)chain); - return; - } - } - } - - /* if they didn't want it to go to a default handler, then we are done */ - if (chain->nondefault) { - /* if we get here, then we need to cache this event in case they - * register for it later - we cannot lose individual events */ - opal_list_append(&mca_pmix_ext20_component.cache, &chain->super); - return; - } - - /* we are done with the threadshift caddy */ - OBJ_RELEASE(cd); - - /* finally, pass it to any default handlers */ - if (0 < opal_list_get_size(&mca_pmix_ext20_component.default_events)) { - def = (opal_ext20_default_event_t*)opal_list_get_first(&mca_pmix_ext20_component.default_events); - OBJ_RETAIN(chain); - chain->def = def; - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s _EVENT_HDLR CALLING DEFAULT EVHDLR", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); - def->handler(chain->status, &chain->source, - chain->info, &chain->results, - progress_local_event_hdlr, (void*)chain); - return; - } - - /* we still have to call their final callback */ - if (NULL != chain->final_cbfunc) { - chain->final_cbfunc(PMIX_SUCCESS, chain->final_cbdata); - } - return; -} - -/* this function will be called by the PMIx client library - * whenever it receives notification of an event. The - * notification can come from an ORTE daemon (when launched - * by mpirun), directly from a RM (when direct launched), or - * from another process (via the local daemon). - * The call will occur in the PMIx event base */ -void ext20_event_hdlr(size_t evhdlr_registration_id, - pmix_status_t status, const pmix_proc_t *source, - pmix_info_t info[], size_t ninfo, - pmix_info_t results[], size_t nresults, - pmix_event_notification_cbfunc_fn_t cbfunc, - void *cbdata) -{ - ext20_threadshift_t *cd; - int rc; - opal_value_t *iptr; - size_t n; - - /* this is in the PMIx local thread - need to threadshift to - * our own thread as we will be accessing framework-global - * lists and objects */ - - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s RECEIVED NOTIFICATION OF STATUS %d", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), status); - - cd = OBJ_NEW(ext20_threadshift_t); - - /* convert the incoming status */ - cd->status = ext20_convert_rc(status); - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s CONVERTED STATUS %d TO STATUS %d", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), status, cd->status); - /* convert the nspace/rank to an opal_process_name_t */ - if (NULL == source) { - cd->pname.jobid = OPAL_NAME_INVALID->jobid; - cd->pname.vpid = OPAL_NAME_INVALID->vpid; - } else { - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&cd->pname.jobid, source->nspace))) { - OPAL_ERROR_LOG(rc); - OBJ_RELEASE(cd); - return; - } - cd->pname.vpid = ext20_convert_rank(source->rank); - } - - /* convert the array of info */ - if (NULL != info) { - cd->info = OBJ_NEW(opal_list_t); - for (n=0; n < ninfo; n++) { - if (0 == strncmp(info[n].key, PMIX_EVENT_NON_DEFAULT, PMIX_MAX_KEYLEN)) { - cd->nondefault = true; - } - iptr = OBJ_NEW(opal_value_t); - iptr->key = strdup(info[n].key); - if (OPAL_SUCCESS != (rc = ext20_value_unload(iptr, &info[n].value))) { - OPAL_ERROR_LOG(rc); - OBJ_RELEASE(iptr); - continue; - } - opal_list_append(cd->info, &iptr->super); - } - } - /* now push it into the local thread */ - event_assign(&cd->ev, opal_pmix_base.evbase, - -1, EV_WRITE, _event_hdlr, cd); - event_active(&cd->ev, EV_WRITE, 1); - - /* we don't need any of the data they provided, - * so let them go */ - if (NULL != cbfunc) { - cbfunc(PMIX_SUCCESS, NULL, 0, NULL, NULL, cbdata); - } -} - -opal_vpid_t ext20_convert_rank(int rank) -{ - switch(rank) { - case PMIX_RANK_UNDEF: - return OPAL_VPID_INVALID; - case PMIX_RANK_WILDCARD: - return OPAL_VPID_WILDCARD; - default: - return (opal_vpid_t)rank; - } -} - -pmix_rank_t ext20_convert_opalrank(opal_vpid_t vpid) -{ - switch(vpid) { - case OPAL_VPID_WILDCARD: - return PMIX_RANK_WILDCARD; - case OPAL_VPID_INVALID: - return PMIX_RANK_UNDEF; - default: - return (pmix_rank_t)vpid; - } -} - -pmix_status_t ext20_convert_opalrc(int rc) -{ - switch (rc) { - case OPAL_ERR_DEBUGGER_RELEASE: - return PMIX_ERR_DEBUGGER_RELEASE; - - case OPAL_ERR_HANDLERS_COMPLETE: - return PMIX_EVENT_ACTION_COMPLETE; - - case OPAL_ERR_PROC_ABORTED: - return PMIX_ERR_PROC_ABORTED; - - case OPAL_ERR_PROC_REQUESTED_ABORT: - return PMIX_ERR_PROC_REQUESTED_ABORT; - - case OPAL_ERR_PROC_ABORTING: - return PMIX_ERR_PROC_ABORTING; - - case OPAL_ERR_NODE_DOWN: - return PMIX_ERR_NODE_DOWN; - - case OPAL_ERR_NODE_OFFLINE: - return PMIX_ERR_NODE_OFFLINE; - - case OPAL_ERR_NOT_IMPLEMENTED: - case OPAL_ERR_NOT_SUPPORTED: - return PMIX_ERR_NOT_SUPPORTED; - - case OPAL_ERR_NOT_FOUND: - return PMIX_ERR_NOT_FOUND; - - case OPAL_ERR_PERM: - case OPAL_ERR_UNREACH: - case OPAL_ERR_SERVER_NOT_AVAIL: - return PMIX_ERR_UNREACH; - - case OPAL_ERR_BAD_PARAM: - return PMIX_ERR_BAD_PARAM; - - case OPAL_ERR_OUT_OF_RESOURCE: - return PMIX_ERR_OUT_OF_RESOURCE; - - case OPAL_ERR_DATA_VALUE_NOT_FOUND: - return PMIX_ERR_DATA_VALUE_NOT_FOUND; - - case OPAL_ERR_TIMEOUT: - return PMIX_ERR_TIMEOUT; - - case OPAL_ERR_WOULD_BLOCK: - return PMIX_ERR_WOULD_BLOCK; - - case OPAL_EXISTS: - return PMIX_EXISTS; - - case OPAL_ERR_PARTIAL_SUCCESS: - return PMIX_QUERY_PARTIAL_SUCCESS; - - case OPAL_ERROR: - return PMIX_ERROR; - case OPAL_SUCCESS: - return PMIX_SUCCESS; - default: - return PMIX_ERROR; - } -} - -int ext20_convert_rc(pmix_status_t rc) -{ - switch (rc) { - case PMIX_ERR_DEBUGGER_RELEASE: - return OPAL_ERR_DEBUGGER_RELEASE; - - case PMIX_EVENT_ACTION_COMPLETE: - return OPAL_ERR_HANDLERS_COMPLETE; - - case PMIX_ERR_PROC_ABORTED: - return OPAL_ERR_PROC_ABORTED; - - case PMIX_ERR_PROC_REQUESTED_ABORT: - return OPAL_ERR_PROC_REQUESTED_ABORT; - - case PMIX_ERR_PROC_ABORTING: - return OPAL_ERR_PROC_ABORTING; - - case PMIX_ERR_NODE_DOWN: - return OPAL_ERR_NODE_DOWN; - - case PMIX_ERR_NODE_OFFLINE: - return OPAL_ERR_NODE_OFFLINE; - - case PMIX_ERR_NOT_SUPPORTED: - return OPAL_ERR_NOT_SUPPORTED; - - case PMIX_ERR_NOT_FOUND: - return OPAL_ERR_NOT_FOUND; - - case PMIX_ERR_OUT_OF_RESOURCE: - return OPAL_ERR_OUT_OF_RESOURCE; - - case PMIX_ERR_INIT: - return OPAL_ERROR; - - case PMIX_ERR_BAD_PARAM: - return OPAL_ERR_BAD_PARAM; - - case PMIX_ERR_UNREACH: - case PMIX_ERR_NO_PERMISSIONS: - return OPAL_ERR_UNREACH; - - case PMIX_ERR_TIMEOUT: - return OPAL_ERR_TIMEOUT; - - case PMIX_ERR_WOULD_BLOCK: - return OPAL_ERR_WOULD_BLOCK; - - case PMIX_ERR_LOST_CONNECTION_TO_SERVER: - case PMIX_ERR_LOST_PEER_CONNECTION: - case PMIX_ERR_LOST_CONNECTION_TO_CLIENT: - return OPAL_ERR_COMM_FAILURE; - - case PMIX_EXISTS: - return OPAL_EXISTS; - - case PMIX_QUERY_PARTIAL_SUCCESS: - return OPAL_ERR_PARTIAL_SUCCESS; - - case PMIX_ERROR: - return OPAL_ERROR; - case PMIX_SUCCESS: - return OPAL_SUCCESS; - default: - return OPAL_ERROR; - } -} - -opal_pmix_scope_t ext20_convert_scope(pmix_scope_t scope) -{ - switch(scope) { - case PMIX_SCOPE_UNDEF: - return OPAL_PMIX_SCOPE_UNDEF; - case PMIX_LOCAL: - return OPAL_PMIX_LOCAL; - case PMIX_REMOTE: - return OPAL_PMIX_REMOTE; - case PMIX_GLOBAL: - return OPAL_PMIX_GLOBAL; - default: - return OPAL_PMIX_SCOPE_UNDEF; - } -} - -pmix_scope_t ext20_convert_opalscope(opal_pmix_scope_t scope) { - switch(scope) { - case OPAL_PMIX_LOCAL: - return PMIX_LOCAL; - case OPAL_PMIX_REMOTE: - return PMIX_REMOTE; - case OPAL_PMIX_GLOBAL: - return PMIX_GLOBAL; - default: - return PMIX_SCOPE_UNDEF; - } -} - -pmix_data_range_t ext20_convert_opalrange(opal_pmix_data_range_t range) { - switch(range) { - case OPAL_PMIX_RANGE_UNDEF: - return PMIX_RANGE_UNDEF; - case OPAL_PMIX_RANGE_LOCAL: - return PMIX_RANGE_LOCAL; - case OPAL_PMIX_RANGE_NAMESPACE: - return PMIX_RANGE_NAMESPACE; - case OPAL_PMIX_RANGE_SESSION: - return PMIX_RANGE_SESSION; - case OPAL_PMIX_RANGE_GLOBAL: - return PMIX_RANGE_GLOBAL; - case OPAL_PMIX_RANGE_CUSTOM: - return PMIX_RANGE_CUSTOM; - default: - return PMIX_SCOPE_UNDEF; - } -} - -opal_pmix_data_range_t ext20_convert_range(pmix_data_range_t range) { - switch(range) { - case PMIX_RANGE_UNDEF: - return OPAL_PMIX_RANGE_UNDEF; - case PMIX_RANGE_LOCAL: - return OPAL_PMIX_RANGE_LOCAL; - case PMIX_RANGE_NAMESPACE: - return OPAL_PMIX_RANGE_NAMESPACE; - case PMIX_RANGE_SESSION: - return OPAL_PMIX_RANGE_SESSION; - case PMIX_RANGE_GLOBAL: - return OPAL_PMIX_RANGE_GLOBAL; - case PMIX_RANGE_CUSTOM: - return OPAL_PMIX_RANGE_CUSTOM; - default: - return OPAL_PMIX_SCOPE_UNDEF; - } -} - -opal_pmix_persistence_t ext20_convert_persist(pmix_persistence_t persist) -{ - switch(persist) { - case PMIX_PERSIST_INDEF: - return OPAL_PMIX_PERSIST_INDEF; - case PMIX_PERSIST_FIRST_READ: - return OPAL_PMIX_PERSIST_FIRST_READ; - case PMIX_PERSIST_PROC: - return OPAL_PMIX_PERSIST_PROC; - case PMIX_PERSIST_APP: - return OPAL_PMIX_PERSIST_APP; - case PMIX_PERSIST_SESSION: - return OPAL_PMIX_PERSIST_SESSION; - default: - return OPAL_PMIX_PERSIST_INDEF; - } -} - -pmix_persistence_t ext20_convert_opalpersist(opal_pmix_persistence_t persist) -{ - switch(persist) { - case OPAL_PMIX_PERSIST_INDEF: - return PMIX_PERSIST_INDEF; - case OPAL_PMIX_PERSIST_FIRST_READ: - return PMIX_PERSIST_FIRST_READ; - case OPAL_PMIX_PERSIST_PROC: - return PMIX_PERSIST_PROC; - case OPAL_PMIX_PERSIST_APP: - return PMIX_PERSIST_APP; - case OPAL_PMIX_PERSIST_SESSION: - return PMIX_PERSIST_SESSION; - default: - return PMIX_PERSIST_INDEF; - } -} - -/**** RHC: NEED TO ADD SUPPORT FOR NEW PMIX DATA TYPES, INCLUDING - **** CONVERSION OF PROC STATES ****/ - -void ext20_value_load(pmix_value_t *v, - opal_value_t *kv) -{ - switch(kv->type) { - case OPAL_UNDEF: - v->type = PMIX_UNDEF; - break; - case OPAL_BOOL: - v->type = PMIX_BOOL; - memcpy(&(v->data.flag), &kv->data.flag, 1); - break; - case OPAL_BYTE: - v->type = PMIX_BYTE; - memcpy(&(v->data.byte), &kv->data.byte, 1); - break; - case OPAL_STRING: - v->type = PMIX_STRING; - if (NULL != kv->data.string) { - v->data.string = strdup(kv->data.string); - } else { - v->data.string = NULL; - } - break; - case OPAL_SIZE: - v->type = PMIX_SIZE; - v->data.size = (size_t)kv->data.size; - break; - case OPAL_PID: - v->type = PMIX_PID; - memcpy(&(v->data.pid), &kv->data.pid, sizeof(pid_t)); - break; - case OPAL_INT: - v->type = PMIX_INT; - memcpy(&(v->data.integer), &kv->data.integer, sizeof(int)); - break; - case OPAL_INT8: - v->type = PMIX_INT8; - memcpy(&(v->data.int8), &kv->data.int8, 1); - break; - case OPAL_INT16: - v->type = PMIX_INT16; - memcpy(&(v->data.int16), &kv->data.int16, 2); - break; - case OPAL_INT32: - v->type = PMIX_INT32; - memcpy(&(v->data.int32), &kv->data.int32, 4); - break; - case OPAL_INT64: - v->type = PMIX_INT64; - memcpy(&(v->data.int64), &kv->data.int64, 8); - break; - case OPAL_UINT: - v->type = PMIX_UINT; - memcpy(&(v->data.uint), &kv->data.uint, sizeof(int)); - break; - case OPAL_UINT8: - v->type = PMIX_UINT8; - memcpy(&(v->data.uint8), &kv->data.uint8, 1); - break; - case OPAL_UINT16: - v->type = PMIX_UINT16; - memcpy(&(v->data.uint16), &kv->data.uint16, 2); - break; - case OPAL_UINT32: - v->type = PMIX_UINT32; - memcpy(&(v->data.uint32), &kv->data.uint32, 4); - break; - case OPAL_UINT64: - v->type = PMIX_UINT64; - memcpy(&(v->data.uint64), &kv->data.uint64, 8); - break; - case OPAL_FLOAT: - v->type = PMIX_FLOAT; - memcpy(&(v->data.fval), &kv->data.fval, sizeof(float)); - break; - case OPAL_DOUBLE: - v->type = PMIX_DOUBLE; - memcpy(&(v->data.dval), &kv->data.dval, sizeof(double)); - break; - case OPAL_TIMEVAL: - v->type = PMIX_TIMEVAL; - memcpy(&(v->data.tv), &kv->data.tv, sizeof(struct timeval)); - break; - case OPAL_TIME: - v->type = PMIX_TIME; - memcpy(&(v->data.time), &kv->data.time, sizeof(time_t)); - break; - case OPAL_STATUS: - v->type = PMIX_STATUS; - memcpy(&(v->data.status), &kv->data.status, sizeof(pmix_status_t)); - break; - case OPAL_VPID: - v->type = PMIX_PROC_RANK; - v->data.rank = ext20_convert_opalrank(kv->data.name.vpid); - break; - case OPAL_NAME: - v->type = PMIX_PROC; - /* have to stringify the jobid */ - (void)opal_snprintf_jobid(v->data.proc.nspace, PMIX_MAX_NSLEN, kv->data.name.vpid); - v->data.proc.rank = ext20_convert_opalrank(kv->data.name.vpid); - break; - case OPAL_BYTE_OBJECT: - v->type = PMIX_BYTE_OBJECT; - if (NULL != kv->data.bo.bytes) { - v->data.bo.bytes = (char*)malloc(kv->data.bo.size); - memcpy(v->data.bo.bytes, kv->data.bo.bytes, kv->data.bo.size); - v->data.bo.size = (size_t)kv->data.bo.size; - } else { - v->data.bo.bytes = NULL; - v->data.bo.size = 0; - } - break; - case OPAL_PERSIST: - v->type = PMIX_PERSIST; - v->data.persist = ext20_convert_opalpersist(kv->data.uint8); - break; - case OPAL_SCOPE: - v->type = PMIX_SCOPE; - v->data.scope = ext20_convert_opalscope(kv->data.uint8); - break; - case OPAL_DATA_RANGE: - v->type = PMIX_DATA_RANGE; - v->data.range = ext20_convert_opalrange(kv->data.uint8); - break; - case OPAL_PROC_STATE: - v->type = PMIX_PROC_STATE; - /* the OPAL layer doesn't have any concept of proc state, - * so the ORTE layer is responsible for converting it */ - memcpy(&v->data.state, &kv->data.uint8, sizeof(uint8_t)); - break; - case OPAL_PTR: - v->type = PMIX_POINTER; - v->data.ptr = kv->data.ptr; - break; - default: - /* silence warnings */ - break; - } -} - -int ext20_value_unload(opal_value_t *kv, - const pmix_value_t *v) -{ - int rc=OPAL_SUCCESS; - - - switch(v->type) { - case PMIX_UNDEF: - kv->type = OPAL_UNDEF; - break; - case PMIX_BOOL: - kv->type = OPAL_BOOL; - memcpy(&kv->data.flag, &(v->data.flag), 1); - break; - case PMIX_BYTE: - kv->type = OPAL_BYTE; - memcpy(&kv->data.byte, &(v->data.byte), 1); - break; - case PMIX_STRING: - kv->type = OPAL_STRING; - if (NULL != v->data.string) { - kv->data.string = strdup(v->data.string); - } - break; - case PMIX_SIZE: - kv->type = OPAL_SIZE; - kv->data.size = (int)v->data.size; - break; - case PMIX_PID: - kv->type = OPAL_PID; - memcpy(&kv->data.pid, &(v->data.pid), sizeof(pid_t)); - break; - case PMIX_INT: - kv->type = OPAL_INT; - memcpy(&kv->data.integer, &(v->data.integer), sizeof(int)); - break; - case PMIX_INT8: - kv->type = OPAL_INT8; - memcpy(&kv->data.int8, &(v->data.int8), 1); - break; - case PMIX_INT16: - kv->type = OPAL_INT16; - memcpy(&kv->data.int16, &(v->data.int16), 2); - break; - case PMIX_INT32: - kv->type = OPAL_INT32; - memcpy(&kv->data.int32, &(v->data.int32), 4); - break; - case PMIX_INT64: - kv->type = OPAL_INT64; - memcpy(&kv->data.int64, &(v->data.int64), 8); - break; - case PMIX_UINT: - kv->type = OPAL_UINT; - memcpy(&kv->data.uint, &(v->data.uint), sizeof(int)); - break; - case PMIX_UINT8: - kv->type = OPAL_UINT8; - memcpy(&kv->data.uint8, &(v->data.uint8), 1); - break; - case PMIX_UINT16: - kv->type = OPAL_UINT16; - memcpy(&kv->data.uint16, &(v->data.uint16), 2); - break; - case PMIX_UINT32: - kv->type = OPAL_UINT32; - memcpy(&kv->data.uint32, &(v->data.uint32), 4); - break; - case PMIX_UINT64: - kv->type = OPAL_UINT64; - memcpy(&kv->data.uint64, &(v->data.uint64), 8); - break; - case PMIX_FLOAT: - kv->type = OPAL_FLOAT; - memcpy(&kv->data.fval, &(v->data.fval), sizeof(float)); - break; - case PMIX_DOUBLE: - kv->type = OPAL_DOUBLE; - memcpy(&kv->data.dval, &(v->data.dval), sizeof(double)); - break; - case PMIX_TIMEVAL: - kv->type = OPAL_TIMEVAL; - memcpy(&kv->data.tv, &(v->data.tv), sizeof(struct timeval)); - break; - case PMIX_TIME: - kv->type = OPAL_TIME; - memcpy(&kv->data.time, &(v->data.tv), sizeof(struct timeval)); - break; - case PMIX_STATUS: - kv->type = OPAL_STATUS; - memcpy(&kv->data.status, &(v->data.status), sizeof(opal_status_t)); - break; - case PMIX_PROC_RANK: - kv->type = OPAL_VPID; - kv->data.name.vpid = ext20_convert_rank(v->data.rank); - break; - case PMIX_PROC: - kv->type = OPAL_NAME; - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&kv->data.name.jobid, v->data.proc.nspace))) { - return ext20_convert_opalrc(rc); - } - kv->data.name.vpid = ext20_convert_rank(v->data.proc.rank); - break; - case PMIX_BYTE_OBJECT: - kv->type = OPAL_BYTE_OBJECT; - if (NULL != v->data.bo.bytes && 0 < v->data.bo.size) { - kv->data.bo.bytes = (uint8_t*)malloc(v->data.bo.size); - memcpy(kv->data.bo.bytes, v->data.bo.bytes, v->data.bo.size); - kv->data.bo.size = (int)v->data.bo.size; - } else { - kv->data.bo.bytes = NULL; - kv->data.bo.size = 0; - } - break; - case PMIX_PERSIST: - kv->type = OPAL_PERSIST; - kv->data.uint8 = ext20_convert_persist(v->data.persist); - break; - case PMIX_SCOPE: - kv->type = OPAL_SCOPE; - kv->data.uint8 = ext20_convert_scope(v->data.persist); - break; - case PMIX_DATA_RANGE: - kv->type = OPAL_DATA_RANGE; - kv->data.uint8 = ext20_convert_range(v->data.persist); - break; - case PMIX_PROC_STATE: - kv->type = OPAL_PROC_STATE; - /* the OPAL layer doesn't have any concept of proc state, - * so the ORTE layer is responsible for converting it */ - memcpy(&kv->data.uint8, &v->data.state, sizeof(uint8_t)); - break; - case PMIX_POINTER: - kv->type = OPAL_PTR; - kv->data.ptr = v->data.ptr; - break; - default: - /* silence warnings */ - rc = OPAL_ERROR; - break; - } - return rc; -} - -static void _reg_hdlr(int sd, short args, void *cbdata) -{ - ext20_threadshift_t *cd = (ext20_threadshift_t*)cbdata; - opal_ext20_event_chain_t *chain; - opal_ext20_single_event_t *sing = NULL; - opal_ext20_multi_event_t *multi = NULL; - opal_ext20_default_event_t *def = NULL; - opal_value_t *kv; - int i; - bool prepend = false; - size_t n; - - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s REGISTER HANDLER CODES %s", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), - (NULL == cd->event_codes) ? "NULL" : "NON-NULL"); - - if (NULL != cd->info) { - OPAL_LIST_FOREACH(kv, cd->info, opal_value_t) { - if (0 == strcmp(kv->key, OPAL_PMIX_EVENT_ORDER_PREPEND)) { - prepend = true; - break; - } - } - } - - if (NULL == cd->event_codes) { - /* this is a default handler */ - def = OBJ_NEW(opal_ext20_default_event_t); - def->handler = cd->evhandler; - def->index = mca_pmix_ext20_component.evindex; - if (prepend) { - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s PREPENDING TO DEFAULT EVENTS", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); - opal_list_prepend(&mca_pmix_ext20_component.default_events, &def->super); - } else { - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s APPENDING TO DEFAULT EVENTS", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); - opal_list_append(&mca_pmix_ext20_component.default_events, &def->super); - } - } else if (1 == opal_list_get_size(cd->event_codes)) { - /* single handler */ - sing = OBJ_NEW(opal_ext20_single_event_t); - kv = (opal_value_t*)opal_list_get_first(cd->event_codes); - sing->code = kv->data.integer; - sing->index = mca_pmix_ext20_component.evindex; - sing->handler = cd->evhandler; - if (prepend) { - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s PREPENDING TO SINGLE EVENTS WITH CODE %d", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), sing->code); - opal_list_prepend(&mca_pmix_ext20_component.single_events, &sing->super); - } else { - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s APPENDING TO SINGLE EVENTS WITH CODE %d", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), sing->code); - opal_list_append(&mca_pmix_ext20_component.single_events, &sing->super); - } - } else { - multi = OBJ_NEW(opal_ext20_multi_event_t); - multi->ncodes = opal_list_get_size(cd->event_codes); - multi->codes = (int*)malloc(multi->ncodes * sizeof(int)); - i=0; - OPAL_LIST_FOREACH(kv, cd->event_codes, opal_value_t) { - multi->codes[i] = kv->data.integer; - ++i; - } - multi->index = mca_pmix_ext20_component.evindex; - multi->handler = cd->evhandler; - if (prepend) { - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s PREPENDING TO MULTI EVENTS", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); - opal_list_prepend(&mca_pmix_ext20_component.multi_events, &multi->super); - } else { - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "%s APPENDING TO MULTI EVENTS", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME)); - opal_list_append(&mca_pmix_ext20_component.multi_events, &multi->super); - } - } - - /* release the caller */ - if (NULL != cd->cbfunc) { - cd->cbfunc(OPAL_SUCCESS, mca_pmix_ext20_component.evindex, cd->cbdata); - } - mca_pmix_ext20_component.evindex++; - - /* check if any matching notifications have been cached - only nondefault - * events will have been cached*/ - if (NULL == def) { - /* check single code registrations */ - if (NULL != sing) { - OPAL_LIST_FOREACH(chain, &mca_pmix_ext20_component.cache, opal_ext20_event_chain_t) { - if (sing->code == chain->status) { - opal_list_remove_item(&mca_pmix_ext20_component.cache, &chain->super); - chain->sing = sing; - sing->handler(chain->status, &chain->source, - chain->info, &chain->results, - progress_local_event_hdlr, (void*)chain); - OBJ_RELEASE(cd); - return; - } - } - } else if (NULL != multi) { - /* check for multi code registrations */ - OPAL_LIST_FOREACH(chain, &mca_pmix_ext20_component.cache, opal_ext20_event_chain_t) { - for (n=0; n < multi->ncodes; n++) { - if (multi->codes[n] == chain->status) { - opal_list_remove_item(&mca_pmix_ext20_component.cache, &chain->super); - chain->multi = multi; - multi->handler(chain->status, &chain->source, - chain->info, &chain->results, - progress_local_event_hdlr, (void*)chain); - OBJ_RELEASE(cd); - return; - } - } - } - } - } - - OBJ_RELEASE(cd); - return; -} -static void register_handler(opal_list_t *event_codes, - opal_list_t *info, - opal_pmix_notification_fn_t evhandler, - opal_pmix_evhandler_reg_cbfunc_t cbfunc, - void *cbdata) -{ - /* we must threadshift this request as we might not be in an event - * and we are going to access framework-global lists/objects */ - - OPAL_PMIX_THREADSHIFT(event_codes, info, evhandler, _reg_hdlr, cbfunc, cbdata); - return; -} - -static void _dereg_hdlr(int sd, short args, void *cbdata) -{ - ext20_threadshift_t *cd = (ext20_threadshift_t*)cbdata; - opal_ext20_single_event_t *sing; - opal_ext20_multi_event_t *multi; - opal_ext20_default_event_t *def; - - /* check the single events first */ - OPAL_LIST_FOREACH(sing, &mca_pmix_ext20_component.single_events, opal_ext20_single_event_t) { - if (cd->handler == sing->index) { - opal_list_remove_item(&mca_pmix_ext20_component.single_events, &sing->super); - OBJ_RELEASE(sing); - goto release; - } - } - /* check multi events */ - OPAL_LIST_FOREACH(multi, &mca_pmix_ext20_component.multi_events, opal_ext20_multi_event_t) { - if (cd->handler == multi->index) { - opal_list_remove_item(&mca_pmix_ext20_component.multi_events, &multi->super); - OBJ_RELEASE(multi); - goto release; - } - } - /* check default events */ - OPAL_LIST_FOREACH(def, &mca_pmix_ext20_component.default_events, opal_ext20_default_event_t) { - if (cd->handler == def->index) { - opal_list_remove_item(&mca_pmix_ext20_component.default_events, &def->super); - OBJ_RELEASE(def); - break; - } - } - - release: - if (NULL != cd->opcbfunc) { - cd->opcbfunc(OPAL_SUCCESS, cd->cbdata); - } - OBJ_RELEASE(cd); -} - -static void deregister_handler(size_t evhandler, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata) -{ - /* we must threadshift this request as we might not be in an event - * and we are going to access framework-global lists/objects */ - OPAL_PMIX_OP_THREADSHIFT(evhandler, _dereg_hdlr, cbfunc, cbdata); - return; -} - -static void _notify_event(int sd, short args, void *cbdata) -{ - ext20_threadshift_t *cd = (ext20_threadshift_t*)cbdata; - size_t i; - opal_ext20_single_event_t *sing; - opal_ext20_multi_event_t *multi; - opal_ext20_default_event_t *def; - opal_ext20_event_chain_t *chain; - - /* check the single events first */ - OPAL_LIST_FOREACH(sing, &mca_pmix_ext20_component.single_events, opal_ext20_single_event_t) { - if (cd->status == sing->code) { - /* found it - invoke the handler, pointing its - * callback function to our progression function */ - chain = OBJ_NEW(opal_ext20_event_chain_t); - chain->status = cd->status; - chain->range = ext20_convert_opalrange(cd->range); - chain->source = *(cd->source); - chain->info = cd->info; - chain->final_cbfunc = cd->opcbfunc; - chain->final_cbdata = cd->cbdata; - chain->sing = sing; - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "[%s] CALLING SINGLE EVHDLR FOR STATUS %d", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), chain->status); - sing->handler(chain->status, &chain->source, - chain->info, &chain->results, - progress_local_event_hdlr, (void*)chain); - OBJ_RELEASE(cd); - return; - } - } - /* check multi events */ - OPAL_LIST_FOREACH(multi, &mca_pmix_ext20_component.multi_events, opal_ext20_multi_event_t) { - for (i=0; i < multi->ncodes; i++) { - if (cd->status == multi->codes[i]) { - /* found it - invoke the handler, pointing its - * callback function to our progression function */ - chain = OBJ_NEW(opal_ext20_event_chain_t); - chain->status = cd->status; - chain->range = ext20_convert_opalrange(cd->range); - chain->source = *(cd->source); - chain->info = cd->info; - chain->final_cbfunc = cd->opcbfunc; - chain->final_cbdata = cd->cbdata; - chain->multi = multi; - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "[%s] CALLING MULTI EVHDLR FOR STATUS %d", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), chain->status); - multi->handler(chain->status, &chain->source, - chain->info, &chain->results, - progress_local_event_hdlr, (void*)chain); - OBJ_RELEASE(cd); - return; - } - } - } - /* check default events */ - if (0 < opal_list_get_size(&mca_pmix_ext20_component.default_events)) { - def = (opal_ext20_default_event_t*)opal_list_get_first(&mca_pmix_ext20_component.default_events); - chain = OBJ_NEW(opal_ext20_event_chain_t); - chain->status = cd->status; - chain->range = ext20_convert_opalrange(cd->range); - chain->source = *(cd->source); - chain->info = cd->info; - chain->final_cbfunc = cd->opcbfunc; - chain->final_cbdata = cd->cbdata; - chain->def = def; - opal_output_verbose(2, opal_pmix_base_framework.framework_output, - "[%s] CALLING DEFAULT EVHDLR FOR STATUS %d", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), chain->status); - def->handler(chain->status, &chain->source, - chain->info, &chain->results, - progress_local_event_hdlr, (void*)chain); - OBJ_RELEASE(cd); - return; - } - - /* if we get here, then there are no registered event handlers */ - if (NULL != cd->opcbfunc) { - cd->opcbfunc(OPAL_ERR_NOT_FOUND, cd->cbdata); - } - OBJ_RELEASE(cd); - return; -} - -static int notify_event(int status, - const opal_process_name_t *source, - opal_pmix_data_range_t range, - opal_list_t *info, - opal_pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - /* we must threadshift this request as we might not be in an event - * and we are going to access framework-global lists/objects */ - OPAL_PMIX_NOTIFY_THREADSHIFT(status, source, range, info, _notify_event, cbfunc, cbdata); - return OPAL_SUCCESS; -} - -/**** INSTANTIATE INTERNAL CLASSES ****/ -OBJ_CLASS_INSTANCE(opal_ext20_jobid_trkr_t, - opal_list_item_t, - NULL, NULL); - -OBJ_CLASS_INSTANCE(opal_ext20_single_event_t, - opal_list_item_t, - NULL, NULL); - -static void mtevcon(opal_ext20_multi_event_t *p) -{ - p->codes = NULL; - p->ncodes = 0; -} -static void mtevdes(opal_ext20_multi_event_t *p) -{ - if (NULL != p->codes) { - free(p->codes); - } -} -OBJ_CLASS_INSTANCE(opal_ext20_multi_event_t, - opal_list_item_t, - mtevcon, mtevdes); - -OBJ_CLASS_INSTANCE(opal_ext20_default_event_t, - opal_list_item_t, - NULL, NULL); - -static void chcon(opal_ext20_event_chain_t *p) -{ - p->nondefault = false; - p->info = NULL; - OBJ_CONSTRUCT(&p->results, opal_list_t); - p->sing = NULL; - p->multi = NULL; - p->def = NULL; - p->final_cbfunc = NULL; - p->final_cbdata = NULL; -} -static void chdes(opal_ext20_event_chain_t *p) -{ - OPAL_LIST_DESTRUCT(&p->results); -} -OBJ_CLASS_INSTANCE(opal_ext20_event_chain_t, - opal_list_item_t, - chcon, chdes); - -static void opcon(ext20_opcaddy_t *p) -{ - memset(&p->p, 0, sizeof(pmix_proc_t)); - p->procs = NULL; - p->nprocs = 0; - p->error_procs = NULL; - p->nerror_procs = 0; - p->info = NULL; - p->ninfo = 0; - p->apps = NULL; - p->sz = 0; - p->active = false; - p->opcbfunc = NULL; - p->mdxcbfunc = NULL; - p->valcbfunc = NULL; - p->lkcbfunc = NULL; - p->spcbfunc = NULL; - p->cbdata = NULL; -} -static void opdes(ext20_opcaddy_t *p) -{ - if (NULL != p->procs) { - PMIX_PROC_FREE(p->procs, p->nprocs); - } - if (NULL != p->error_procs) { - PMIX_PROC_FREE(p->error_procs, p->nerror_procs); - } - if (NULL != p->info) { - PMIX_INFO_FREE(p->info, p->sz); - } - if (NULL != p->apps) { - PMIX_APP_FREE(p->apps, p->sz); - } -} -OBJ_CLASS_INSTANCE(ext20_opcaddy_t, - opal_object_t, - opcon, opdes); - -static void ocadcon(ext20_opalcaddy_t *p) -{ - OBJ_CONSTRUCT(&p->procs, opal_list_t); - OBJ_CONSTRUCT(&p->info, opal_list_t); - OBJ_CONSTRUCT(&p->apps, opal_list_t); - p->opcbfunc = NULL; - p->dmdxfunc = NULL; - p->mdxcbfunc = NULL; - p->lkupcbfunc = NULL; - p->spwncbfunc = NULL; - p->cbdata = NULL; - p->odmdxfunc = NULL; - p->infocbfunc = NULL; - p->toolcbfunc = NULL; - p->ocbdata = NULL; -} -static void ocaddes(ext20_opalcaddy_t *p) -{ - OPAL_LIST_DESTRUCT(&p->procs); - OPAL_LIST_DESTRUCT(&p->info); - OPAL_LIST_DESTRUCT(&p->apps); -} -OBJ_CLASS_INSTANCE(ext20_opalcaddy_t, - opal_object_t, - ocadcon, ocaddes); - -static void tscon(ext20_threadshift_t *p) -{ - p->active = false; - p->source = NULL; - p->event_codes = NULL; - p->info = NULL; - p->evhandler = NULL; - p->nondefault = false; - p->cbfunc = NULL; - p->opcbfunc = NULL; - p->cbdata = NULL; -} -OBJ_CLASS_INSTANCE(ext20_threadshift_t, - opal_object_t, - tscon, NULL); diff --git a/opal/mca/pmix/ext20/pmix_ext20.h b/opal/mca/pmix/ext20/pmix_ext20.h deleted file mode 100644 index 77dfb299556..00000000000 --- a/opal/mca/pmix/ext20/pmix_ext20.h +++ /dev/null @@ -1,323 +0,0 @@ -/* - * Copyright (c) 2014-2016 Intel, Inc. All rights reserved. - * Copyright (c) 2014-2015 Mellanox Technologies, Inc. - * All rights reserved. - * Copyright (c) 2016 Research Organization for Information Science - * and Technology (RIST). All rights reserved. - * $COPYRIGHT$ - * - * Additional copyrights may follow - * - * $HEADER$ - */ - -#ifndef MCA_PMIX_PMIX2X_H -#define MCA_PMIX_PMIX2X_H - -#include "opal_config.h" - -#ifdef HAVE_SYS_SOCKET_H -#include -#endif -#ifdef HAVE_SYS_UN_H -#include -#endif - -#include "opal/class/opal_list.h" -#include "opal/mca/mca.h" -#include "opal/mca/event/event.h" -#include "opal/util/proc.h" - -#include "opal/mca/pmix/pmix.h" -#include "pmix_server.h" -#include "pmix_common.h" - -BEGIN_C_DECLS - -typedef struct { - opal_pmix_base_component_t super; - opal_list_t jobids; - bool native_launch; - size_t evindex; - opal_list_t single_events; - opal_list_t multi_events; - opal_list_t default_events; - int cache_size; - opal_list_t cache; -} mca_pmix_ext20_component_t; - -OPAL_DECLSPEC extern mca_pmix_ext20_component_t mca_pmix_ext20_component; - -OPAL_DECLSPEC extern const opal_pmix_base_module_t opal_pmix_ext20_module; - -/**** INTERNAL OBJECTS ****/ -typedef struct { - opal_list_item_t super; - opal_jobid_t jobid; - char nspace[PMIX_MAX_NSLEN + 1]; -} opal_ext20_jobid_trkr_t; -OBJ_CLASS_DECLARATION(opal_ext20_jobid_trkr_t); - -typedef struct { - opal_list_item_t super; - size_t index; - int code; - opal_pmix_notification_fn_t handler; -} opal_ext20_single_event_t; -OBJ_CLASS_DECLARATION(opal_ext20_single_event_t); - -typedef struct { - opal_list_item_t super; - size_t index; - int *codes; - size_t ncodes; - opal_pmix_notification_fn_t handler; -} opal_ext20_multi_event_t; -OBJ_CLASS_DECLARATION(opal_ext20_multi_event_t); - -typedef struct { - opal_list_item_t super; - size_t index; - opal_pmix_notification_fn_t handler; -} opal_ext20_default_event_t; -OBJ_CLASS_DECLARATION(opal_ext20_default_event_t); - -typedef struct { - opal_list_item_t super; - int status; - bool nondefault; - opal_process_name_t source; - pmix_data_range_t range; - opal_list_t *info; - opal_list_t results; - opal_ext20_single_event_t *sing; - opal_ext20_multi_event_t *multi; - opal_ext20_default_event_t *def; - opal_pmix_op_cbfunc_t final_cbfunc; - void *final_cbdata; -} opal_ext20_event_chain_t; -OBJ_CLASS_DECLARATION(opal_ext20_event_chain_t); - -typedef struct { - opal_object_t super; - pmix_status_t status; - pmix_proc_t p; - pmix_proc_t *procs; - size_t nprocs; - pmix_proc_t *error_procs; - size_t nerror_procs; - pmix_info_t *info; - size_t ninfo; - pmix_app_t *apps; - size_t sz; - volatile bool active; - opal_pmix_op_cbfunc_t opcbfunc; - opal_pmix_modex_cbfunc_t mdxcbfunc; - opal_pmix_value_cbfunc_t valcbfunc; - opal_pmix_lookup_cbfunc_t lkcbfunc; - opal_pmix_spawn_cbfunc_t spcbfunc; - void *cbdata; -} ext20_opcaddy_t; -OBJ_CLASS_DECLARATION(ext20_opcaddy_t); - -typedef struct { - opal_object_t super; - opal_list_t procs; - opal_list_t info; - opal_list_t apps; - pmix_op_cbfunc_t opcbfunc; - pmix_dmodex_response_fn_t dmdxfunc; - pmix_modex_cbfunc_t mdxcbfunc; - pmix_lookup_cbfunc_t lkupcbfunc; - pmix_spawn_cbfunc_t spwncbfunc; - pmix_info_cbfunc_t infocbfunc; - pmix_tool_connection_cbfunc_t toolcbfunc; - void *cbdata; - opal_pmix_release_cbfunc_t odmdxfunc; - void *ocbdata; -} ext20_opalcaddy_t; -OBJ_CLASS_DECLARATION(ext20_opalcaddy_t); - -typedef struct { - opal_object_t super; - opal_event_t ev; - volatile bool active; - size_t id; - int status; - opal_process_name_t pname; - opal_jobid_t jobid; - const opal_process_name_t *source; - opal_pmix_data_range_t range; - bool nondefault; - size_t handler; - opal_list_t *event_codes; - opal_list_t *info; - opal_pmix_notification_fn_t evhandler; - opal_pmix_evhandler_reg_cbfunc_t cbfunc; - opal_pmix_op_cbfunc_t opcbfunc; - void *cbdata; -} ext20_threadshift_t; -OBJ_CLASS_DECLARATION(ext20_threadshift_t); - -#define OPAL_PMIX_OPCD_THREADSHIFT(i, s, sr, if, nif, fn, cb, cd) \ - do { \ - ext20_opalcaddy_t *_cd; \ - _cd = OBJ_NEW(ext20_opalcaddy_t); \ - _cd->id = (i); \ - _cd->status = (s); \ - _cd->source = (sr); \ - _cd->info = (i); \ - _cd->evcbfunc = (cb); \ - _cd->cbdata = (cd); \ - event_assign(&((_cd)->ev), opal_pmix_base.evbase, \ - -1, EV_WRITE, (fn), (_cd)); \ - event_active(&((_cd)->ev), EV_WRITE, 1); \ - } while(0) - -#define OPAL_PMIX_OP_THREADSHIFT(e, fn, cb, cd) \ - do { \ - ext20_threadshift_t *_cd; \ - _cd = OBJ_NEW(ext20_threadshift_t); \ - _cd->handler = (e); \ - _cd->opcbfunc = (cb); \ - _cd->cbdata = (cd); \ - event_assign(&((_cd)->ev), opal_pmix_base.evbase, \ - -1, EV_WRITE, (fn), (_cd)); \ - event_active(&((_cd)->ev), EV_WRITE, 1); \ - } while(0) - -#define OPAL_PMIX_THREADSHIFT(e, i, eh, fn, cb, cd) \ - do { \ - ext20_threadshift_t *_cd; \ - _cd = OBJ_NEW(ext20_threadshift_t); \ - _cd->event_codes = (e); \ - _cd->info = (i); \ - _cd->evhandler = (eh); \ - _cd->cbfunc = (cb); \ - _cd->cbdata = (cd); \ - event_assign(&((_cd)->ev), opal_pmix_base.evbase, \ - -1, EV_WRITE, (fn), (_cd)); \ - event_active(&((_cd)->ev), EV_WRITE, 1); \ - } while(0) - -#define OPAL_PMIX_NOTIFY_THREADSHIFT(s, sr, r, i, fn, cb, cd) \ - do { \ - ext20_threadshift_t *_cd; \ - _cd = OBJ_NEW(ext20_threadshift_t); \ - _cd->status = (s); \ - _cd->source = (sr); \ - _cd->range = (r); \ - _cd->info = (i); \ - _cd->opcbfunc = (cb); \ - _cd->cbdata = (cd); \ - event_assign(&((_cd)->ev), opal_pmix_base.evbase, \ - -1, EV_WRITE, (fn), (_cd)); \ - event_active(&((_cd)->ev), EV_WRITE, 1); \ - } while(0) - -/**** CLIENT FUNCTIONS ****/ -OPAL_MODULE_DECLSPEC int ext20_client_init(void); -OPAL_MODULE_DECLSPEC int ext20_client_finalize(void); -OPAL_MODULE_DECLSPEC int ext20_initialized(void); -OPAL_MODULE_DECLSPEC int ext20_abort(int flag, const char *msg, - opal_list_t *procs); -OPAL_MODULE_DECLSPEC int ext20_commit(void); -OPAL_MODULE_DECLSPEC int ext20_fence(opal_list_t *procs, int collect_data); -OPAL_MODULE_DECLSPEC int ext20_fencenb(opal_list_t *procs, int collect_data, - opal_pmix_op_cbfunc_t cbfunc, void *cbdata); -OPAL_MODULE_DECLSPEC int ext20_put(opal_pmix_scope_t scope, - opal_value_t *val); -OPAL_MODULE_DECLSPEC int ext20_get(const opal_process_name_t *proc, const char *key, - opal_list_t *info, opal_value_t **val); -OPAL_MODULE_DECLSPEC int ext20_getnb(const opal_process_name_t *proc, const char *key, - opal_list_t *info, - opal_pmix_value_cbfunc_t cbfunc, void *cbdata); -OPAL_MODULE_DECLSPEC int ext20_publish(opal_list_t *info); -OPAL_MODULE_DECLSPEC int ext20_publishnb(opal_list_t *info, - opal_pmix_op_cbfunc_t cbfunc, void *cbdata); -OPAL_MODULE_DECLSPEC int ext20_lookup(opal_list_t *data, opal_list_t *info); -OPAL_MODULE_DECLSPEC int ext20_lookupnb(char **keys, opal_list_t *info, - opal_pmix_lookup_cbfunc_t cbfunc, void *cbdata); -OPAL_MODULE_DECLSPEC int ext20_unpublish(char **keys, opal_list_t *info); -OPAL_MODULE_DECLSPEC int ext20_unpublishnb(char **keys, opal_list_t *info, - opal_pmix_op_cbfunc_t cbfunc, void *cbdata); -OPAL_MODULE_DECLSPEC int ext20_spawn(opal_list_t *job_info, opal_list_t *apps, opal_jobid_t *jobid); -OPAL_MODULE_DECLSPEC int ext20_spawnnb(opal_list_t *job_info, opal_list_t *apps, - opal_pmix_spawn_cbfunc_t cbfunc, void *cbdata); -OPAL_MODULE_DECLSPEC int ext20_connect(opal_list_t *procs); -OPAL_MODULE_DECLSPEC int ext20_connectnb(opal_list_t *procs, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata); -OPAL_MODULE_DECLSPEC int ext20_disconnect(opal_list_t *procs); -OPAL_MODULE_DECLSPEC int ext20_disconnectnb(opal_list_t *procs, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata); -OPAL_MODULE_DECLSPEC int ext20_resolve_peers(const char *nodename, opal_jobid_t jobid, - opal_list_t *procs); -OPAL_MODULE_DECLSPEC int ext20_resolve_nodes(opal_jobid_t jobid, char **nodelist); - -/**** COMMON FUNCTIONS ****/ -OPAL_MODULE_DECLSPEC int ext20_store_local(const opal_process_name_t *proc, - opal_value_t *val); - -/**** SERVER SOUTHBOUND FUNCTIONS ****/ -OPAL_MODULE_DECLSPEC int ext20_server_init(opal_pmix_server_module_t *module, - opal_list_t *info); -OPAL_MODULE_DECLSPEC int ext20_server_finalize(void); -OPAL_MODULE_DECLSPEC int ext20_server_gen_regex(const char *input, char **regex); -OPAL_MODULE_DECLSPEC int ext20_server_gen_ppn(const char *input, char **ppn); -OPAL_MODULE_DECLSPEC int ext20_server_register_nspace(opal_jobid_t jobid, - int nlocalprocs, - opal_list_t *info, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata); -OPAL_MODULE_DECLSPEC void ext20_server_deregister_nspace(opal_jobid_t jobid, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata); -OPAL_MODULE_DECLSPEC int ext20_server_register_client(const opal_process_name_t *proc, - uid_t uid, gid_t gid, - void *server_object, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata); -OPAL_MODULE_DECLSPEC void ext20_server_deregister_client(const opal_process_name_t *proc, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata); -OPAL_MODULE_DECLSPEC int ext20_server_setup_fork(const opal_process_name_t *proc, char ***env); -OPAL_MODULE_DECLSPEC int ext20_server_dmodex(const opal_process_name_t *proc, - opal_pmix_modex_cbfunc_t cbfunc, void *cbdata); -OPAL_MODULE_DECLSPEC int ext20_server_notify_event(int status, - const opal_process_name_t *source, - opal_list_t *info, - opal_pmix_op_cbfunc_t cbfunc, void *cbdata); - - -/**** COMPONENT UTILITY FUNCTIONS ****/ -OPAL_MODULE_DECLSPEC void ext20_event_hdlr(size_t evhdlr_registration_id, - pmix_status_t status, const pmix_proc_t *source, - pmix_info_t info[], size_t ninfo, - pmix_info_t results[], size_t nresults, - pmix_event_notification_cbfunc_fn_t cbfunc, - void *cbdata); -OPAL_MODULE_DECLSPEC pmix_status_t ext20_convert_opalrc(int rc); -OPAL_MODULE_DECLSPEC int ext20_convert_rc(pmix_status_t rc); - -OPAL_MODULE_DECLSPEC opal_vpid_t ext20_convert_rank(int rank); -OPAL_MODULE_DECLSPEC pmix_rank_t ext20_convert_opalrank(opal_vpid_t vpid); - -OPAL_MODULE_DECLSPEC opal_pmix_scope_t ext20_convert_scope(pmix_scope_t scope); -OPAL_MODULE_DECLSPEC pmix_scope_t ext20_convert_opalscope(opal_pmix_scope_t scope); - -OPAL_MODULE_DECLSPEC pmix_data_range_t ext20_convert_opalrange(opal_pmix_data_range_t range); -OPAL_MODULE_DECLSPEC opal_pmix_data_range_t ext20_convert_range(pmix_data_range_t range); - -OPAL_MODULE_DECLSPEC opal_pmix_persistence_t ext20_convert_persist(pmix_persistence_t scope); -OPAL_MODULE_DECLSPEC pmix_persistence_t ext20_convert_opalpersist(opal_pmix_persistence_t scope); - -OPAL_MODULE_DECLSPEC void ext20_value_load(pmix_value_t *v, - opal_value_t *kv); -OPAL_MODULE_DECLSPEC int ext20_value_unload(opal_value_t *kv, - const pmix_value_t *v); - -END_C_DECLS - -#endif /* MCA_PMIX_EXTERNAL_H */ diff --git a/opal/mca/pmix/ext20/pmix_ext20_client.c b/opal/mca/pmix/ext20/pmix_ext20_client.c deleted file mode 100644 index 617b35ad503..00000000000 --- a/opal/mca/pmix/ext20/pmix_ext20_client.c +++ /dev/null @@ -1,1283 +0,0 @@ -/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */ -/* - * Copyright (c) 2014-2016 Intel, Inc. All rights reserved. - * Copyright (c) 2014-2016 Research Organization for Information Science - * and Technology (RIST). All rights reserved. - * Copyright (c) 2014-2015 Mellanox Technologies, Inc. - * All rights reserved. - * Copyright (c) 2016 Cisco Systems, Inc. All rights reserved. - * Copyright (c) 2016 Los Alamos National Security, LLC. All rights - * reserved. - * $COPYRIGHT$ - * - * Additional copyrights may follow - * - * $HEADER$ - */ - -#include "opal_config.h" -#include "opal/constants.h" -#include "opal/types.h" - -#ifdef HAVE_STRING_H -#include -#endif -#ifdef HAVE_UNISTD_H -#include -#endif - -#include "opal/util/argv.h" -#include "opal/util/proc.h" - -#include "opal/mca/pmix/base/base.h" -#include "pmix_ext20.h" -#include "pmix.h" - -static pmix_proc_t my_proc; -static char *dbgvalue=NULL; -static size_t errhdler_ref = 0; - -#define PMIX_WAIT_FOR_COMPLETION(a) \ - do { \ - while ((a)) { \ - usleep(10); \ - } \ - } while (0) - - -static void errreg_cbfunc (pmix_status_t status, - size_t errhandler_ref, - void *cbdata) -{ - errhdler_ref = errhandler_ref; - opal_output_verbose(5, opal_pmix_base_framework.framework_output, - "PMIX client errreg_cbfunc - error handler registered status=%d, reference=%lu", - status, (unsigned long)errhandler_ref); -} - -int ext20_client_init(void) -{ - opal_process_name_t pname; - pmix_status_t rc; - int dbg; - opal_ext20_jobid_trkr_t *job; - - opal_output_verbose(1, opal_pmix_base_framework.framework_output, - "PMIx_client init"); - - if (0 < (dbg = opal_output_get_verbosity(opal_pmix_base_framework.framework_output))) { - asprintf(&dbgvalue, "PMIX_DEBUG=%d", dbg); - putenv(dbgvalue); - } - - rc = PMIx_Init(&my_proc, NULL, 0); - if (PMIX_SUCCESS != rc) { - return ext20_convert_rc(rc); - } - - /* store our jobid and rank */ - if (NULL != getenv(OPAL_MCA_PREFIX"orte_launch")) { - /* if we were launched by the OMPI RTE, then - * the jobid is in a special format - so get it */ - mca_pmix_ext20_component.native_launch = true; - opal_convert_string_to_jobid(&pname.jobid, my_proc.nspace); - } else { - /* we were launched by someone else, so make the - * jobid just be the hash of the nspace */ - OPAL_HASH_JOBID(my_proc.nspace, pname.jobid); - } - /* insert this into our list of jobids - it will be the - * first, and so we'll check it first */ - job = OBJ_NEW(opal_ext20_jobid_trkr_t); - (void)strncpy(job->nspace, my_proc.nspace, PMIX_MAX_NSLEN); - job->jobid = pname.jobid; - opal_list_append(&mca_pmix_ext20_component.jobids, &job->super); - - pname.vpid = ext20_convert_rank(my_proc.rank); - opal_proc_set_name(&pname); - - /* register the default event handler */ - PMIx_Register_event_handler(NULL, 0, NULL, 0, ext20_event_hdlr, errreg_cbfunc, NULL); - return OPAL_SUCCESS; - -} - -int ext20_client_finalize(void) -{ - pmix_status_t rc; - - opal_output_verbose(1, opal_pmix_base_framework.framework_output, - "PMIx_client finalize"); - - /* deregister the default event handler */ - PMIx_Deregister_event_handler(errhdler_ref, NULL, NULL); - - rc = PMIx_Finalize(NULL, 0); - return ext20_convert_rc(rc); -} - -int ext20_initialized(void) -{ - opal_output_verbose(1, opal_pmix_base_framework.framework_output, - "PMIx_client initialized"); - - return PMIx_Initialized(); -} - -int ext20_abort(int flag, const char *msg, - opal_list_t *procs) -{ - pmix_status_t rc; - pmix_proc_t *parray=NULL; - size_t n, cnt=0; - opal_namelist_t *ptr; - opal_ext20_jobid_trkr_t *job, *jptr; - - opal_output_verbose(1, opal_pmix_base_framework.framework_output, - "PMIx_client abort"); - - /* convert the list of procs to an array - * of pmix_proc_t */ - if (NULL != procs && 0 < (cnt = opal_list_get_size(procs))) { - PMIX_PROC_CREATE(parray, cnt); - n=0; - OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) { - /* look thru our list of jobids and find the - * corresponding nspace */ - job = NULL; - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == ptr->name.jobid) { - job = jptr; - break; - } - } - if (NULL == job) { - PMIX_PROC_FREE(parray, cnt); - return OPAL_ERR_NOT_FOUND; - } - (void)strncpy(parray[n].nspace, job->nspace, PMIX_MAX_NSLEN); - parray[n].rank = ext20_convert_opalrank(ptr->name.vpid); - ++n; - } - } - - /* call the library abort */ - rc = PMIx_Abort(flag, msg, parray, cnt); - - /* release the array */ - PMIX_PROC_FREE(parray, cnt); - - return ext20_convert_rc(rc); -} - -int ext20_store_local(const opal_process_name_t *proc, opal_value_t *val) -{ - pmix_value_t kv; - pmix_status_t rc; - pmix_proc_t p; - opal_ext20_jobid_trkr_t *job, *jptr; - - /* we must threadshift this request as we might not be in an event - * and we are going to access framework-global lists/objects */ - - if (NULL != proc) { - /* look thru our list of jobids and find the - * corresponding nspace */ - job = NULL; - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == proc->jobid) { - job = jptr; - break; - } - } - if (NULL == job) { - OPAL_ERROR_LOG(OPAL_ERR_NOT_FOUND); - return OPAL_ERR_NOT_FOUND; - } - (void)strncpy(p.nspace, job->nspace, PMIX_MAX_NSLEN); - p.rank = ext20_convert_opalrank(proc->vpid); - } else { - /* use our name */ - (void)strncpy(p.nspace, my_proc.nspace, PMIX_MAX_NSLEN); - p.rank = ext20_convert_opalrank(OPAL_PROC_MY_NAME.vpid); - } - - PMIX_VALUE_CONSTRUCT(&kv); - ext20_value_load(&kv, val); - - rc = PMIx_Store_internal(&p, val->key, &kv); - PMIX_VALUE_DESTRUCT(&kv); - - return ext20_convert_rc(rc); -} - -int ext20_commit(void) -{ - pmix_status_t rc; - - rc = PMIx_Commit(); - return ext20_convert_rc(rc); -} - -static void opcbfunc(pmix_status_t status, void *cbdata) -{ - ext20_opcaddy_t *op = (ext20_opcaddy_t*)cbdata; - - if (NULL != op->opcbfunc) { - op->opcbfunc(ext20_convert_rc(status), op->cbdata); - } - OBJ_RELEASE(op); -} - -int ext20_fence(opal_list_t *procs, int collect_data) -{ - pmix_status_t rc; - pmix_proc_t *parray=NULL; - size_t n, cnt=0; - opal_namelist_t *ptr; - pmix_info_t info, *iptr; - opal_ext20_jobid_trkr_t *job, *jptr; - - opal_output_verbose(1, opal_pmix_base_framework.framework_output, - "PMIx_client fence"); - - /* convert the list of procs to an array - * of pmix_proc_t */ - if (NULL != procs && 0 < (cnt = opal_list_get_size(procs))) { - PMIX_PROC_CREATE(parray, cnt); - n=0; - OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) { - /* look thru our list of jobids and find the - * corresponding nspace */ - job = NULL; - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == ptr->name.jobid) { - job = jptr; - break; - } - } - if (NULL == job) { - return OPAL_ERR_NOT_FOUND; - } - (void)strncpy(parray[n].nspace, job->nspace, PMIX_MAX_NSLEN); - parray[n].rank = ext20_convert_opalrank(ptr->name.vpid); - ++n; - } - } - if (collect_data) { - PMIX_INFO_CONSTRUCT(&info); - (void)strncpy(info.key, PMIX_COLLECT_DATA, PMIX_MAX_KEYLEN); - info.value.type = PMIX_BOOL; - info.value.data.flag = true; - iptr = &info; - n = 1; - } else { - iptr = NULL; - n = 0; - } - - /* call the library function */ - rc = PMIx_Fence(parray, cnt, iptr, n); - - /* release the array */ - PMIX_PROC_FREE(parray, cnt); - if (NULL != iptr) { - PMIX_INFO_DESTRUCT(&info); - } - - return ext20_convert_rc(rc); - -} - -int ext20_fencenb(opal_list_t *procs, int collect_data, - opal_pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - pmix_status_t rc; - pmix_proc_t *parray=NULL; - size_t n, cnt=0; - opal_namelist_t *ptr; - ext20_opcaddy_t *op; - pmix_info_t info, *iptr; - opal_ext20_jobid_trkr_t *job, *jptr; - - /* we must threadshift this request as we might not be in an event - * and we are going to access framework-global lists/objects */ - - opal_output_verbose(1, opal_pmix_base_framework.framework_output, - "PMIx_client fence_nb"); - - /* convert the list of procs to an array - * of pmix_proc_t */ - if (NULL != procs && 0 < (cnt = opal_list_get_size(procs))) { - PMIX_PROC_CREATE(parray, cnt); - n=0; - OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) { - /* look thru our list of jobids and find the - * corresponding nspace */ - job = NULL; - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == ptr->name.jobid) { - job = jptr; - break; - } - } - if (NULL == job) { - PMIX_PROC_FREE(parray, cnt); - return OPAL_ERR_NOT_FOUND; - } - (void)strncpy(parray[n].nspace, job->nspace, PMIX_MAX_NSLEN); - parray[n].rank = ext20_convert_opalrank(ptr->name.vpid); - ++n; - } - } - - if (collect_data) { - PMIX_INFO_CONSTRUCT(&info); - (void)strncpy(info.key, PMIX_COLLECT_DATA, PMIX_MAX_KEYLEN); - info.value.type = PMIX_BOOL; - info.value.data.flag = true; - iptr = &info; - n = 1; - } else { - iptr = NULL; - n = 0; - } - - /* create the caddy */ - op = OBJ_NEW(ext20_opcaddy_t); - op->opcbfunc = cbfunc; - op->cbdata = cbdata; - op->procs = parray; - op->nprocs = cnt; - - /* call the library function */ - rc = PMIx_Fence_nb(parray, cnt, iptr, n, opcbfunc, op); - if (PMIX_SUCCESS != rc) { - OBJ_RELEASE(op); - } - - return ext20_convert_rc(rc); - -} - -int ext20_put(opal_pmix_scope_t opal_scope, - opal_value_t *val) -{ - pmix_value_t kv; - pmix_scope_t pmix_scope = ext20_convert_opalscope(opal_scope); - pmix_status_t rc; - - opal_output_verbose(1, opal_pmix_base_framework.framework_output, - "PMIx_client put"); - - PMIX_VALUE_CONSTRUCT(&kv); - ext20_value_load(&kv, val); - - rc = PMIx_Put(pmix_scope, val->key, &kv); - PMIX_VALUE_DESTRUCT(&kv); - return ext20_convert_rc(rc); -} - -int ext20_get(const opal_process_name_t *proc, const char *key, - opal_list_t *info, opal_value_t **val) -{ - int ret; - pmix_value_t *kv; - pmix_status_t rc; - pmix_proc_t p, *pptr; - size_t ninfo, n; - pmix_info_t *pinfo; - opal_value_t *ival; - opal_ext20_jobid_trkr_t *job, *jptr; - - opal_output_verbose(1, opal_pmix_base_framework.framework_output, - "%s PMIx_client get on proc %s key %s", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), - (NULL == proc) ? "NULL" : OPAL_NAME_PRINT(*proc), key); - - /* prep default response */ - *val = NULL; - if (NULL != proc) { - /* look thru our list of jobids and find the - * corresponding nspace */ - job = NULL; - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == proc->jobid) { - job = jptr; - break; - } - } - if (NULL == job) { - return OPAL_ERR_NOT_FOUND; - } - (void)strncpy(p.nspace, job->nspace, PMIX_MAX_NSLEN); - p.rank = ext20_convert_opalrank(proc->vpid); - pptr = &p; - } else { - /* if they are asking for our jobid, then return it */ - if (0 == strcmp(key, OPAL_PMIX_JOBID)) { - (*val) = OBJ_NEW(opal_value_t); - (*val)->type = OPAL_UINT32; - (*val)->data.uint32 = OPAL_PROC_MY_NAME.jobid; - return OPAL_SUCCESS; - } else if (0 == strcmp(key, OPAL_PMIX_RANK)) { - (*val) = OBJ_NEW(opal_value_t); - (*val)->type = OPAL_INT; - (*val)->data.integer = ext20_convert_rank(my_proc.rank); - return OPAL_SUCCESS; - } - pptr = NULL; - } - - if (NULL != info) { - ninfo = opal_list_get_size(info); - if (0 < ninfo) { - PMIX_INFO_CREATE(pinfo, ninfo); - n=0; - OPAL_LIST_FOREACH(ival, info, opal_value_t) { - (void)strncpy(pinfo[n].key, ival->key, PMIX_MAX_KEYLEN); - ext20_value_load(&pinfo[n].value, ival); - ++n; - } - } else { - pinfo = NULL; - } - } else { - pinfo = NULL; - ninfo = 0; - } - - /* pass the request down */ - rc = PMIx_Get(pptr, key, pinfo, ninfo, &kv); - if (PMIX_SUCCESS == rc) { - if (NULL == kv) { - ret = OPAL_SUCCESS; - } else { - *val = OBJ_NEW(opal_value_t); - ret = ext20_value_unload(*val, kv); - PMIX_VALUE_FREE(kv, 1); - } - } else { - ret = ext20_convert_rc(rc); - } - PMIX_INFO_FREE(pinfo, ninfo); - return ret; -} - -static void val_cbfunc(pmix_status_t status, - pmix_value_t *kv, void *cbdata) -{ - ext20_opcaddy_t *op = (ext20_opcaddy_t*)cbdata; - int rc; - opal_value_t val, *v=NULL; - - rc = ext20_convert_opalrc(status); - if (PMIX_SUCCESS == status && NULL != kv) { - rc = ext20_value_unload(&val, kv); - v = &val; - } - - if (NULL != op->valcbfunc) { - op->valcbfunc(rc, v, op->cbdata); - } - OBJ_RELEASE(op); -} - -int ext20_getnb(const opal_process_name_t *proc, const char *key, - opal_list_t *info, - opal_pmix_value_cbfunc_t cbfunc, void *cbdata) -{ - ext20_opcaddy_t *op; - pmix_status_t rc; - size_t n; - opal_value_t *ival; - opal_ext20_jobid_trkr_t *job, *jptr; - - /* we must threadshift this request as we might not be in an event - * and we are going to access shared lists/objects */ - - opal_output_verbose(1, opal_pmix_base_framework.framework_output, - "%s PMIx_client get_nb on proc %s key %s", - OPAL_NAME_PRINT(OPAL_PROC_MY_NAME), - (NULL == proc) ? "NULL" : OPAL_NAME_PRINT(*proc), key); - - /* create the caddy */ - op = OBJ_NEW(ext20_opcaddy_t); - op->valcbfunc = cbfunc; - op->cbdata = cbdata; - - if (NULL != proc) { - /* look thru our list of jobids and find the - * corresponding nspace */ - job = NULL; - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == proc->jobid) { - job = jptr; - break; - } - } - if (NULL == job) { - return OPAL_ERR_NOT_FOUND; - } - (void)strncpy(op->p.nspace, job->nspace, PMIX_MAX_NSLEN); - op->p.rank = ext20_convert_opalrank(proc->vpid); - } else { - (void)strncpy(op->p.nspace, my_proc.nspace, PMIX_MAX_NSLEN); - op->p.rank = ext20_convert_rank(PMIX_RANK_WILDCARD); - } - - if (NULL != info) { - op->sz = opal_list_get_size(info); - if (0 < op->sz) { - PMIX_INFO_CREATE(op->info, op->sz); - n=0; - OPAL_LIST_FOREACH(ival, info, opal_value_t) { - (void)strncpy(op->info[n].key, ival->key, PMIX_MAX_KEYLEN); - ext20_value_load(&op->info[n].value, ival); - ++n; - } - } - } - - /* call the library function */ - rc = PMIx_Get_nb(&op->p, key, op->info, op->sz, val_cbfunc, op); - if (PMIX_SUCCESS != rc) { - OBJ_RELEASE(op); - } - - return ext20_convert_rc(rc); -} - -int ext20_publish(opal_list_t *info) -{ - pmix_info_t *pinfo; - pmix_status_t ret; - opal_value_t *iptr; - size_t sz, n; - - opal_output_verbose(1, opal_pmix_base_framework.framework_output, - "PMIx_client publish"); - - if (NULL == info) { - return OPAL_ERR_BAD_PARAM; - } - - sz = opal_list_get_size(info); - if (0 < sz) { - PMIX_INFO_CREATE(pinfo, sz); - n=0; - OPAL_LIST_FOREACH(iptr, info, opal_value_t) { - (void)strncpy(pinfo[n].key, iptr->key, PMIX_MAX_KEYLEN); - ext20_value_load(&pinfo[n].value, iptr); - ++n; - } - } else { - pinfo = NULL; - } - - ret = PMIx_Publish(pinfo, sz); - - return ext20_convert_rc(ret); -} - -int ext20_publishnb(opal_list_t *info, - opal_pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - pmix_status_t ret; - opal_value_t *iptr; - size_t n; - ext20_opcaddy_t *op; - - opal_output_verbose(1, opal_pmix_base_framework.framework_output, - "PMIx_client publish_nb"); - - if (NULL == info) { - return OPAL_ERR_BAD_PARAM; - } - - /* create the caddy */ - op = OBJ_NEW(ext20_opcaddy_t); - op->opcbfunc = cbfunc; - op->cbdata = cbdata; - - op->sz = opal_list_get_size(info); - if (0 < op->sz) { - PMIX_INFO_CREATE(op->info, op->sz); - n=0; - OPAL_LIST_FOREACH(iptr, info, opal_value_t) { - (void)strncpy(op->info[n].key, iptr->key, PMIX_MAX_KEYLEN); - ext20_value_load(&op->info[n].value, iptr); - ++n; - } - } - - ret = PMIx_Publish_nb(op->info, op->sz, opcbfunc, op); - - return ext20_convert_rc(ret); -} - -int ext20_lookup(opal_list_t *data, opal_list_t *info) -{ - pmix_pdata_t *pdata; - pmix_info_t *pinfo; - size_t sz, ninfo, n; - int rc; - pmix_status_t ret; - opal_pmix_pdata_t *d; - opal_value_t *iptr; - opal_ext20_jobid_trkr_t *job, *jptr; - - /* we must threadshift this request as we might not be in an event - * and we are going to access shared lists/objects */ - opal_output_verbose(1, opal_pmix_base_framework.framework_output, - "PMIx_client lookup"); - - if (NULL == data) { - return OPAL_ERR_BAD_PARAM; - } - - sz = opal_list_get_size(data); - PMIX_PDATA_CREATE(pdata, sz); - n=0; - OPAL_LIST_FOREACH(d, data, opal_pmix_pdata_t) { - (void)strncpy(pdata[n++].key, d->value.key, PMIX_MAX_KEYLEN); - } - - if (NULL != info) { - ninfo = opal_list_get_size(info); - PMIX_INFO_CREATE(pinfo, ninfo); - n=0; - OPAL_LIST_FOREACH(iptr, info, opal_value_t) { - (void)strncpy(pinfo[n].key, iptr->key, PMIX_MAX_KEYLEN); - ext20_value_load(&pinfo[n].value, iptr); - ++n; - } - } else { - pinfo = NULL; - ninfo = 0; - } - - ret = PMIx_Lookup(pdata, sz, pinfo, ninfo); - PMIX_INFO_FREE(pinfo, ninfo); - - if (PMIX_SUCCESS == ret) { - /* transfer the data back */ - n=0; - OPAL_LIST_FOREACH(d, data, opal_pmix_pdata_t) { - if (mca_pmix_ext20_component.native_launch) { - /* if we were launched by the OMPI RTE, then - * the jobid is in a special format - so get it */ - opal_convert_string_to_jobid(&d->proc.jobid, pdata[n].proc.nspace); - } else { - /* we were launched by someone else, so make the - * jobid just be the hash of the nspace */ - OPAL_HASH_JOBID(pdata[n].proc.nspace, d->proc.jobid); - } - /* if we don't already have it, add this to our jobid tracker */ - job = NULL; - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == d->proc.jobid) { - job = jptr; - break; - } - } - if (NULL == job) { - job = OBJ_NEW(opal_ext20_jobid_trkr_t); - (void)strncpy(job->nspace, pdata[n].proc.nspace, PMIX_MAX_NSLEN); - job->jobid = d->proc.jobid; - opal_list_append(&mca_pmix_ext20_component.jobids, &job->super); - } - d->proc.vpid = ext20_convert_rank(pdata[n].proc.rank); - rc = ext20_value_unload(&d->value, &pdata[n].value); - if (OPAL_SUCCESS != rc) { - OPAL_ERROR_LOG(rc); - PMIX_PDATA_FREE(pdata, sz); - return OPAL_ERR_BAD_PARAM; - } - ++n; - } - } - - return ext20_convert_rc(ret); -} - -static void lk_cbfunc(pmix_status_t status, - pmix_pdata_t data[], size_t ndata, - void *cbdata) -{ - ext20_opcaddy_t *op = (ext20_opcaddy_t*)cbdata; - opal_pmix_pdata_t *d; - opal_list_t results, *r = NULL; - int rc; - size_t n; - opal_ext20_jobid_trkr_t *job, *jptr; - - /* this is in the PMIx local thread - need to threadshift to - * our own thread as we will be accessing framework-global - * lists and objects */ - - if (NULL == op->lkcbfunc) { - OBJ_RELEASE(op); - return; - } - - rc = ext20_convert_rc(status); - if (OPAL_SUCCESS == rc) { - OBJ_CONSTRUCT(&results, opal_list_t); - for (n=0; n < ndata; n++) { - d = OBJ_NEW(opal_pmix_pdata_t); - opal_list_append(&results, &d->super); - if (mca_pmix_ext20_component.native_launch) { - /* if we were launched by the OMPI RTE, then - * the jobid is in a special format - so get it */ - opal_convert_string_to_jobid(&d->proc.jobid, data[n].proc.nspace); - } else { - /* we were launched by someone else, so make the - * jobid just be the hash of the nspace */ - OPAL_HASH_JOBID(data[n].proc.nspace, d->proc.jobid); - } - /* if we don't already have it, add this to our jobid tracker */ - job = NULL; - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == d->proc.jobid) { - job = jptr; - break; - } - } - if (NULL == job) { - job = OBJ_NEW(opal_ext20_jobid_trkr_t); - (void)strncpy(job->nspace, data[n].proc.nspace, PMIX_MAX_NSLEN); - job->jobid = d->proc.jobid; - opal_list_append(&mca_pmix_ext20_component.jobids, &job->super); - } - d->proc.vpid = ext20_convert_rank(data[n].proc.rank); - d->value.key = strdup(data[n].key); - rc = ext20_value_unload(&d->value, &data[n].value); - if (OPAL_SUCCESS != rc) { - rc = OPAL_ERR_BAD_PARAM; - OPAL_ERROR_LOG(rc); - goto release; - } - } - r = &results; - } -release: - /* execute the callback */ - op->lkcbfunc(rc, r, op->cbdata); - - if (NULL != r) { - OPAL_LIST_DESTRUCT(&results); - } - OBJ_RELEASE(op); -} - -int ext20_lookupnb(char **keys, opal_list_t *info, - opal_pmix_lookup_cbfunc_t cbfunc, void *cbdata) -{ - pmix_status_t ret; - ext20_opcaddy_t *op; - opal_value_t *iptr; - size_t n; - - - opal_output_verbose(1, opal_pmix_base_framework.framework_output, - "PMIx_client lookup_nb"); - - /* create the caddy */ - op = OBJ_NEW(ext20_opcaddy_t); - op->lkcbfunc = cbfunc; - op->cbdata = cbdata; - - if (NULL != info) { - op->sz = opal_list_get_size(info); - if (0 < op->sz) { - PMIX_INFO_CREATE(op->info, op->sz); - n=0; - OPAL_LIST_FOREACH(iptr, info, opal_value_t) { - (void)strncpy(op->info[n].key, iptr->key, PMIX_MAX_KEYLEN); - ext20_value_load(&op->info[n].value, iptr); - ++n; - } - } - } - - ret = PMIx_Lookup_nb(keys, op->info, op->sz, lk_cbfunc, op); - - return ext20_convert_rc(ret); -} - -int ext20_unpublish(char **keys, opal_list_t *info) -{ - pmix_status_t ret; - size_t ninfo, n; - pmix_info_t *pinfo; - opal_value_t *iptr; - - if (NULL != info) { - ninfo = opal_list_get_size(info); - PMIX_INFO_CREATE(pinfo, ninfo); - n=0; - OPAL_LIST_FOREACH(iptr, info, opal_value_t) { - (void)strncpy(pinfo[n].key, iptr->key, PMIX_MAX_KEYLEN); - ext20_value_load(&pinfo[n].value, iptr); - ++n; - } - } else { - pinfo = NULL; - ninfo = 0; - } - - ret = PMIx_Unpublish(keys, pinfo, ninfo); - PMIX_INFO_FREE(pinfo, ninfo); - - return ext20_convert_rc(ret); -} - -int ext20_unpublishnb(char **keys, opal_list_t *info, - opal_pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - pmix_status_t ret; - ext20_opcaddy_t *op; - opal_value_t *iptr; - size_t n; - - /* create the caddy */ - op = OBJ_NEW(ext20_opcaddy_t); - op->opcbfunc = cbfunc; - op->cbdata = cbdata; - - if (NULL != info) { - op->sz = opal_list_get_size(info); - if (0 < op->sz) { - PMIX_INFO_CREATE(op->info, op->sz); - n=0; - OPAL_LIST_FOREACH(iptr, info, opal_value_t) { - (void)strncpy(op->info[n].key, iptr->key, PMIX_MAX_KEYLEN); - ext20_value_load(&op->info[n].value, iptr); - ++n; - } - } - } - - ret = PMIx_Unpublish_nb(keys, op->info, op->sz, opcbfunc, op); - - return ext20_convert_rc(ret); -} - -int ext20_spawn(opal_list_t *job_info, opal_list_t *apps, opal_jobid_t *jobid) -{ - pmix_status_t ret; - pmix_info_t *pinfo = NULL; - pmix_app_t *papps; - size_t napps, n, m, ninfo = 0; - char nspace[PMIX_MAX_NSLEN+1]; - opal_value_t *info; - opal_pmix_app_t *app; - opal_ext20_jobid_trkr_t *job; - - if (NULL != job_info && 0 < (ninfo = opal_list_get_size(job_info))) { - PMIX_INFO_CREATE(pinfo, ninfo); - n=0; - OPAL_LIST_FOREACH(info, job_info, opal_value_t) { - (void)strncpy(pinfo[n].key, info->key, PMIX_MAX_KEYLEN); - ext20_value_load(&pinfo[n].value, info); - ++n; - } - } - - napps = opal_list_get_size(apps); - PMIX_APP_CREATE(papps, napps); - n=0; - OPAL_LIST_FOREACH(app, apps, opal_pmix_app_t) { - papps[n].cmd = strdup(app->cmd); - papps[n].argc = app->argc; - papps[n].argv = opal_argv_copy(app->argv); - papps[n].env = opal_argv_copy(app->env); - papps[n].maxprocs = app->maxprocs; - if (0 < (papps[n].ninfo = opal_list_get_size(&app->info))) { - PMIX_INFO_CREATE(papps[n].info, papps[n].ninfo); - m=0; - OPAL_LIST_FOREACH(info, &app->info, opal_value_t) { - (void)strncpy(papps[n].info[m].key, info->key, PMIX_MAX_KEYLEN); - ext20_value_load(&papps[n].info[m].value, info); - ++m; - } - } - ++n; - } - - ret = PMIx_Spawn(pinfo, ninfo, papps, napps, nspace); - if (PMIX_SUCCESS == ret) { - if (mca_pmix_ext20_component.native_launch) { - /* if we were launched by the OMPI RTE, then - * the jobid is in a special format - so get it */ - opal_convert_string_to_jobid(jobid, nspace); - } else { - /* we were launched by someone else, so make the - * jobid just be the hash of the nspace */ - OPAL_HASH_JOBID(nspace, *jobid); - } - /* add this to our jobid tracker */ - job = OBJ_NEW(opal_ext20_jobid_trkr_t); - (void)strncpy(job->nspace, nspace, PMIX_MAX_NSLEN); - job->jobid = *jobid; - opal_list_append(&mca_pmix_ext20_component.jobids, &job->super); - } - PMIX_APP_FREE(papps, napps); - - return ext20_convert_rc(ret); -} - -static void spcbfunc(pmix_status_t status, - char *nspace, void *cbdata) -{ - ext20_opcaddy_t *op = (ext20_opcaddy_t*)cbdata; - int rc; - opal_jobid_t jobid=OPAL_JOBID_INVALID; - opal_ext20_jobid_trkr_t *job; - - /* this is in the PMIx local thread - need to threadshift to - * our own thread as we will be accessing framework-global - * lists and objects */ - - rc = ext20_convert_rc(status); - if (PMIX_SUCCESS == status) { - if (mca_pmix_ext20_component.native_launch) { - /* if we were launched by the OMPI RTE, then - * the jobid is in a special format - so get it */ - opal_convert_string_to_jobid(&jobid, nspace); - } else { - /* we were launched by someone else, so make the - * jobid just be the hash of the nspace */ - OPAL_HASH_JOBID(nspace, jobid); - } - /* add this to our jobid tracker */ - job = OBJ_NEW(opal_ext20_jobid_trkr_t); - (void)strncpy(job->nspace, nspace, PMIX_MAX_NSLEN); - job->jobid = jobid; - opal_list_append(&mca_pmix_ext20_component.jobids, &job->super); - } - - op->spcbfunc(rc, jobid, op->cbdata); - OBJ_RELEASE(op); -} - -int ext20_spawnnb(opal_list_t *job_info, opal_list_t *apps, - opal_pmix_spawn_cbfunc_t cbfunc, void *cbdata) -{ - pmix_status_t ret; - ext20_opcaddy_t *op; - size_t n, m; - opal_value_t *info; - opal_pmix_app_t *app; - - /* create the caddy */ - op = OBJ_NEW(ext20_opcaddy_t); - op->spcbfunc = cbfunc; - op->cbdata = cbdata; - - if (NULL != job_info && 0 < (op->ninfo = opal_list_get_size(job_info))) { - PMIX_INFO_CREATE(op->info, op->ninfo); - n=0; - OPAL_LIST_FOREACH(info, job_info, opal_value_t) { - (void)strncpy(op->info[n].key, info->key, PMIX_MAX_KEYLEN); - ext20_value_load(&op->info[n].value, info); - ++n; - } - } - - op->sz = opal_list_get_size(apps); - PMIX_APP_CREATE(op->apps, op->sz); - n=0; - OPAL_LIST_FOREACH(app, apps, opal_pmix_app_t) { - op->apps[n].cmd = strdup(app->cmd); - op->apps[n].argc = app->argc; - op->apps[n].argv = opal_argv_copy(app->argv); - op->apps[n].env = opal_argv_copy(app->env); - op->apps[n].maxprocs = app->maxprocs; - if (0 < (op->apps[n].ninfo = opal_list_get_size(&app->info))) { - PMIX_INFO_CREATE(op->apps[n].info, op->apps[n].ninfo); - m=0; - OPAL_LIST_FOREACH(info, &app->info, opal_value_t) { - (void)strncpy(op->apps[n].info[m].key, info->key, PMIX_MAX_KEYLEN); - ext20_value_load(&op->apps[n].info[m].value, info); - ++m; - } - } - ++n; - } - - ret = PMIx_Spawn_nb(op->info, op->ninfo, op->apps, op->sz, spcbfunc, op); - - return ext20_convert_rc(ret); -} - -int ext20_connect(opal_list_t *procs) -{ - pmix_status_t ret; - pmix_proc_t *parray=NULL; - size_t n, cnt=0; - opal_namelist_t *ptr; - opal_ext20_jobid_trkr_t *job, *jptr; - - /* protect against bozo error */ - if (NULL == procs || 0 == (cnt = opal_list_get_size(procs))) { - return OPAL_ERR_BAD_PARAM; - } - - /* convert the list of procs to an array - * of pmix_proc_t */ - PMIX_PROC_CREATE(parray, cnt); - n=0; - OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) { - /* look thru our list of jobids and find the - * corresponding nspace */ - job = NULL; - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == ptr->name.jobid) { - job = jptr; - break; - } - } - if (NULL == job) { - OPAL_ERROR_LOG(OPAL_ERR_NOT_FOUND); - PMIX_PROC_FREE(parray, cnt); - return OPAL_ERR_NOT_FOUND; - } - (void)strncpy(parray[n].nspace, job->nspace, PMIX_MAX_NSLEN); - parray[n].rank = ext20_convert_opalrank(ptr->name.vpid); - ++n; - } - - ret = PMIx_Connect(parray, cnt, NULL, 0); - PMIX_PROC_FREE(parray, cnt); - - return ext20_convert_rc(ret); -} - -int ext20_connectnb(opal_list_t *procs, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata) -{ - pmix_status_t ret; - size_t n, cnt=0; - opal_namelist_t *ptr; - ext20_opcaddy_t *op; - opal_ext20_jobid_trkr_t *job; - - /* we must threadshift this request as we might not be in an event - * and we are going to access framework-global lists/objects */ - - /* protect against bozo error */ - if (NULL == procs || 0 == (cnt = opal_list_get_size(procs))) { - return OPAL_ERR_BAD_PARAM; - } - - /* create the caddy */ - op = OBJ_NEW(ext20_opcaddy_t); - op->opcbfunc = cbfunc; - op->cbdata = cbdata; - op->nprocs = cnt; - - /* convert the list of procs to an array - * of pmix_proc_t */ - PMIX_PROC_CREATE(op->procs, op->nprocs); - n=0; - OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) { - /* look thru our list of jobids and find the - * corresponding nspace */ - OPAL_LIST_FOREACH(job, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (job->jobid == ptr->name.jobid) { - (void)strncpy(op->procs[n].nspace, job->nspace, PMIX_MAX_NSLEN); - break; - } - } - op->procs[n].rank = ext20_convert_opalrank(ptr->name.vpid); - ++n; - } - - ret = PMIx_Connect_nb(op->procs, op->nprocs, NULL, 0, opcbfunc, op); - - return ext20_convert_rc(ret); -} - -int ext20_disconnect(opal_list_t *procs) -{ - pmix_status_t ret; - pmix_proc_t *parray=NULL; - size_t n, cnt=0; - opal_namelist_t *ptr; - opal_ext20_jobid_trkr_t *job; - - /* protect against bozo error */ - if (NULL == procs || 0 == (cnt = opal_list_get_size(procs))) { - return OPAL_ERR_BAD_PARAM; - } - - /* convert the list of procs to an array - * of pmix_proc_t */ - PMIX_PROC_CREATE(parray, cnt); - n=0; - OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) { - /* look thru our list of jobids and find the - * corresponding nspace */ - OPAL_LIST_FOREACH(job, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (job->jobid == ptr->name.jobid) { - (void)strncpy(parray[n].nspace, job->nspace, PMIX_MAX_NSLEN); - break; - } - } - parray[n].rank = ext20_convert_opalrank(ptr->name.vpid); - ++n; - } - - ret = PMIx_Disconnect(parray, cnt, NULL, 0); - PMIX_PROC_FREE(parray, cnt); - - return ext20_convert_rc(ret); -} - -int ext20_disconnectnb(opal_list_t *procs, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata) -{ - pmix_status_t ret; - size_t n, cnt=0; - opal_namelist_t *ptr; - ext20_opcaddy_t *op; - opal_ext20_jobid_trkr_t *job; - - /* we must threadshift this request as we might not be in an event - * and we are going to access framework-global lists/objects */ - - /* protect against bozo error */ - if (NULL == procs || 0 == (cnt = opal_list_get_size(procs))) { - return OPAL_ERR_BAD_PARAM; - } - - /* create the caddy */ - op = OBJ_NEW(ext20_opcaddy_t); - op->opcbfunc = cbfunc; - op->cbdata = cbdata; - op->nprocs = cnt; - - /* convert the list of procs to an array - * of pmix_proc_t */ - PMIX_PROC_CREATE(op->procs, op->nprocs); - n=0; - OPAL_LIST_FOREACH(ptr, procs, opal_namelist_t) { - /* look thru our list of jobids and find the - * corresponding nspace */ - OPAL_LIST_FOREACH(job, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (job->jobid == ptr->name.jobid) { - (void)strncpy(op->procs[n].nspace, job->nspace, PMIX_MAX_NSLEN); - break; - } - } - op->procs[n].rank = ext20_convert_opalrank(ptr->name.vpid); - ++n; - } - - ret = PMIx_Disconnect_nb(op->procs, op->nprocs, NULL, 0, opcbfunc, op); - - return ext20_convert_rc(ret); -} - - -int ext20_resolve_peers(const char *nodename, opal_jobid_t jobid, - opal_list_t *procs) -{ - char *nspace; - pmix_proc_t *array=NULL; - size_t nprocs, n; - opal_namelist_t *nm; - int rc; - pmix_status_t ret; - opal_ext20_jobid_trkr_t *job, *jptr; - - /* we must threadshift this request as we might not be in an event - * and we are going to access framework-global lists/objects */ - - if (OPAL_JOBID_WILDCARD == jobid) { - nspace = NULL; - } else { - job = NULL; - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == jobid) { - job = jptr; - break; - } - } - if (NULL == job) { - return OPAL_ERR_NOT_FOUND; - } - nspace = job->nspace; - } - - ret = PMIx_Resolve_peers(nodename, nspace, &array, &nprocs); - rc = ext20_convert_rc(ret); - - if (NULL != array && 0 < nprocs) { - for (n=0; n < nprocs; n++) { - nm = OBJ_NEW(opal_namelist_t); - opal_list_append(procs, &nm->super); - if (mca_pmix_ext20_component.native_launch) { - /* if we were launched by the OMPI RTE, then - * the jobid is in a special format - so get it */ - opal_convert_string_to_jobid(&nm->name.jobid, array[n].nspace); - } else { - /* we were launched by someone else, so make the - * jobid just be the hash of the nspace */ - OPAL_HASH_JOBID(array[n].nspace, nm->name.jobid); - } - /* if we don't already have it, add this to our jobid tracker */ - job = NULL; - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == nm->name.jobid) { - job = jptr; - break; - } - } - if (NULL == job) { - job = OBJ_NEW(opal_ext20_jobid_trkr_t); - (void)strncpy(job->nspace, nspace, PMIX_MAX_NSLEN); - job->jobid = jobid; - opal_list_append(&mca_pmix_ext20_component.jobids, &job->super); - } - nm->name.vpid = ext20_convert_rank(array[n].rank); - } - } - PMIX_PROC_FREE(array, nprocs); - - return rc; -} - -int ext20_resolve_nodes(opal_jobid_t jobid, char **nodelist) -{ - pmix_status_t ret; - char *nspace=NULL; - opal_ext20_jobid_trkr_t *job, *jptr; - - /* we must threadshift this request as we might not be in an event - * and we are going to access framework-global lists/objects */ - - if (OPAL_JOBID_WILDCARD != jobid) { - /* look thru our list of jobids and find the - * corresponding nspace */ - job = NULL; - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == jobid) { - job = jptr; - break; - } - } - if (NULL == job) { - return OPAL_ERR_NOT_FOUND; - } - nspace = job->nspace; - } - - ret = PMIx_Resolve_nodes(nspace, nodelist); - - return ext20_convert_rc(ret);; -} diff --git a/opal/mca/pmix/ext20/pmix_ext20_component.c b/opal/mca/pmix/ext20/pmix_ext20_component.c deleted file mode 100644 index f16a5001029..00000000000 --- a/opal/mca/pmix/ext20/pmix_ext20_component.c +++ /dev/null @@ -1,131 +0,0 @@ -/* - * Copyright (c) 2014-2016 Intel, Inc. All rights reserved. - * Copyright (c) 2014-2015 Research Organization for Information Science - * and Technology (RIST). All rights reserved. - * Copyright (c) 2016 Cisco Systems, Inc. All rights reserved. - * $COPYRIGHT$ - * - * Additional copyrights may follow - * - * $HEADER$ - * - * These symbols are in a file by themselves to provide nice linker - * semantics. Since linkers generally pull in symbols by object - * files, keeping these symbols as the only symbols in this file - * prevents utility programs such as "ompi_info" from having to import - * entire components just to query their version and parameters. - */ - -#include "opal_config.h" - -#include "opal/constants.h" -#include "opal/class/opal_list.h" -#include "opal/util/proc.h" -#include "opal/mca/pmix/pmix.h" -#include "pmix_ext20.h" - -/* - * Public string showing the pmix external component version number - */ -const char *opal_pmix_ext20_component_version_string = - "OPAL external pmix2.0 MCA component version " OPAL_VERSION; - -/* - * Local function - */ -static int external_open(void); -static int external_close(void); -static int external_component_query(mca_base_module_t **module, int *priority); -static int external_register(void); - - -/* - * Instantiate the public struct with all of our public information - * and pointers to our public functions in it - */ - -mca_pmix_ext20_component_t mca_pmix_ext20_component = { - { - /* First, the mca_component_t struct containing meta information - about the component itself */ - - .base_version = { - /* Indicate that we are a pmix v1.1.0 component (which also - implies a specific MCA version) */ - - OPAL_PMIX_BASE_VERSION_2_0_0, - - /* Component name and version */ - - .mca_component_name = "ext20", - MCA_BASE_MAKE_VERSION(component, OPAL_MAJOR_VERSION, OPAL_MINOR_VERSION, - OPAL_RELEASE_VERSION), - - /* Component open and close functions */ - - .mca_open_component = external_open, - .mca_close_component = external_close, - .mca_query_component = external_component_query, - .mca_register_component_params = external_register, - }, - /* Next the MCA v1.0.0 component meta data */ - .base_data = { - /* The component is checkpoint ready */ - MCA_BASE_METADATA_PARAM_CHECKPOINT - } - }, - .native_launch = false -}; - -static int external_register(void) -{ - mca_pmix_ext20_component.cache_size = 256; - mca_base_component_var_register(&mca_pmix_ext20_component.super.base_version, - "cache_size", "Size of the ring buffer cache for events", - MCA_BASE_VAR_TYPE_INT, NULL, 0, 0, OPAL_INFO_LVL_5, - MCA_BASE_VAR_SCOPE_CONSTANT, - &mca_pmix_ext20_component.cache_size); - - return OPAL_SUCCESS; -} - - -static int external_open(void) -{ - mca_pmix_ext20_component.evindex = 0; - OBJ_CONSTRUCT(&mca_pmix_ext20_component.jobids, opal_list_t); - OBJ_CONSTRUCT(&mca_pmix_ext20_component.single_events, opal_list_t); - OBJ_CONSTRUCT(&mca_pmix_ext20_component.multi_events, opal_list_t); - OBJ_CONSTRUCT(&mca_pmix_ext20_component.default_events, opal_list_t); - OBJ_CONSTRUCT(&mca_pmix_ext20_component.cache, opal_list_t); - - return OPAL_SUCCESS; -} - -static int external_close(void) -{ - OPAL_LIST_DESTRUCT(&mca_pmix_ext20_component.jobids); - OPAL_LIST_DESTRUCT(&mca_pmix_ext20_component.single_events); - OPAL_LIST_DESTRUCT(&mca_pmix_ext20_component.multi_events); - OPAL_LIST_DESTRUCT(&mca_pmix_ext20_component.default_events); - OPAL_LIST_DESTRUCT(&mca_pmix_ext20_component.cache); - return OPAL_SUCCESS; -} - - -static int external_component_query(mca_base_module_t **module, int *priority) -{ - char *t, *id; - - /* see if a PMIx server is present */ - if (NULL != (t = getenv("PMIX_SERVER_URI")) || - NULL != (id = getenv("PMIX_ID"))) { - /* if PMIx is present, then we are a client and need to use it */ - *priority = 100; - } else { - /* we could be a server, so we still need to be considered */ - *priority = 5; - } - *module = (mca_base_module_t *)&opal_pmix_ext20_module; - return OPAL_SUCCESS; -} diff --git a/opal/mca/pmix/ext20/pmix_ext20_server_north.c b/opal/mca/pmix/ext20/pmix_ext20_server_north.c deleted file mode 100644 index 2668547404b..00000000000 --- a/opal/mca/pmix/ext20/pmix_ext20_server_north.c +++ /dev/null @@ -1,1003 +0,0 @@ -/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */ -/* - * Copyright (c) 2014-2016 Intel, Inc. All rights reserved. - * Copyright (c) 2014-2016 Research Organization for Information Science - * and Technology (RIST). All rights reserved. - * Copyright (c) 2014-2015 Mellanox Technologies, Inc. - * All rights reserved. - * Copyright (c) 2016 Cisco Systems, Inc. All rights reserved. - * $COPYRIGHT$ - * - * Additional copyrights may follow - * - * $HEADER$ - */ - -#include "opal_config.h" -#include "opal/constants.h" -#include "opal/types.h" - -#ifdef HAVE_STRING_H -#include -#endif -#ifdef HAVE_UNISTD_H -#include -#endif - -#include "opal/dss/dss.h" -#include "opal/mca/event/event.h" -#include "opal/mca/hwloc/base/base.h" -#include "opal/runtime/opal.h" -#include "opal/runtime/opal_progress_threads.h" -#include "opal/util/argv.h" -#include "opal/util/error.h" -#include "opal/util/output.h" -#include "opal/util/proc.h" -#include "opal/util/show_help.h" -#include "opal/mca/pmix/base/base.h" -#include "pmix_ext20.h" - -#include "pmix.h" -#include "pmix_server.h" - -/**** N.O.R.T.H.B.O.U.N.D I.N.T.E.R.F.A.C.E.S ****/ - -/* These are the interfaces used by the embedded PMIx server - * to call up into ORTE for service requests */ - - static pmix_status_t server_client_connected_fn(const pmix_proc_t *proc, void* server_object, - pmix_op_cbfunc_t cbfunc, void *cbdata); - static pmix_status_t server_client_finalized_fn(const pmix_proc_t *proc, void* server_object, - pmix_op_cbfunc_t cbfunc, void *cbdata); - static pmix_status_t server_abort_fn(const pmix_proc_t *proc, void *server_object, - int status, const char msg[], - pmix_proc_t procs[], size_t nprocs, - pmix_op_cbfunc_t cbfunc, void *cbdata); - static pmix_status_t server_fencenb_fn(const pmix_proc_t procs[], size_t nprocs, - const pmix_info_t info[], size_t ninfo, - char *data, size_t ndata, - pmix_modex_cbfunc_t cbfunc, void *cbdata); - static pmix_status_t server_dmodex_req_fn(const pmix_proc_t *proc, - const pmix_info_t info[], size_t ninfo, - pmix_modex_cbfunc_t cbfunc, void *cbdata); - static pmix_status_t server_publish_fn(const pmix_proc_t *proc, - const pmix_info_t info[], size_t ninfo, - pmix_op_cbfunc_t cbfunc, void *cbdata); - static pmix_status_t server_lookup_fn(const pmix_proc_t *proc, char **keys, - const pmix_info_t info[], size_t ninfo, - pmix_lookup_cbfunc_t cbfunc, void *cbdata); - static pmix_status_t server_unpublish_fn(const pmix_proc_t *proc, char **keys, - const pmix_info_t info[], size_t ninfo, - pmix_op_cbfunc_t cbfunc, void *cbdata); - static pmix_status_t server_spawn_fn(const pmix_proc_t *proc, - const pmix_info_t job_info[], size_t ninfo, - const pmix_app_t apps[], size_t napps, - pmix_spawn_cbfunc_t cbfunc, void *cbdata); - static pmix_status_t server_connect_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 server_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 server_register_events(pmix_status_t *codes, size_t ncodes, - const pmix_info_t info[], size_t ninfo, - pmix_op_cbfunc_t cbfunc, void *cbdata); - static pmix_status_t server_deregister_events(pmix_status_t *codes, size_t ncodes, - pmix_op_cbfunc_t cbfunc, void *cbdata); - static pmix_status_t server_notify_event(pmix_status_t code, - const pmix_proc_t *source, - pmix_data_range_t range, - pmix_info_t info[], size_t ninfo, - pmix_op_cbfunc_t cbfunc, void *cbdata); - static pmix_status_t server_query(pmix_proc_t *proct, - pmix_query_t *queryies, size_t nqueries, - pmix_info_cbfunc_t cbfunc, - void *cbdata); - static void server_tool_connection(pmix_info_t *info, size_t ninfo, - pmix_tool_connection_cbfunc_t cbfunc, - void *cbdata); -static void server_log(const pmix_proc_t *client, - const pmix_info_t data[], size_t ndata, - const pmix_info_t directives[], size_t ndirs, - pmix_op_cbfunc_t cbfunc, void *cbdata); - - pmix_server_module_t mymodule = { - .client_connected = server_client_connected_fn, - .client_finalized = server_client_finalized_fn, - .abort = server_abort_fn, - .fence_nb = server_fencenb_fn, - .direct_modex = server_dmodex_req_fn, - .publish = server_publish_fn, - .lookup = server_lookup_fn, - .unpublish = server_unpublish_fn, - .spawn = server_spawn_fn, - .connect = server_connect_fn, - .disconnect = server_disconnect_fn, - .register_events = server_register_events, - .deregister_events = server_deregister_events, - .notify_event = server_notify_event, - .query = server_query, - .tool_connected = server_tool_connection, - .log = server_log -}; - -opal_pmix_server_module_t *host_module = NULL; - - -static void opal_opcbfunc(int status, void *cbdata) -{ - ext20_opalcaddy_t *opalcaddy = (ext20_opalcaddy_t*)cbdata; - - if (NULL != opalcaddy->opcbfunc) { - opalcaddy->opcbfunc(ext20_convert_opalrc(status), opalcaddy->cbdata); - } - OBJ_RELEASE(opalcaddy); -} - -static pmix_status_t server_client_connected_fn(const pmix_proc_t *p, void *server_object, - pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - int rc; - opal_process_name_t proc; - ext20_opalcaddy_t *opalcaddy; - - if (NULL == host_module || NULL == host_module->client_connected) { - return PMIX_SUCCESS; - } - - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->opcbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the nspace/rank to an opal_process_name_t */ - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) { - return ext20_convert_opalrc(rc); - } - proc.vpid = ext20_convert_rank(p->rank); - - /* pass it up */ - rc = host_module->client_connected(&proc, server_object, - opal_opcbfunc, opalcaddy); - return ext20_convert_opalrc(rc); -} - -static pmix_status_t server_client_finalized_fn(const pmix_proc_t *p, void* server_object, - pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - int rc; - ext20_opalcaddy_t *opalcaddy; - opal_process_name_t proc; - - if (NULL == host_module || NULL == host_module->client_finalized) { - return PMIX_SUCCESS; - } - - /* convert the nspace/rank to an opal_process_name_t */ - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) { - return ext20_convert_opalrc(rc); - } - proc.vpid = ext20_convert_rank(p->rank); - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->opcbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* pass it up */ - rc = host_module->client_finalized(&proc, server_object, opal_opcbfunc, opalcaddy); - if (OPAL_SUCCESS != rc) { - OBJ_RELEASE(opalcaddy); - } - return ext20_convert_opalrc(rc); -} - -static pmix_status_t server_abort_fn(const pmix_proc_t *p, void *server_object, - int status, const char msg[], - pmix_proc_t procs[], size_t nprocs, - pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - size_t n; - opal_namelist_t *nm; - opal_process_name_t proc; - int rc; - ext20_opalcaddy_t *opalcaddy; - - if (NULL == host_module || NULL == host_module->abort) { - return PMIX_ERR_NOT_SUPPORTED; - } - - /* convert the nspace/rank to an opal_process_name_t */ - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) { - return ext20_convert_opalrc(rc); - } - proc.vpid = ext20_convert_rank(p->rank); - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->opcbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the array of pmix_proc_t to the list of procs */ - for (n=0; n < nprocs; n++) { - nm = OBJ_NEW(opal_namelist_t); - opal_list_append(&opalcaddy->procs, &nm->super); - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&nm->name.jobid, procs[n].nspace))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - nm->name.vpid = ext20_convert_rank(procs[n].rank); - } - - /* pass it up */ - rc = host_module->abort(&proc, server_object, status, msg, - &opalcaddy->procs, opal_opcbfunc, opalcaddy); - if (OPAL_SUCCESS != rc) { - OBJ_RELEASE(opalcaddy); - } - return ext20_convert_opalrc(rc); -} - -static void _data_release(void *cbdata) -{ - ext20_opalcaddy_t *opalcaddy = (ext20_opalcaddy_t*)cbdata; - - if (NULL != opalcaddy->odmdxfunc) { - opalcaddy->odmdxfunc(opalcaddy->ocbdata); - } - OBJ_RELEASE(opalcaddy); -} - -static void opmdx_response(int status, const char *data, size_t sz, void *cbdata, - opal_pmix_release_cbfunc_t relcbfunc, void *relcbdata) -{ - pmix_status_t rc; - ext20_opalcaddy_t *opalcaddy = (ext20_opalcaddy_t*)cbdata; - - rc = ext20_convert_rc(status); - if (NULL != opalcaddy->mdxcbfunc) { - opalcaddy->odmdxfunc = relcbfunc; - opalcaddy->ocbdata = relcbdata; - opalcaddy->mdxcbfunc(rc, data, sz, opalcaddy->cbdata, - _data_release, opalcaddy); - } else { - OBJ_RELEASE(opalcaddy); - } -} - -static pmix_status_t server_fencenb_fn(const pmix_proc_t procs[], size_t nprocs, - const pmix_info_t info[], size_t ninfo, - char *data, size_t ndata, - pmix_modex_cbfunc_t cbfunc, void *cbdata) -{ - ext20_opalcaddy_t *opalcaddy; - size_t n; - opal_namelist_t *nm; - opal_value_t *iptr; - int rc; - - if (NULL == host_module || NULL == host_module->fence_nb) { - return PMIX_ERR_NOT_SUPPORTED; - } - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->mdxcbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the array of pmix_proc_t to the list of procs */ - for (n=0; n < nprocs; n++) { - nm = OBJ_NEW(opal_namelist_t); - opal_list_append(&opalcaddy->procs, &nm->super); - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&nm->name.jobid, procs[n].nspace))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - nm->name.vpid = ext20_convert_rank(procs[n].rank); - } - - /* convert the array of pmix_info_t to the list of info */ - for (n=0; n < ninfo; n++) { - iptr = OBJ_NEW(opal_value_t); - opal_list_append(&opalcaddy->info, &iptr->super); - iptr->key = strdup(info[n].key); - if (OPAL_SUCCESS != (rc = ext20_value_unload(iptr, &info[n].value))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - } - - /* pass it up */ - rc = host_module->fence_nb(&opalcaddy->procs, &opalcaddy->info, - data, ndata, opmdx_response, opalcaddy); - if (OPAL_SUCCESS != rc) { - OBJ_RELEASE(opalcaddy); - } - return ext20_convert_opalrc(rc); -} - -static pmix_status_t server_dmodex_req_fn(const pmix_proc_t *p, - const pmix_info_t info[], size_t ninfo, - pmix_modex_cbfunc_t cbfunc, void *cbdata) -{ - int rc; - ext20_opalcaddy_t *opalcaddy; - opal_process_name_t proc; - opal_value_t *iptr; - size_t n; - - if (NULL == host_module || NULL == host_module->direct_modex) { - return PMIX_ERR_NOT_SUPPORTED; - } - - /* convert the nspace/rank to an opal_process_name_t */ - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) { - return ext20_convert_opalrc(rc); - } - proc.vpid = ext20_convert_rank(p->rank); - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->mdxcbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the array of pmix_info_t to the list of info */ - for (n=0; n < ninfo; n++) { - iptr = OBJ_NEW(opal_value_t); - opal_list_append(&opalcaddy->info, &iptr->super); - iptr->key = strdup(info[n].key); - if (OPAL_SUCCESS != (rc = ext20_value_unload(iptr, &info[n].value))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - } - - /* pass it up */ - rc = host_module->direct_modex(&proc, &opalcaddy->info, opmdx_response, opalcaddy); - if (OPAL_SUCCESS != rc && OPAL_ERR_IN_PROCESS != rc) { - OBJ_RELEASE(opalcaddy); - } - if (OPAL_ERR_IN_PROCESS == rc) { - rc = OPAL_SUCCESS; - } - return ext20_convert_opalrc(rc); -} - -static pmix_status_t server_publish_fn(const pmix_proc_t *p, - const pmix_info_t info[], size_t ninfo, - pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - int rc; - size_t n; - ext20_opalcaddy_t *opalcaddy; - opal_process_name_t proc; - opal_value_t *oinfo; - - if (NULL == host_module || NULL == host_module->publish) { - return PMIX_ERR_NOT_SUPPORTED; - } - - /* convert the nspace/rank to an opal_process_name_t */ - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) { - return ext20_convert_opalrc(rc); - } - proc.vpid = ext20_convert_rank(p->rank); - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->opcbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the info array */ - for (n=0; n < ninfo; n++) { - oinfo = OBJ_NEW(opal_value_t); - opal_list_append(&opalcaddy->info, &oinfo->super); - oinfo->key = strdup(info[n].key); - if (OPAL_SUCCESS != (rc = ext20_value_unload(oinfo, &info[n].value))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - } - - /* pass it up */ - rc = host_module->publish(&proc, &opalcaddy->info, opal_opcbfunc, opalcaddy); - if (OPAL_SUCCESS != rc) { - OBJ_RELEASE(opalcaddy); - } - - return ext20_convert_opalrc(rc); -} - -static void opal_lkupcbfunc(int status, - opal_list_t *data, - void *cbdata) -{ - ext20_opalcaddy_t *opalcaddy = (ext20_opalcaddy_t*)cbdata; - pmix_status_t rc; - pmix_pdata_t *d=NULL; - size_t nd=0, n; - opal_pmix_pdata_t *p; - - if (NULL != opalcaddy->lkupcbfunc) { - rc = ext20_convert_opalrc(status); - /* convert any returned data */ - if (NULL != data) { - nd = opal_list_get_size(data); - PMIX_PDATA_CREATE(d, nd); - n=0; - OPAL_LIST_FOREACH(p, data, opal_pmix_pdata_t) { - /* convert the jobid */ - (void)opal_snprintf_jobid(d[n].proc.nspace, PMIX_MAX_NSLEN, p->proc.jobid); - d[n].proc.rank = ext20_convert_opalrank(p->proc.vpid); - (void)strncpy(d[n].key, p->value.key, PMIX_MAX_KEYLEN); - ext20_value_load(&d[n].value, &p->value); - } - } - opalcaddy->lkupcbfunc(rc, d, nd, opalcaddy->cbdata); - } - OBJ_RELEASE(opalcaddy); -} - -static pmix_status_t server_lookup_fn(const pmix_proc_t *p, char **keys, - const pmix_info_t info[], size_t ninfo, - pmix_lookup_cbfunc_t cbfunc, void *cbdata) -{ - int rc; - ext20_opalcaddy_t *opalcaddy; - opal_process_name_t proc; - opal_value_t *iptr; - size_t n; - - if (NULL == host_module || NULL == host_module->lookup) { - return PMIX_ERR_NOT_SUPPORTED; - } - - /* convert the nspace/rank to an opal_process_name_t */ - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) { - return ext20_convert_opalrc(rc); - } - proc.vpid = ext20_convert_rank(p->rank); - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->lkupcbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the array of pmix_info_t to the list of info */ - for (n=0; n < ninfo; n++) { - iptr = OBJ_NEW(opal_value_t); - opal_list_append(&opalcaddy->info, &iptr->super); - iptr->key = strdup(info[n].key); - if (OPAL_SUCCESS != (rc = ext20_value_unload(iptr, &info[n].value))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - } - - /* pass it up */ - rc = host_module->lookup(&proc, keys, &opalcaddy->info, opal_lkupcbfunc, opalcaddy); - if (OPAL_SUCCESS != rc) { - OBJ_RELEASE(opalcaddy); - } - - return ext20_convert_opalrc(rc); -} - - -static pmix_status_t server_unpublish_fn(const pmix_proc_t *p, char **keys, - const pmix_info_t info[], size_t ninfo, - pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - int rc; - ext20_opalcaddy_t *opalcaddy; - opal_process_name_t proc; - opal_value_t *iptr; - size_t n; - - if (NULL == host_module || NULL == host_module->unpublish) { - return PMIX_SUCCESS; - } - - /* convert the nspace/rank to an opal_process_name_t */ - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) { - return ext20_convert_opalrc(rc); - } - proc.vpid = ext20_convert_rank(p->rank); - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->opcbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the array of pmix_info_t to the list of info */ - for (n=0; n < ninfo; n++) { - iptr = OBJ_NEW(opal_value_t); - opal_list_append(&opalcaddy->info, &iptr->super); - iptr->key = strdup(info[n].key); - if (OPAL_SUCCESS != (rc = ext20_value_unload(iptr, &info[n].value))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - } - - /* pass it up */ - rc = host_module->unpublish(&proc, keys, &opalcaddy->info, opal_opcbfunc, opalcaddy); - if (OPAL_SUCCESS != rc) { - OBJ_RELEASE(opalcaddy); - } - - return ext20_convert_opalrc(rc); -} - -static void opal_spncbfunc(int status, opal_jobid_t jobid, void *cbdata) -{ - ext20_opalcaddy_t *opalcaddy = (ext20_opalcaddy_t*)cbdata; - pmix_status_t rc; - char nspace[PMIX_MAX_NSLEN]; - - if (NULL != opalcaddy->spwncbfunc) { - rc = ext20_convert_opalrc(status); - /* convert the jobid */ - (void)opal_snprintf_jobid(nspace, PMIX_MAX_NSLEN, jobid); - opalcaddy->spwncbfunc(rc, nspace, opalcaddy->cbdata); - } - OBJ_RELEASE(opalcaddy); -} - -static pmix_status_t server_spawn_fn(const pmix_proc_t *p, - const pmix_info_t job_info[], size_t ninfo, - const pmix_app_t apps[], size_t napps, - pmix_spawn_cbfunc_t cbfunc, void *cbdata) -{ - ext20_opalcaddy_t *opalcaddy; - opal_process_name_t proc; - opal_pmix_app_t *app; - opal_value_t *oinfo; - size_t k, n; - int rc; - - if (NULL == host_module || NULL == host_module->spawn) { - return PMIX_ERR_NOT_SUPPORTED; - } - - /* convert the nspace/rank to an opal_process_name_t */ - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&proc.jobid, p->nspace))) { - return ext20_convert_opalrc(rc); - } - proc.vpid = ext20_convert_rank(p->rank); - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->spwncbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the job info */ - for (k=0; k < ninfo; k++) { - oinfo = OBJ_NEW(opal_value_t); - opal_list_append(&opalcaddy->info, &oinfo->super); - oinfo->key = strdup(job_info[k].key); - if (OPAL_SUCCESS != (rc = ext20_value_unload(oinfo, &job_info[k].value))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - } - - /* convert the apps */ - for (n=0; n < napps; n++) { - app = OBJ_NEW(opal_pmix_app_t); - opal_list_append(&opalcaddy->apps, &app->super); - if (NULL != apps[n].cmd) { - app->cmd = strdup(apps[n].cmd); - } - app->argc = apps[n].argc; - if (NULL != apps[n].argv) { - app->argv = opal_argv_copy(apps[n].argv); - } - if (NULL != apps[n].env) { - app->env = opal_argv_copy(apps[n].env); - } - app->maxprocs = apps[n].maxprocs; - for (k=0; k < apps[n].ninfo; k++) { - oinfo = OBJ_NEW(opal_value_t); - opal_list_append(&app->info, &oinfo->super); - oinfo->key = strdup(apps[n].info[k].key); - if (OPAL_SUCCESS != (rc = ext20_value_unload(oinfo, &apps[n].info[k].value))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - } - } - - /* pass it up */ - rc = host_module->spawn(&proc, &opalcaddy->info, &opalcaddy->apps, opal_spncbfunc, opalcaddy); - if (OPAL_SUCCESS != rc) { - OPAL_ERROR_LOG(rc); - OBJ_RELEASE(opalcaddy); - } - - return ext20_convert_opalrc(rc); -} - - -static pmix_status_t server_connect_fn(const pmix_proc_t procs[], size_t nprocs, - const pmix_info_t info[], size_t ninfo, - pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - int rc; - ext20_opalcaddy_t *opalcaddy; - opal_namelist_t *nm; - size_t n; - opal_value_t *oinfo; - - if (NULL == host_module || NULL == host_module->connect) { - return PMIX_ERR_NOT_SUPPORTED; - } - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->opcbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the array of pmix_proc_t to the list of procs */ - for (n=0; n < nprocs; n++) { - nm = OBJ_NEW(opal_namelist_t); - opal_list_append(&opalcaddy->procs, &nm->super); - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&nm->name.jobid, procs[n].nspace))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - nm->name.vpid = ext20_convert_rank(procs[n].rank); - } - - /* convert the info */ - for (n=0; n < ninfo; n++) { - oinfo = OBJ_NEW(opal_value_t); - opal_list_append(&opalcaddy->info, &oinfo->super); - oinfo->key = strdup(info[n].key); - if (OPAL_SUCCESS != (rc = ext20_value_unload(oinfo, &info[n].value))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - } - - /* pass it up */ - rc = host_module->connect(&opalcaddy->procs, &opalcaddy->info, opal_opcbfunc, opalcaddy); - if (OPAL_SUCCESS != rc) { - OBJ_RELEASE(opalcaddy); - } - - return ext20_convert_opalrc(rc); -} - - -static pmix_status_t server_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) -{ - int rc; - ext20_opalcaddy_t *opalcaddy; - opal_namelist_t *nm; - size_t n; - opal_value_t *oinfo; - - if (NULL == host_module || NULL == host_module->disconnect) { - return PMIX_ERR_NOT_SUPPORTED; - } - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->opcbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the array of pmix_proc_t to the list of procs */ - for (n=0; n < nprocs; n++) { - nm = OBJ_NEW(opal_namelist_t); - opal_list_append(&opalcaddy->procs, &nm->super); - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&nm->name.jobid, procs[n].nspace))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - nm->name.vpid = ext20_convert_rank(procs[n].rank); - } - - /* convert the info */ - for (n=0; n < ninfo; n++) { - oinfo = OBJ_NEW(opal_value_t); - opal_list_append(&opalcaddy->info, &oinfo->super); - oinfo->key = strdup(info[n].key); - if (OPAL_SUCCESS != (rc = ext20_value_unload(oinfo, &info[n].value))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - } - - /* pass it up */ - rc = host_module->disconnect(&opalcaddy->procs, &opalcaddy->info, opal_opcbfunc, opalcaddy); - if (OPAL_SUCCESS != rc) { - OBJ_RELEASE(opalcaddy); - } - - return ext20_convert_opalrc(rc); -} - -static pmix_status_t server_register_events(pmix_status_t *codes, size_t ncodes, - const pmix_info_t info[], size_t ninfo, - pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - ext20_opalcaddy_t *opalcaddy; - size_t n; - opal_value_t *oinfo; - int rc; - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->opcbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the info */ - for (n=0; n < ninfo; n++) { - oinfo = OBJ_NEW(opal_value_t); - opal_list_append(&opalcaddy->info, &oinfo->super); - oinfo->key = strdup(info[n].key); - if (OPAL_SUCCESS != (rc = ext20_value_unload(oinfo, &info[n].value))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - } - - /* pass it up */ - rc = host_module->register_events(&opalcaddy->info, opal_opcbfunc, opalcaddy); - if (OPAL_SUCCESS != rc) { - OBJ_RELEASE(opalcaddy); - } - - return ext20_convert_opalrc(rc); -} - -static pmix_status_t server_deregister_events(pmix_status_t *codes, size_t ncodes, - pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - return PMIX_ERR_NOT_SUPPORTED; -} - -static pmix_status_t server_notify_event(pmix_status_t code, - const pmix_proc_t *source, - pmix_data_range_t range, - pmix_info_t info[], size_t ninfo, - pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - return PMIX_ERR_NOT_SUPPORTED; -} - -static void _info_rel(void *cbdata) -{ - ext20_opcaddy_t *pcaddy = (ext20_opcaddy_t*)cbdata; - - OBJ_RELEASE(pcaddy); -} -static void info_cbfunc(int status, - opal_list_t *info, - void *cbdata, - opal_pmix_release_cbfunc_t release_fn, - void *release_cbdata) -{ - ext20_opalcaddy_t *opalcaddy = (ext20_opalcaddy_t*)cbdata; - ext20_opcaddy_t *pcaddy; - opal_value_t *kv; - size_t n; - - pcaddy = OBJ_NEW(ext20_opcaddy_t); - - /* convert the status */ - pcaddy->status = ext20_convert_opalrc(status); - - /* convert the list to a pmix_info_t array */ - if (NULL != info) { - pcaddy->ninfo = opal_list_get_size(info); - if (0 < pcaddy->ninfo) { - PMIX_INFO_CREATE(pcaddy->info, pcaddy->ninfo); - n = 0; - OPAL_LIST_FOREACH(kv, info, opal_value_t) { - (void)strncpy(pcaddy->info[n].key, kv->key, PMIX_MAX_KEYLEN); - ext20_value_load(&pcaddy->info[n].value, kv); - } - } - } - /* we are done with the incoming data */ - if (NULL != release_fn) { - release_fn(release_cbdata); - } - - /* provide the answer downward */ - if (NULL != opalcaddy->infocbfunc) { - opalcaddy->infocbfunc(pcaddy->status, pcaddy->info, pcaddy->ninfo, - opalcaddy->cbdata, _info_rel, pcaddy); - } - OBJ_RELEASE(opalcaddy); -} - -static pmix_status_t server_query(pmix_proc_t *proct, - pmix_query_t *queries, size_t nqueries, - pmix_info_cbfunc_t cbfunc, - void *cbdata) -{ - ext20_opalcaddy_t *opalcaddy; - opal_process_name_t requestor; - int rc; - size_t n, m; - opal_pmix_query_t *q; - opal_value_t *oinfo; - - if (NULL == host_module || NULL == host_module->query) { - return PMIX_ERR_NOT_SUPPORTED; - } - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->infocbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the requestor */ - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&requestor.jobid, proct->nspace))) { - opal_output(0, "FILE: %s LINE %d", __FILE__, __LINE__); - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - requestor.vpid = ext20_convert_rank(proct->rank); - - /* convert the queries */ - for (n=0; n < nqueries; n++) { - q = OBJ_NEW(opal_pmix_query_t); - /* we "borrow" the info field of the caddy as we and the - * server function both agree on what will be there */ - opal_list_append(&opalcaddy->info, &q->super); - q->keys = opal_argv_copy(queries[n].keys); - for (m=0; m < queries[n].nqual; m++) { - oinfo = OBJ_NEW(opal_value_t); - opal_list_append(&q->qualifiers, &oinfo->super); - oinfo->key = strdup(queries[n].qualifiers[m].key); - if (OPAL_SUCCESS != (rc = ext20_value_unload(oinfo, &queries[n].qualifiers[m].value))) { - OBJ_RELEASE(opalcaddy); - return ext20_convert_opalrc(rc); - } - } - } - - /* pass the call upwards */ - if (OPAL_SUCCESS != (rc = host_module->query(&requestor, - &opalcaddy->info, - info_cbfunc, opalcaddy))) { - OBJ_RELEASE(opalcaddy); - } - - return ext20_convert_opalrc(rc); -} - -static void toolcbfunc(int status, - opal_process_name_t proc, - void *cbdata) -{ - ext20_opalcaddy_t *opalcaddy = (ext20_opalcaddy_t*)cbdata; - pmix_status_t rc; - pmix_proc_t p; - - /* convert the status */ - rc = ext20_convert_opalrc(status); - - /* convert the process name */ - (void)opal_snprintf_jobid(p.nspace, PMIX_MAX_NSLEN, proc.jobid); - p.rank = ext20_convert_opalrank(proc.vpid); - - /* pass it down */ - if (NULL != opalcaddy->toolcbfunc) { - opalcaddy->toolcbfunc(rc, &p, opalcaddy->cbdata); - } - OBJ_RELEASE(opalcaddy); -} - -static void server_tool_connection(pmix_info_t *info, size_t ninfo, - pmix_tool_connection_cbfunc_t cbfunc, - void *cbdata) -{ - ext20_opalcaddy_t *opalcaddy; - size_t n; - opal_value_t *oinfo; - int rc; - pmix_status_t err; - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->toolcbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the info */ - for (n=0; n < ninfo; n++) { - oinfo = OBJ_NEW(opal_value_t); - opal_list_append(&opalcaddy->info, &oinfo->super); - oinfo->key = strdup(info[n].key); - if (OPAL_SUCCESS != (rc = ext20_value_unload(oinfo, &info[n].value))) { - OBJ_RELEASE(opalcaddy); - err = ext20_convert_opalrc(rc); - if (NULL != cbfunc) { - cbfunc(err, NULL, cbdata); - } - } - } - - /* pass it up */ - host_module->tool_connected(&opalcaddy->info, toolcbfunc, opalcaddy); -} - -static void server_log(const pmix_proc_t *proct, - const pmix_info_t data[], size_t ndata, - const pmix_info_t directives[], size_t ndirs, - pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - ext20_opalcaddy_t *opalcaddy; - opal_process_name_t requestor; - int rc; - size_t n; - opal_value_t *oinfo; - pmix_status_t ret; - - if (NULL == host_module || NULL == host_module->log) { - if (NULL != cbfunc) { - cbfunc(PMIX_ERR_NOT_SUPPORTED, cbdata); - } - return; - } - - /* setup the caddy */ - opalcaddy = OBJ_NEW(ext20_opalcaddy_t); - opalcaddy->opcbfunc = cbfunc; - opalcaddy->cbdata = cbdata; - - /* convert the requestor */ - if (OPAL_SUCCESS != (rc = opal_convert_string_to_jobid(&requestor.jobid, proct->nspace))) { - opal_output(0, "FILE: %s LINE %d", __FILE__, __LINE__); - OBJ_RELEASE(opalcaddy); - ret = ext20_convert_opalrc(rc); - if (NULL != cbfunc) { - cbfunc(ret, cbdata); - } - return; - } - requestor.vpid = ext20_convert_rank(proct->rank); - - /* convert the data */ - for (n=0; n < ndata; n++) { - oinfo = OBJ_NEW(opal_value_t); - /* we "borrow" the info field of the caddy as we and the - * server function both agree on what will be there */ - opal_list_append(&opalcaddy->info, &oinfo->super); - if (OPAL_SUCCESS != (rc = ext20_value_unload(oinfo, &data[n].value))) { - OBJ_RELEASE(opalcaddy); - ret = ext20_convert_opalrc(rc); - if (NULL != cbfunc) { - cbfunc(ret, cbdata); - } - return; - } - } - - /* convert the directives */ - for (n=0; n < ndirs; n++) { - oinfo = OBJ_NEW(opal_value_t); - /* we "borrow" the apps field of the caddy as we and the - * server function both agree on what will be there */ - opal_list_append(&opalcaddy->apps, &oinfo->super); - if (OPAL_SUCCESS != (rc = ext20_value_unload(oinfo, &directives[n].value))) { - OBJ_RELEASE(opalcaddy); - ret = ext20_convert_opalrc(rc); - if (NULL != cbfunc) { - cbfunc(ret, cbdata); - } - return; - } - } - - /* pass the call upwards */ - host_module->log(&requestor, - &opalcaddy->info, - &opalcaddy->apps, - opal_opcbfunc, opalcaddy); -} diff --git a/opal/mca/pmix/ext20/pmix_ext20_server_south.c b/opal/mca/pmix/ext20/pmix_ext20_server_south.c deleted file mode 100644 index 342b6f4224c..00000000000 --- a/opal/mca/pmix/ext20/pmix_ext20_server_south.c +++ /dev/null @@ -1,518 +0,0 @@ -/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */ -/* - * Copyright (c) 2014-2016 Intel, Inc. All rights reserved. - * Copyright (c) 2014-2016 Research Organization for Information Science - * and Technology (RIST). All rights reserved. - * Copyright (c) 2014-2016 Intel, Inc. All rights reserved. - * Copyright (c) 2014 Mellanox Technologies, Inc. - * All rights reserved. - * Copyright (c) 2016 Cisco Systems, Inc. All rights reserved. - * $COPYRIGHT$ - * - * Additional copyrights may follow - * - * $HEADER$ - */ - -#include "opal_config.h" -#include "opal/constants.h" -#include "opal/types.h" - -#ifdef HAVE_STRING_H -#include -#endif -#ifdef HAVE_UNISTD_H -#include -#endif - -#include "opal/dss/dss.h" -#include "opal/mca/event/event.h" -#include "opal/mca/hwloc/base/base.h" -#include "opal/runtime/opal.h" -#include "opal/runtime/opal_progress_threads.h" -#include "opal/util/argv.h" -#include "opal/util/error.h" -#include "opal/util/output.h" -#include "opal/util/proc.h" -#include "opal/util/show_help.h" -#include "opal/mca/pmix/base/base.h" -#include "pmix_ext20.h" - -#include "pmix.h" -#include "pmix_server.h" - -/**** S.O.U.T.H.B.O.U.N.D I.N.T.E.R.F.A.C.E.S ****/ - -/* These are the interfaces used by the OMPI/ORTE/OPAL layer to call - * down into the embedded PMIx server. */ - -extern pmix_server_module_t mymodule; -extern opal_pmix_server_module_t *host_module; -static char *dbgvalue=NULL; -static size_t errhdler_ref = 0; - -#define PMIX_WAIT_FOR_COMPLETION(a) \ - do { \ - while ((a)) { \ - usleep(10); \ - } \ - } while (0) - -static void errreg_cbfunc (pmix_status_t status, - size_t errhandler_ref, - void *cbdata) -{ - volatile bool *active = (volatile bool*)cbdata; - - errhdler_ref = errhandler_ref; - opal_output_verbose(5, opal_pmix_base_framework.framework_output, - "PMIX server errreg_cbfunc - error handler registered status=%d, reference=%lu", - status, (unsigned long)errhandler_ref); - *active = false; -} - -int ext20_server_init(opal_pmix_server_module_t *module, - opal_list_t *info) -{ - pmix_status_t rc; - int dbg; - opal_value_t *kv; - pmix_info_t *pinfo; - size_t sz, n; - volatile bool active; - opal_ext20_jobid_trkr_t *job; - - if (0 < (dbg = opal_output_get_verbosity(opal_pmix_base_framework.framework_output))) { - asprintf(&dbgvalue, "PMIX_DEBUG=%d", dbg); - putenv(dbgvalue); - } - - /* convert the list to an array of pmix_info_t */ - if (NULL != info) { - sz = opal_list_get_size(info); - PMIX_INFO_CREATE(pinfo, sz); - n = 0; - OPAL_LIST_FOREACH(kv, info, opal_value_t) { - (void)strncpy(pinfo[n].key, kv->key, PMIX_MAX_KEYLEN); - ext20_value_load(&pinfo[n].value, kv); - ++n; - } - } else { - sz = 0; - pinfo = NULL; - } - - /* insert ourselves into our list of jobids - it will be the - * first, and so we'll check it first */ - job = OBJ_NEW(opal_ext20_jobid_trkr_t); - (void)opal_snprintf_jobid(job->nspace, PMIX_MAX_NSLEN, OPAL_PROC_MY_NAME.jobid); - job->jobid = OPAL_PROC_MY_NAME.jobid; - opal_list_append(&mca_pmix_ext20_component.jobids, &job->super); - - if (PMIX_SUCCESS != (rc = PMIx_server_init(&mymodule, pinfo, sz))) { - PMIX_INFO_FREE(pinfo, sz); - return ext20_convert_rc(rc); - } - PMIX_INFO_FREE(pinfo, sz); - - /* record the host module */ - host_module = module; - - /* register the default event handler */ - active = true; - PMIx_Register_event_handler(NULL, 0, NULL, 0, ext20_event_hdlr, errreg_cbfunc, (void*)&active); - PMIX_WAIT_FOR_COMPLETION(active); - - return OPAL_SUCCESS; -} - -static void fincb(pmix_status_t status, void *cbdata) -{ - volatile bool *active = (volatile bool*)cbdata; - *active = false; -} - -int ext20_server_finalize(void) -{ - pmix_status_t rc; - volatile bool active; - - /* deregister the default event handler */ - active = true; - PMIx_Deregister_event_handler(errhdler_ref, fincb, (void*)&active); - PMIX_WAIT_FOR_COMPLETION(active); - - rc = PMIx_server_finalize(); - return ext20_convert_rc(rc); -} - -int ext20_server_gen_regex(const char *input, char **regex) -{ - pmix_status_t rc; - - rc = PMIx_generate_regex(input, regex); - return ext20_convert_rc(rc); -} - - -int ext20_server_gen_ppn(const char *input, char **ppn) -{ - pmix_status_t rc; - - rc = PMIx_generate_ppn(input, ppn); - return ext20_convert_rc(rc); -} - -static void opcbfunc(pmix_status_t status, void *cbdata) -{ - ext20_opcaddy_t *op = (ext20_opcaddy_t*)cbdata; - - if (NULL != op->opcbfunc) { - op->opcbfunc(ext20_convert_rc(status), op->cbdata); - } - if (op->active) { - op->status = status; - op->active = false; - } else { - OBJ_RELEASE(op); - } -} - -static void _reg_nspace(int sd, short args, void *cbdata) -{ - ext20_threadshift_t *cd = (ext20_threadshift_t*)cbdata; - opal_value_t *kv, *k2; - pmix_info_t *pinfo = NULL, *pmap; - size_t sz, szmap, m, n; - char nspace[PMIX_MAX_NSLEN]; - pmix_status_t rc; - opal_list_t *pmapinfo; - opal_ext20_jobid_trkr_t *job; - ext20_opcaddy_t op; - - /* we must threadshift this request as we might not be in an event - * and we are going to access framework-global lists/objects */ - - /* convert the jobid */ - (void)opal_snprintf_jobid(nspace, PMIX_MAX_NSLEN, cd->jobid); - - /* store this job in our list of known nspaces */ - job = OBJ_NEW(opal_ext20_jobid_trkr_t); - (void)strncpy(job->nspace, nspace, PMIX_MAX_NSLEN); - job->jobid = cd->jobid; - opal_list_append(&mca_pmix_ext20_component.jobids, &job->super); - - /* convert the list to an array of pmix_info_t */ - if (NULL != cd->info) { - sz = opal_list_get_size(cd->info); - PMIX_INFO_CREATE(pinfo, sz); - n = 0; - OPAL_LIST_FOREACH(kv, cd->info, opal_value_t) { - (void)strncpy(pinfo[n].key, kv->key, PMIX_MAX_KEYLEN); - if (0 == strcmp(kv->key, OPAL_PMIX_PROC_DATA)) { - pinfo[n].value.type = PMIX_DATA_ARRAY; - /* the value contains a list of values - convert - * that list to another array */ - pmapinfo = (opal_list_t*)kv->data.ptr; - szmap = opal_list_get_size(pmapinfo); - PMIX_INFO_CREATE(pmap, szmap); - pinfo[n].value.data.darray.type = PMIX_INFO; - pinfo[n].value.data.darray.array = (struct pmix_info_t*)pmap; - pinfo[n].value.data.darray.size = szmap; - m = 0; - OPAL_LIST_FOREACH(k2, pmapinfo, opal_value_t) { - (void)strncpy(pmap[m].key, k2->key, PMIX_MAX_KEYLEN); - ext20_value_load(&pmap[m].value, k2); - ++m; - } - } else { - ext20_value_load(&pinfo[n].value, kv); - } - ++n; - } - } else { - sz = 0; - pinfo = NULL; - } - - OBJ_CONSTRUCT(&op, ext20_opcaddy_t); - op.active = true; - rc = PMIx_server_register_nspace(nspace, cd->status, pinfo, sz, - opcbfunc, (void*)&op); - if (PMIX_SUCCESS == rc) { - PMIX_WAIT_FOR_COMPLETION(op.active); - } else { - op.status = rc; - } - /* ensure we execute the cbfunc so the caller doesn't hang */ - if (NULL != cd->opcbfunc) { - cd->opcbfunc(ext20_convert_rc(op.status), cd->cbdata); - } - if (NULL != pinfo) { - PMIX_INFO_FREE(pinfo, sz); - } - OBJ_DESTRUCT(&op); - OBJ_RELEASE(cd); -} - -int ext20_server_register_nspace(opal_jobid_t jobid, - int nlocalprocs, - opal_list_t *info, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata) -{ - ext20_threadshift_t *cd; - - /* we must threadshift this request as it touches - * shared lists of objects */ - cd = OBJ_NEW(ext20_threadshift_t); - cd->jobid = jobid; - cd->status = nlocalprocs; - cd->info = info; - cd->opcbfunc = cbfunc; - cd->cbdata = cbdata; - /* if the cbfunc is NULL, then the caller is in an event - * and we can directly call the processing function */ - if (NULL == cbfunc) { - _reg_nspace(0, 0, cd); - } else { - event_assign(&cd->ev, opal_pmix_base.evbase, - -1, EV_WRITE, _reg_nspace, cd); - event_active(&cd->ev, EV_WRITE, 1); - } - - return OPAL_SUCCESS; -} - -static void tdcbfunc(pmix_status_t status, void *cbdata) -{ - ext20_threadshift_t *cd = (ext20_threadshift_t*)cbdata; - - if (NULL != cd->opcbfunc) { - cd->opcbfunc(ext20_convert_rc(status), cd->cbdata); - } - if (cd->active) { - cd->active = false; - } else { - OBJ_RELEASE(cd); - } -} - -static void _dereg_nspace(int sd, short args, void *cbdata) -{ - ext20_threadshift_t *cd = (ext20_threadshift_t*)cbdata; - opal_ext20_jobid_trkr_t *jptr; - - /* if we don't already have it, we can ignore this */ - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == cd->jobid) { - /* found it - tell the server to deregister */ - cd->active = true; - PMIx_server_deregister_nspace(jptr->nspace, tdcbfunc, cd); - PMIX_WAIT_FOR_COMPLETION(cd->active); - OBJ_RELEASE(cd); - /* now get rid of it from our list */ - opal_list_remove_item(&mca_pmix_ext20_component.jobids, &jptr->super); - OBJ_RELEASE(jptr); - return; - } - } - /* must release the caller */ - tdcbfunc(PMIX_ERR_NOT_FOUND, cd); -} - -void ext20_server_deregister_nspace(opal_jobid_t jobid, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata) -{ - ext20_threadshift_t *cd; - - /* we must threadshift this request as it touches - * shared lists of objects */ - cd = OBJ_NEW(ext20_threadshift_t); - cd->jobid = jobid; - cd->opcbfunc = cbfunc; - cd->cbdata = cbdata; - if (NULL == cbfunc) { - _dereg_nspace(0, 0, cd); - } else { - event_assign(&cd->ev, opal_pmix_base.evbase, - -1, EV_WRITE, _dereg_nspace, cd); - event_active(&cd->ev, EV_WRITE, 1); - } -} - -int ext20_server_register_client(const opal_process_name_t *proc, - uid_t uid, gid_t gid, - void *server_object, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata) -{ - pmix_status_t rc; - pmix_proc_t p; - ext20_opcaddy_t op; - - /* convert the jobid */ - (void)opal_snprintf_jobid(p.nspace, PMIX_MAX_NSLEN, proc->jobid); - p.rank = ext20_convert_opalrank(proc->vpid); - - OBJ_CONSTRUCT(&op, ext20_opcaddy_t); - op.active = true; - rc = PMIx_server_register_client(&p, uid, gid, server_object, - opcbfunc, (void*)&op); - if (PMIX_SUCCESS == rc) { - PMIX_WAIT_FOR_COMPLETION(op.active); - rc = op.status; - } - OBJ_DESTRUCT(&op); - return ext20_convert_rc(rc); -} - -static void _dereg_client(int sd, short args, void *cbdata) -{ - ext20_threadshift_t *cd = (ext20_threadshift_t*)cbdata; - opal_ext20_jobid_trkr_t *jptr; - pmix_proc_t p; - - /* if we don't already have it, we can ignore this */ - OPAL_LIST_FOREACH(jptr, &mca_pmix_ext20_component.jobids, opal_ext20_jobid_trkr_t) { - if (jptr->jobid == cd->source->jobid) { - /* found it - tell the server to deregister */ - (void)strncpy(p.nspace, jptr->nspace, PMIX_MAX_NSLEN); - p.rank = ext20_convert_opalrank(cd->source->vpid); - cd->active = true; - PMIx_server_deregister_client(&p, tdcbfunc, (void*)cd); - PMIX_WAIT_FOR_COMPLETION(cd->active); - break; - } - } - OBJ_RELEASE(cd); -} - -/* tell the local PMIx server to cleanup this client as it is - * done executing */ -void ext20_server_deregister_client(const opal_process_name_t *proc, - opal_pmix_op_cbfunc_t cbfunc, - void *cbdata) -{ - ext20_threadshift_t *cd; - - /* we must threadshift this request as we might not be in an event - * and we are going to access framework-global lists/objects */ - cd = OBJ_NEW(ext20_threadshift_t); - cd->source = proc; - cd->opcbfunc = cbfunc; - cd->cbdata = cbdata; - if (NULL == cbfunc) { - _dereg_client(0, 0, cd); - } else { - event_assign(&cd->ev, opal_pmix_base.evbase, - -1, EV_WRITE, _dereg_client, cd); - event_active(&cd->ev, EV_WRITE, 1); - } -} - -/* have the local PMIx server setup the environment for this client */ -int ext20_server_setup_fork(const opal_process_name_t *proc, char ***env) -{ - pmix_status_t rc; - pmix_proc_t p; - - /* convert the jobid */ - (void)opal_snprintf_jobid(p.nspace, PMIX_MAX_NSLEN, proc->jobid); - p.rank = ext20_convert_opalrank(proc->vpid); - - rc = PMIx_server_setup_fork(&p, env); - return ext20_convert_rc(rc); -} - -/* this is the call back up from the embedded PMIx server that - * will contain the returned data. Note that the embedded server - * "owns" the data and will free it upon return from this function */ -static void dmdx_response(pmix_status_t status, char *data, size_t sz, void *cbdata) -{ - int rc; - ext20_opcaddy_t *op = (ext20_opcaddy_t*)cbdata; - - rc = ext20_convert_rc(status); - if (NULL != op->mdxcbfunc) { - op->mdxcbfunc(rc, data, sz, op->cbdata, NULL, NULL); - } - OBJ_RELEASE(op); -} - -/* request modex data for a local proc from the PMIx server */ -int ext20_server_dmodex(const opal_process_name_t *proc, - opal_pmix_modex_cbfunc_t cbfunc, void *cbdata) -{ - ext20_opcaddy_t *op; - pmix_status_t rc; - - /* setup the caddy */ - op = OBJ_NEW(ext20_opcaddy_t); - op->mdxcbfunc = cbfunc; - op->cbdata = cbdata; - - /* convert the jobid */ - (void)opal_snprintf_jobid(op->p.nspace, PMIX_MAX_NSLEN, proc->jobid); - op->p.rank = ext20_convert_opalrank(proc->vpid); - - /* find the internally-cached data for this proc */ - rc = PMIx_server_dmodex_request(&op->p, dmdx_response, op); - if (PMIX_SUCCESS != rc) { - OBJ_RELEASE(op); - } - return ext20_convert_rc(rc); -} - -/* tell the PMIx server to notify its local clients of an event */ -int ext20_server_notify_event(int status, - const opal_process_name_t *source, - opal_list_t *info, - opal_pmix_op_cbfunc_t cbfunc, void *cbdata) -{ - opal_value_t *kv; - pmix_info_t *pinfo; - size_t sz, n; - pmix_status_t rc; - ext20_opcaddy_t *op; - - /* convert the list to an array of pmix_info_t */ - if (NULL != info) { - sz = opal_list_get_size(info); - PMIX_INFO_CREATE(pinfo, sz); - n = 0; - OPAL_LIST_FOREACH(kv, info, opal_value_t) { - (void)strncpy(pinfo[n].key, kv->key, PMIX_MAX_KEYLEN); - ext20_value_load(&pinfo[n].value, kv); - } - } else { - sz = 0; - pinfo = NULL; - } - /* setup the caddy */ - op = OBJ_NEW(ext20_opcaddy_t); - op->info = pinfo; - op->sz = sz; - op->opcbfunc = cbfunc; - op->cbdata = cbdata; - /* convert the jobid */ - if (NULL == source) { - (void)opal_snprintf_jobid(op->p.nspace, PMIX_MAX_NSLEN, OPAL_JOBID_INVALID); - op->p.rank = ext20_convert_opalrank(OPAL_VPID_INVALID); - } else { - (void)opal_snprintf_jobid(op->p.nspace, PMIX_MAX_NSLEN, source->jobid); - op->p.rank = ext20_convert_opalrank(source->vpid); - } - - - rc = ext20_convert_opalrc(status); - /* the range is irrelevant here as the server is passing - * the event down to its local clients */ - rc = PMIx_Notify_event(rc, &op->p, PMIX_RANGE_LOCAL, - pinfo, sz, opcbfunc, op); - if (PMIX_SUCCESS != rc) { - OBJ_RELEASE(op); - } - return ext20_convert_rc(rc); -} diff --git a/opal/mca/pmix/pmix2x/Makefile.am b/opal/mca/pmix/pmix2x/Makefile.am index f9692367a17..206f22c225d 100644 --- a/opal/mca/pmix/pmix2x/Makefile.am +++ b/opal/mca/pmix/pmix2x/Makefile.am @@ -42,12 +42,12 @@ mca_pmix_pmix2x_la_CPPFLAGS = \ -I$(srcdir)/pmix/include $(opal_pmix_pmix2x_CPPFLAGS) mca_pmix_pmix2x_la_LDFLAGS = -module -avoid-version $(opal_pmix_pmix2x_LDFLAGS) mca_pmix_pmix2x_la_LIBADD = $(opal_pmix_pmix2x_LIBS) -mca_pmix_pmix2x_la_DEPENDENCIES = $(mca_pmix_pmix2x_la_LIBADD) +mca_pmix_pmix2x_la_DEPENDENCIES = $(opal_pmix_pmix2x_DEPENDENCIES) noinst_LTLIBRARIES = $(component_noinst) libmca_pmix_pmix2x_la_SOURCES =$(sources) libmca_pmix_pmix2x_la_CFLAGS = $(opal_pmix_pmix2x_CFLAGS) -libmca_pmix_pmix2x_la_CPPFLAGS = -I$(srcdir)/pmix/include $(opal_pmix_pmix2x_CPPFLAGS) +libmca_pmix_pmix2x_la_CPPFLAGS = $(opal_pmix_pmix2x_CPPFLAGS) libmca_pmix_pmix2x_la_LDFLAGS = -module -avoid-version $(opal_pmix_pmix2x_LDFLAGS) libmca_pmix_pmix2x_la_LIBADD = $(opal_pmix_pmix2x_LIBS) -libmca_pmix_pmix2x_la_DEPENDENCIES = $(mca_pmix_pmix2x_la_LIBADD) +libmca_pmix_pmix2x_la_DEPENDENCIES = $(opal_pmix_pmix2x_DEPENDENCIES) diff --git a/opal/mca/pmix/pmix2x/configure.m4 b/opal/mca/pmix/pmix2x/configure.m4 index 2a8f05d6d43..b91e1494757 100644 --- a/opal/mca/pmix/pmix2x/configure.m4 +++ b/opal/mca/pmix/pmix2x/configure.m4 @@ -28,6 +28,8 @@ AC_DEFUN([MCA_opal_pmix_pmix2x_CONFIG],[ AC_CONFIG_FILES([opal/mca/pmix/pmix2x/Makefile]) + AC_REQUIRE([OPAL_CHECK_PMIX]) + OPAL_VAR_SCOPE_PUSH([PMIX_VERSION opal_pmix_pmix2x_save_CPPFLAGS opal_pmix_pmix2x_save_LDFLAGS opal_pmix_pmix2x_save_LIBS opal_pmix_pmix2x_basedir opal_pmix_pmix2x_save_cflags]) PMIX_VERSION= @@ -49,31 +51,47 @@ AC_DEFUN([MCA_opal_pmix_pmix2x_CONFIG],[ CPPFLAGS="-I$OPAL_TOP_SRCDIR -I$OPAL_TOP_BUILDDIR -I$OPAL_TOP_SRCDIR/opal/include -I$OPAL_TOP_BUILDDIR/opal/include $CPPFLAGS" OPAL_CONFIG_SUBDIR([$opal_pmix_pmix2x_basedir/pmix], - [$opal_pmix_pmix2x_args $opal_subdir_args 'CFLAGS=$CFLAGS' 'CPPFLAGS=$CPPFLAGS'], - [opal_pmix_pmix2x_happy=1], [opal_pmix_pmix2x_happy=0]) - - AS_IF([test $opal_pmix_pmix2x_happy -eq 1], - [PMIX_VERSION="internal v`$srcdir/$opal_pmix_pmix2x_basedir/pmix/config/pmix_get_version.sh $srcdir/$opal_pmix_pmix2x_basedir/pmix/VERSION`" - # Build flags for our Makefile.am - opal_pmix_pmix2x_LIBS='$(OPAL_TOP_BUILDDIR)/'"$opal_pmix_pmix2x_basedir"'/pmix/src/libpmix.la' - opal_pmix_pmix2x_CPPFLAGS='-I$(OPAL_TOP_BUILDDIR)/opal/mca/pmix/pmix2x/pmix/include/pmix -I$(OPAL_TOP_BUILDDIR)/opal/mca/pmix/pmix2x/pmix/include -I$(OPAL_TOP_BUILDDIR)/opal/mca/pmix/pmix2x/pmix -I$(OPAL_TOP_SRCDIR)/opal/mca/pmix/pmix2x/pmix' - AC_SUBST([opal_pmix_pmix2x_LIBS]) - AC_SUBST([opal_pmix_pmix2x_CPPFLAGS])]) + [$opal_pmix_pmix2x_args $opal_subdir_args 'CFLAGS=$CFLAGS' 'CPPFLAGS=$CPPFLAGS'], + [opal_pmix_pmix2x_happy=1], [opal_pmix_pmix2x_happy=0]) CFLAGS=$opal_pmix_pmix2x_save_CFLAGS CPPFLAGS=$opal_pmix_pmix2x_save_CPPFLAGS LDFLAGS=$opal_pmix_pmix2x_save_LDFLAGS LIBS=$opal_pmix_pmix2x_save_LIBS - # If we are not building the internal pmix, then indicate that - # this component should not be built. NOTE: we still did all the + # If we are not building the internal pmix, then check to see + # if we are linking to an external v2.x library. If not, then + # do not use this component. NOTE: we still did all the # above configury so that all the proper GNU Autotools # infrastructure is setup properly (e.g., w.r.t. SUBDIRS=pmix in # this directory's Makefile.am, we still need the Autotools "make # distclean" infrastructure to work properly). + AC_MSG_CHECKING([if v2.x component is to be used]) AS_IF([test "$opal_external_pmix_happy" = "yes"], - [AC_MSG_WARN([using an external pmix; disqualifying this component]) - opal_pmix_pmix2x_happy=0]) + [AS_IF([test "$opal_external_pmix_version" = "2"], + [AC_MSG_RESULT([yes - using an external v2.x library]) + # Build flags for our Makefile.am + opal_pmix_pmix2x_CPPFLAGS=$opal_external_pmix_CPPFLAGS + opal_pmix_pmix2x_LDFLAGS=$opal_external_pmix_LDFLAGS + opal_pmix_pmix2x_LIBS=$opal_external_pmix_LIBS + opal_pmix_pmix2x_DEPENDENCIES= + # setup wrapper flags + pmix_pmix2x_WRAPPER_EXTRA_LDFLAGS=$opal_external_pmix_LDFLAGS + pmix_pmix2x_WRAPPER_EXTRA_LIBS=$opal_external_pmix_LIBS], + [AC_MSG_RESULT([no - using an external v1.x pmix; disqualifying this component]) + opal_pmix_pmix2x_happy=0])], + [AC_MSG_RESULT([yes - using the internal v2.x library]) + PMIX_VERSION="internal v`$srcdir/$opal_pmix_pmix2x_basedir/pmix/config/pmix_get_version.sh $srcdir/$opal_pmix_pmix2x_basedir/pmix/VERSION`" + # Build flags for our Makefile.am + opal_pmix_pmix2x_LDFLAGS= + opal_pmix_pmix2x_LIBS='$(OPAL_TOP_BUILDDIR)/'"$opal_pmix_pmix2x_basedir"'/pmix/src/libpmix.la' + opal_pmix_pmix2x_CPPFLAGS='-I$(OPAL_TOP_BUILDDIR)/opal/mca/pmix/pmix2x/pmix/include -I$(OPAL_TOP_BUILDDIR)/opal/mca/pmix/pmix2x/pmix -I$(OPAL_TOP_SRCDIR)/opal/mca/pmix/pmix2x/pmix/include -I$(OPAL_TOP_SRCDIR)/opal/mca/pmix/pmix2x/pmix' + opal_pmix_pmix2x_DEPENDENCIES='$(OPAL_TOP_BUILDDIR)/opal/mca/pmix/pmix2x/pmix/src/libpmix.la']) + + AC_SUBST([opal_pmix_pmix2x_LIBS]) + AC_SUBST([opal_pmix_pmix2x_CPPFLAGS]) + AC_SUBST([opal_pmix_pmix2x_LDFLAGS]) + AC_SUBST([opal_pmix_pmix2x_DEPENDENCIES]) AS_IF([test $opal_pmix_pmix2x_happy -eq 1], [$1],