2006-09-14 21:29:51 +00:00
|
|
|
/*
|
2007-03-16 23:11:45 +00:00
|
|
|
* Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
|
2006-09-14 21:29:51 +00:00
|
|
|
* University Research and Technology
|
|
|
|
|
* Corporation. All rights reserved.
|
2008-11-01 00:39:46 +00:00
|
|
|
* Copyright (c) 2004-2008 The University of Tennessee and The University
|
2006-09-14 21:29:51 +00:00
|
|
|
* 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.
|
2010-04-08 18:17:44 +00:00
|
|
|
* Copyright (c) 2007-2010 Oracle and/or its affiliates. All rights reserved.
|
2007-10-17 13:47:36 +00:00
|
|
|
* Copyright (c) 2007 Evergrid, Inc. All rights reserved.
|
2010-02-22 15:05:09 +00:00
|
|
|
* Copyright (c) 2008-2010 Cisco Systems, Inc. All rights reserved.
|
2010-03-07 18:44:22 +00:00
|
|
|
* Copyright (c) 2010 IBM Corporation. All rights reserved.
|
2007-10-17 13:47:36 +00:00
|
|
|
*
|
2006-09-14 21:29:51 +00:00
|
|
|
* $COPYRIGHT$
|
|
|
|
|
*
|
|
|
|
|
* Additional copyrights may follow
|
|
|
|
|
*
|
|
|
|
|
* $HEADER$
|
This commit is the first of several steps in a paffinity makeover
extravaganza.
= Short version =
This commit does several things, but the short version is that it
re-orients the error message creation of the ODLS default module to
generate error strings in the child process for errors that occur
after the fork but before the exec (such errors are ''usually''
related to paffinity). A show_help string is rendered in the child
and then IPC'ed up to the parent, who displays the string through
normal ORTE show_help aggregation mechanisms. We also broke up the
ginormous paffinity-setting logic into a few separate functions, both
to help us understand the code, and hopefully to ease future
maintenance.
The logic for the ODLS default binding should not have changed -- this
is mainly a code reshuffle and improvement on error reporting.
= Rationale =
The reasoning for this commit is complex. As mentioned above, it's
the first step in some paffinity cleanup. Here's the line of dominoes
that must fall (in this order):
1. Add hwloc paffinity component (already done).
1. While testing hwloc, we discovered that the error reporting from
the ODLS default module was abysmal. So we fixed it.
1. Further, we reorganized the code in the odsl_default_module.c a bit
to help our understanding of it.
1. We also discovered a few bugs in the original ODLS default module
logic that existed before this code shuffle; separate tickets
will be filed to fix them.
1. Next up will be some improvements to paffinity / odls default to
make the act of binding to a core ensure to bind to ''all''
hardware threads contained in that core (similar for sockets:
binding to a socket will bind to ''all'' hardware threads in that
socket).
1. Next will be improvements to paffinity to expose binding to
hardware threads through the paffinity framework API.
1. Finally, we'll expose these binding controls to the user (e.g.,
through mpirun command line arguments, MCA parameters, etc.).
This commit represents the first few bullets; the last 4 bullets are
being worked on right now, but there is no definite timeline for
completion.
= Miscelaneous =
A few points worth mentioning:
* We have tested this new code a bunch; we're pretty sure it behaves
just like the trunk -- but with better / more precise error
reporting. More testing is needed on a wider array of platforms,
however.
* A big comment at the top of odls_default_module.c explains the
(new) general scheme for the error reporting.
* The error reporting in the parent process is now really dumb;
almost all the intelligence about creating error messages is in the
child.
* The show_help file was renamed to be more consistent with other
help files (help-odls-default.txt -> help-orte-odls-default.txt)
* Removed the use of sched_yield() because of recent changes in the
Linux 2.6.3x kernels. We already had an #else clause for
select()'ing for 1us if we didn't have sched_yield() -- that is now
the only code path. This is not a performance-critical section of
the code, so this shouldn't be controversial.
* Replaced the macro-based error reporting with function-based
reporting. It's a bit more bulky, but it helped us understand the
code and saved us multiple times with compile-time parameter
checking, etc.
* Cleaned up the use of several show_help messages to ensure that
they mapped to real messages in help*.txt files.
This commit was SVN r23652.
2010-08-24 19:38:29 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* There is a complicated sequence of events that occurs when the
|
|
|
|
|
* parent forks a child process that is intended to launch the target
|
|
|
|
|
* executable.
|
|
|
|
|
*
|
|
|
|
|
* Before the child process exec's the target executable, it might tri
|
|
|
|
|
* to set the affinity of that new child process according to a
|
|
|
|
|
* complex series of rules. This binding may fail in a myriad of
|
|
|
|
|
* different ways. A lot of this code deals with reporting that error
|
|
|
|
|
* occurately to the end user. This is a complex task in itself
|
|
|
|
|
* because the child process is not "really" an ORTE process -- all
|
|
|
|
|
* error reporting must be proxied up to the parent who can use normal
|
|
|
|
|
* ORTE error reporting mechanisms.
|
2006-09-14 21:29:51 +00:00
|
|
|
*
|
This commit is the first of several steps in a paffinity makeover
extravaganza.
= Short version =
This commit does several things, but the short version is that it
re-orients the error message creation of the ODLS default module to
generate error strings in the child process for errors that occur
after the fork but before the exec (such errors are ''usually''
related to paffinity). A show_help string is rendered in the child
and then IPC'ed up to the parent, who displays the string through
normal ORTE show_help aggregation mechanisms. We also broke up the
ginormous paffinity-setting logic into a few separate functions, both
to help us understand the code, and hopefully to ease future
maintenance.
The logic for the ODLS default binding should not have changed -- this
is mainly a code reshuffle and improvement on error reporting.
= Rationale =
The reasoning for this commit is complex. As mentioned above, it's
the first step in some paffinity cleanup. Here's the line of dominoes
that must fall (in this order):
1. Add hwloc paffinity component (already done).
1. While testing hwloc, we discovered that the error reporting from
the ODLS default module was abysmal. So we fixed it.
1. Further, we reorganized the code in the odsl_default_module.c a bit
to help our understanding of it.
1. We also discovered a few bugs in the original ODLS default module
logic that existed before this code shuffle; separate tickets
will be filed to fix them.
1. Next up will be some improvements to paffinity / odls default to
make the act of binding to a core ensure to bind to ''all''
hardware threads contained in that core (similar for sockets:
binding to a socket will bind to ''all'' hardware threads in that
socket).
1. Next will be improvements to paffinity to expose binding to
hardware threads through the paffinity framework API.
1. Finally, we'll expose these binding controls to the user (e.g.,
through mpirun command line arguments, MCA parameters, etc.).
This commit represents the first few bullets; the last 4 bullets are
being worked on right now, but there is no definite timeline for
completion.
= Miscelaneous =
A few points worth mentioning:
* We have tested this new code a bunch; we're pretty sure it behaves
just like the trunk -- but with better / more precise error
reporting. More testing is needed on a wider array of platforms,
however.
* A big comment at the top of odls_default_module.c explains the
(new) general scheme for the error reporting.
* The error reporting in the parent process is now really dumb;
almost all the intelligence about creating error messages is in the
child.
* The show_help file was renamed to be more consistent with other
help files (help-odls-default.txt -> help-orte-odls-default.txt)
* Removed the use of sched_yield() because of recent changes in the
Linux 2.6.3x kernels. We already had an #else clause for
select()'ing for 1us if we didn't have sched_yield() -- that is now
the only code path. This is not a performance-critical section of
the code, so this shouldn't be controversial.
* Replaced the macro-based error reporting with function-based
reporting. It's a bit more bulky, but it helped us understand the
code and saved us multiple times with compile-time parameter
checking, etc.
* Cleaned up the use of several show_help messages to ensure that
they mapped to real messages in help*.txt files.
This commit was SVN r23652.
2010-08-24 19:38:29 +00:00
|
|
|
* Here's a high-level description of what is occurring in this file:
|
|
|
|
|
*
|
|
|
|
|
* - parent opens a pipe
|
|
|
|
|
* - parent forks a child
|
|
|
|
|
* - parent blocks reading on the pipe: the pipe will either close
|
|
|
|
|
* (indicating that the child successfully exec'ed) or the child will
|
|
|
|
|
* write some proxied error data up the pipe
|
|
|
|
|
*
|
|
|
|
|
* - the child tries to set affinity and do other housekeeping in
|
|
|
|
|
* preparation of exec'ing the target executable
|
|
|
|
|
* - if the child fails anywhere along the way, it sends a message up
|
|
|
|
|
* the pipe to the parent indicating what happened -- including a
|
|
|
|
|
* rendered error message detailing the problem (i.e., human-readable).
|
|
|
|
|
* - it is important that the child renders the error message: there
|
|
|
|
|
* are so many errors that are possible that the child is really the
|
|
|
|
|
* only entity that has enough information to make an accuate error string
|
|
|
|
|
* to report back to the user.
|
|
|
|
|
* - the parent reads this message + rendered string in and uses ORTE
|
|
|
|
|
* reporting mechanisms to display it to the user
|
|
|
|
|
* - if the problem was only a warning, the child continues processing
|
|
|
|
|
* (potentially eventually exec'ing the target executable).
|
|
|
|
|
* - if the problem was an error, the child exits and the parent
|
|
|
|
|
* handles the death of the child as appropriate (i.e., this ODLS
|
|
|
|
|
* simply reports the error -- other things decide what to do).
|
2006-09-14 21:29:51 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "orte_config.h"
|
2008-02-28 01:57:57 +00:00
|
|
|
#include "orte/constants.h"
|
2009-07-13 02:29:17 +00:00
|
|
|
#include "orte/types.h"
|
2006-09-14 21:29:51 +00:00
|
|
|
|
2009-07-16 18:27:33 +00:00
|
|
|
#ifdef HAVE_STRING_H
|
2009-03-13 02:10:32 +00:00
|
|
|
#include <string.h>
|
|
|
|
|
#endif
|
2006-09-14 21:29:51 +00:00
|
|
|
#include <stdlib.h>
|
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
|
|
|
#include <unistd.h>
|
|
|
|
|
#endif
|
|
|
|
|
#include <errno.h>
|
2007-06-12 22:43:18 +00:00
|
|
|
#ifdef HAVE_SYS_TYPES_H
|
2006-09-14 21:29:51 +00:00
|
|
|
#include <sys/types.h>
|
2006-11-13 18:51:18 +00:00
|
|
|
#endif
|
2006-09-14 21:29:51 +00:00
|
|
|
#ifdef HAVE_SYS_WAIT_H
|
|
|
|
|
#include <sys/wait.h>
|
|
|
|
|
#endif
|
|
|
|
|
#include <signal.h>
|
|
|
|
|
#ifdef HAVE_FCNTL_H
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
#endif
|
2006-11-13 18:51:18 +00:00
|
|
|
#ifdef HAVE_SYS_TIME_H
|
|
|
|
|
#include <sys/time.h>
|
|
|
|
|
#endif
|
2006-09-14 21:29:51 +00:00
|
|
|
#ifdef HAVE_SYS_PARAM_H
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef HAVE_NETDB_H
|
|
|
|
|
#include <netdb.h>
|
|
|
|
|
#endif
|
This commit is the first of several steps in a paffinity makeover
extravaganza.
= Short version =
This commit does several things, but the short version is that it
re-orients the error message creation of the ODLS default module to
generate error strings in the child process for errors that occur
after the fork but before the exec (such errors are ''usually''
related to paffinity). A show_help string is rendered in the child
and then IPC'ed up to the parent, who displays the string through
normal ORTE show_help aggregation mechanisms. We also broke up the
ginormous paffinity-setting logic into a few separate functions, both
to help us understand the code, and hopefully to ease future
maintenance.
The logic for the ODLS default binding should not have changed -- this
is mainly a code reshuffle and improvement on error reporting.
= Rationale =
The reasoning for this commit is complex. As mentioned above, it's
the first step in some paffinity cleanup. Here's the line of dominoes
that must fall (in this order):
1. Add hwloc paffinity component (already done).
1. While testing hwloc, we discovered that the error reporting from
the ODLS default module was abysmal. So we fixed it.
1. Further, we reorganized the code in the odsl_default_module.c a bit
to help our understanding of it.
1. We also discovered a few bugs in the original ODLS default module
logic that existed before this code shuffle; separate tickets
will be filed to fix them.
1. Next up will be some improvements to paffinity / odls default to
make the act of binding to a core ensure to bind to ''all''
hardware threads contained in that core (similar for sockets:
binding to a socket will bind to ''all'' hardware threads in that
socket).
1. Next will be improvements to paffinity to expose binding to
hardware threads through the paffinity framework API.
1. Finally, we'll expose these binding controls to the user (e.g.,
through mpirun command line arguments, MCA parameters, etc.).
This commit represents the first few bullets; the last 4 bullets are
being worked on right now, but there is no definite timeline for
completion.
= Miscelaneous =
A few points worth mentioning:
* We have tested this new code a bunch; we're pretty sure it behaves
just like the trunk -- but with better / more precise error
reporting. More testing is needed on a wider array of platforms,
however.
* A big comment at the top of odls_default_module.c explains the
(new) general scheme for the error reporting.
* The error reporting in the parent process is now really dumb;
almost all the intelligence about creating error messages is in the
child.
* The show_help file was renamed to be more consistent with other
help files (help-odls-default.txt -> help-orte-odls-default.txt)
* Removed the use of sched_yield() because of recent changes in the
Linux 2.6.3x kernels. We already had an #else clause for
select()'ing for 1us if we didn't have sched_yield() -- that is now
the only code path. This is not a performance-critical section of
the code, so this shouldn't be controversial.
* Replaced the macro-based error reporting with function-based
reporting. It's a bit more bulky, but it helped us understand the
code and saved us multiple times with compile-time parameter
checking, etc.
* Cleaned up the use of several show_help messages to ensure that
they mapped to real messages in help*.txt files.
This commit was SVN r23652.
2010-08-24 19:38:29 +00:00
|
|
|
#ifdef HAVE_STDLIB_H
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#endif
|
2006-09-14 21:29:51 +00:00
|
|
|
#ifdef HAVE_SYS_STAT_H
|
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
#endif /* HAVE_SYS_STAT_H */
|
This commit is the first of several steps in a paffinity makeover
extravaganza.
= Short version =
This commit does several things, but the short version is that it
re-orients the error message creation of the ODLS default module to
generate error strings in the child process for errors that occur
after the fork but before the exec (such errors are ''usually''
related to paffinity). A show_help string is rendered in the child
and then IPC'ed up to the parent, who displays the string through
normal ORTE show_help aggregation mechanisms. We also broke up the
ginormous paffinity-setting logic into a few separate functions, both
to help us understand the code, and hopefully to ease future
maintenance.
The logic for the ODLS default binding should not have changed -- this
is mainly a code reshuffle and improvement on error reporting.
= Rationale =
The reasoning for this commit is complex. As mentioned above, it's
the first step in some paffinity cleanup. Here's the line of dominoes
that must fall (in this order):
1. Add hwloc paffinity component (already done).
1. While testing hwloc, we discovered that the error reporting from
the ODLS default module was abysmal. So we fixed it.
1. Further, we reorganized the code in the odsl_default_module.c a bit
to help our understanding of it.
1. We also discovered a few bugs in the original ODLS default module
logic that existed before this code shuffle; separate tickets
will be filed to fix them.
1. Next up will be some improvements to paffinity / odls default to
make the act of binding to a core ensure to bind to ''all''
hardware threads contained in that core (similar for sockets:
binding to a socket will bind to ''all'' hardware threads in that
socket).
1. Next will be improvements to paffinity to expose binding to
hardware threads through the paffinity framework API.
1. Finally, we'll expose these binding controls to the user (e.g.,
through mpirun command line arguments, MCA parameters, etc.).
This commit represents the first few bullets; the last 4 bullets are
being worked on right now, but there is no definite timeline for
completion.
= Miscelaneous =
A few points worth mentioning:
* We have tested this new code a bunch; we're pretty sure it behaves
just like the trunk -- but with better / more precise error
reporting. More testing is needed on a wider array of platforms,
however.
* A big comment at the top of odls_default_module.c explains the
(new) general scheme for the error reporting.
* The error reporting in the parent process is now really dumb;
almost all the intelligence about creating error messages is in the
child.
* The show_help file was renamed to be more consistent with other
help files (help-odls-default.txt -> help-orte-odls-default.txt)
* Removed the use of sched_yield() because of recent changes in the
Linux 2.6.3x kernels. We already had an #else clause for
select()'ing for 1us if we didn't have sched_yield() -- that is now
the only code path. This is not a performance-critical section of
the code, so this shouldn't be controversial.
* Replaced the macro-based error reporting with function-based
reporting. It's a bit more bulky, but it helped us understand the
code and saved us multiple times with compile-time parameter
checking, etc.
* Cleaned up the use of several show_help messages to ensure that
they mapped to real messages in help*.txt files.
This commit was SVN r23652.
2010-08-24 19:38:29 +00:00
|
|
|
#ifdef HAVE_STDARG_H
|
|
|
|
|
#include <stdarg.h>
|
2006-11-13 18:51:18 +00:00
|
|
|
#endif
|
|
|
|
|
#ifdef HAVE_SYS_SELECT_H
|
|
|
|
|
#include <sys/select.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
2009-05-12 02:18:35 +00:00
|
|
|
#include "opal/mca/maffinity/base/base.h"
|
|
|
|
|
#include "opal/mca/paffinity/base/base.h"
|
2009-07-13 02:29:17 +00:00
|
|
|
#include "opal/class/opal_pointer_array.h"
|
2010-04-17 01:58:26 +00:00
|
|
|
#include "opal/util/opal_environ.h"
|
2010-05-17 23:08:56 +00:00
|
|
|
#include "opal/util/opal_sos.h"
|
This commit is the first of several steps in a paffinity makeover
extravaganza.
= Short version =
This commit does several things, but the short version is that it
re-orients the error message creation of the ODLS default module to
generate error strings in the child process for errors that occur
after the fork but before the exec (such errors are ''usually''
related to paffinity). A show_help string is rendered in the child
and then IPC'ed up to the parent, who displays the string through
normal ORTE show_help aggregation mechanisms. We also broke up the
ginormous paffinity-setting logic into a few separate functions, both
to help us understand the code, and hopefully to ease future
maintenance.
The logic for the ODLS default binding should not have changed -- this
is mainly a code reshuffle and improvement on error reporting.
= Rationale =
The reasoning for this commit is complex. As mentioned above, it's
the first step in some paffinity cleanup. Here's the line of dominoes
that must fall (in this order):
1. Add hwloc paffinity component (already done).
1. While testing hwloc, we discovered that the error reporting from
the ODLS default module was abysmal. So we fixed it.
1. Further, we reorganized the code in the odsl_default_module.c a bit
to help our understanding of it.
1. We also discovered a few bugs in the original ODLS default module
logic that existed before this code shuffle; separate tickets
will be filed to fix them.
1. Next up will be some improvements to paffinity / odls default to
make the act of binding to a core ensure to bind to ''all''
hardware threads contained in that core (similar for sockets:
binding to a socket will bind to ''all'' hardware threads in that
socket).
1. Next will be improvements to paffinity to expose binding to
hardware threads through the paffinity framework API.
1. Finally, we'll expose these binding controls to the user (e.g.,
through mpirun command line arguments, MCA parameters, etc.).
This commit represents the first few bullets; the last 4 bullets are
being worked on right now, but there is no definite timeline for
completion.
= Miscelaneous =
A few points worth mentioning:
* We have tested this new code a bunch; we're pretty sure it behaves
just like the trunk -- but with better / more precise error
reporting. More testing is needed on a wider array of platforms,
however.
* A big comment at the top of odls_default_module.c explains the
(new) general scheme for the error reporting.
* The error reporting in the parent process is now really dumb;
almost all the intelligence about creating error messages is in the
child.
* The show_help file was renamed to be more consistent with other
help files (help-odls-default.txt -> help-orte-odls-default.txt)
* Removed the use of sched_yield() because of recent changes in the
Linux 2.6.3x kernels. We already had an #else clause for
select()'ing for 1us if we didn't have sched_yield() -- that is now
the only code path. This is not a performance-critical section of
the code, so this shouldn't be controversial.
* Replaced the macro-based error reporting with function-based
reporting. It's a bit more bulky, but it helped us understand the
code and saved us multiple times with compile-time parameter
checking, etc.
* Cleaned up the use of several show_help messages to ensure that
they mapped to real messages in help*.txt files.
This commit was SVN r23652.
2010-08-24 19:38:29 +00:00
|
|
|
#include "opal/util/show_help.h"
|
|
|
|
|
#include "opal/util/fd.h"
|
2009-05-12 02:18:35 +00:00
|
|
|
|
2008-06-09 14:53:58 +00:00
|
|
|
#include "orte/util/show_help.h"
|
2006-09-14 21:29:51 +00:00
|
|
|
#include "orte/runtime/orte_wait.h"
|
2008-02-28 01:57:57 +00:00
|
|
|
#include "orte/runtime/orte_globals.h"
|
2006-09-14 21:29:51 +00:00
|
|
|
#include "orte/mca/errmgr/errmgr.h"
|
2009-05-12 02:18:35 +00:00
|
|
|
#include "orte/mca/ess/ess.h"
|
2006-09-14 21:29:51 +00:00
|
|
|
#include "orte/mca/iof/base/iof_base_setup.h"
|
2010-02-04 15:47:20 +00:00
|
|
|
#include "orte/mca/plm/plm.h"
|
2008-02-28 01:57:57 +00:00
|
|
|
#include "orte/util/name_fns.h"
|
These changes were mostly captured in a prior RFC (except for #2 below) and are aimed specifically at improving startup performance and setting up the remaining modifications described in that RFC.
The commit has been tested for C/R and Cray operations, and on Odin (SLURM, rsh) and RoadRunner (TM). I tried to update all environments, but obviously could not test them. I know that Windows needs some work, and have highlighted what is know to be needed in the odls process component.
This represents a lot of work by Brian, Tim P, Josh, and myself, with much advice from Jeff and others. For posterity, I have appended a copy of the email describing the work that was done:
As we have repeatedly noted, the modex operation in MPI_Init is the single greatest consumer of time during startup. To-date, we have executed that operation as an ORTE stage gate that held the process until a startup message containing all required modex (and OOB contact info - see #3 below) info could be sent to it. Each process would send its data to the HNP's registry, which assembled and sent the message when all processes had reported in.
In addition, ORTE had taken responsibility for monitoring process status as it progressed through a series of "stage gates". The process reported its status at each gate, and ORTE would then send a "release" message once all procs had reported in.
The incoming changes revamp these procedures in three ways:
1. eliminating the ORTE stage gate system and cleanly delineating responsibility between the OMPI and ORTE layers for MPI init/finalize. The modex stage gate (STG1) has been replaced by a collective operation in the modex itself that performs an allgather on the required modex info. The allgather is implemented using the orte_grpcomm framework since the BTL's are not active at that point. At the moment, the grpcomm framework only has a "basic" component analogous to OMPI's "basic" coll framework - I would recommend that the MPI team create additional, more advanced components to improve performance of this step.
The other stage gates have been replaced by orte_grpcomm barrier functions. We tried to use MPI barriers instead (since the BTL's are active at that point), but - as we discussed on the telecon - these are not currently true barriers so the job would hang when we fell through while messages were still in process. Note that the grpcomm barrier doesn't actually resolve that problem, but Brian has pointed out that we are unlikely to ever see it violated. Again, you might want to spend a little time on an advanced barrier algorithm as the one in "basic" is very simplistic.
Summarizing this change: ORTE no longer tracks process state nor has direct responsibility for synchronizing jobs. This is now done via collective operations within the MPI layer, albeit using ORTE collective communication services. I -strongly- urge the MPI team to implement advanced collective algorithms to improve the performance of this critical procedure.
2. reducing the volume of data exchanged during modex. Data in the modex consisted of the process name, the name of the node where that process is located (expressed as a string), plus a string representation of all contact info. The nodename was required in order for the modex to determine if the process was local or not - in addition, some people like to have it to print pretty error messages when a connection failed.
The size of this data has been reduced in three ways:
(a) reducing the size of the process name itself. The process name consisted of two 32-bit fields for the jobid and vpid. This is far larger than any current system, or system likely to exist in the near future, can support. Accordingly, the default size of these fields has been reduced to 16-bits, which means you can have 32k procs in each of 32k jobs. Since the daemons must have a vpid, and we require one daemon/node, this also restricts the default configuration to 32k nodes.
To support any future "mega-clusters", a configuration option --enable-jumbo-apps has been added. This option increases the jobid and vpid field sizes to 32-bits. Someday, if necessary, someone can add yet another option to increase them to 64-bits, I suppose.
(b) replacing the string nodename with an integer nodeid. Since we have one daemon/node, the nodeid corresponds to the local daemon's vpid. This replaces an often lengthy string with only 2 (or at most 4) bytes, a substantial reduction.
(c) when the mca param requesting that nodenames be sent to support pretty error messages, a second mca param is now used to request FQDN - otherwise, the domain name is stripped (by default) from the message to save space. If someone wants to combine those into a single param somehow (perhaps with an argument?), they are welcome to do so - I didn't want to alter what people are already using.
While these may seem like small savings, they actually amount to a significant impact when aggregated across the entire modex operation. Since every proc must receive the modex data regardless of the collective used to send it, just reducing the size of the process name removes nearly 400MBytes of communication from a 32k proc job (admittedly, much of this comm may occur in parallel). So it does add up pretty quickly.
3. routing RML messages to reduce connections. The default messaging system remains point-to-point - i.e., each proc opens a socket to every proc it communicates with and sends its messages directly. A new option uses the orteds as routers - i.e., each proc only opens a single socket to its local orted. All messages are sent from the proc to the orted, which forwards the message to the orted on the node where the intended recipient proc is located - that orted then forwards the message to its local proc (the recipient). This greatly reduces the connection storm we have encountered during startup.
It also has the benefit of removing the sharing of every proc's OOB contact with every other proc. The orted routing tables are populated during launch since every orted gets a map of where every proc is being placed. Each proc, therefore, only needs to know the contact info for its local daemon, which is passed in via the environment when the proc is fork/exec'd by the daemon. This alone removes ~50 bytes/process of communication that was in the current STG1 startup message - so for our 32k proc job, this saves us roughly 32k*50 = 1.6MBytes sent to 32k procs = 51GBytes of messaging.
Note that you can use the new routing method by specifying -mca routed tree - if you so desire. This mode will become the default at some point in the future.
There are a few minor additional changes in the commit that I'll just note in passing:
* propagation of command line mca params to the orteds - fixes ticket #1073. See note there for details.
* requiring of "finalize" prior to "exit" for MPI procs - fixes ticket #1144. See note there for details.
* cleanup of some stale header files
This commit was SVN r16364.
2007-10-05 19:48:23 +00:00
|
|
|
|
2010-04-17 01:02:41 +00:00
|
|
|
#include "orte/mca/odls/base/base.h"
|
2006-09-14 21:29:51 +00:00
|
|
|
#include "orte/mca/odls/base/odls_private.h"
|
|
|
|
|
#include "orte/mca/odls/default/odls_default.h"
|
|
|
|
|
|
2007-06-06 20:18:37 +00:00
|
|
|
/*
|
This commit is the first of several steps in a paffinity makeover
extravaganza.
= Short version =
This commit does several things, but the short version is that it
re-orients the error message creation of the ODLS default module to
generate error strings in the child process for errors that occur
after the fork but before the exec (such errors are ''usually''
related to paffinity). A show_help string is rendered in the child
and then IPC'ed up to the parent, who displays the string through
normal ORTE show_help aggregation mechanisms. We also broke up the
ginormous paffinity-setting logic into a few separate functions, both
to help us understand the code, and hopefully to ease future
maintenance.
The logic for the ODLS default binding should not have changed -- this
is mainly a code reshuffle and improvement on error reporting.
= Rationale =
The reasoning for this commit is complex. As mentioned above, it's
the first step in some paffinity cleanup. Here's the line of dominoes
that must fall (in this order):
1. Add hwloc paffinity component (already done).
1. While testing hwloc, we discovered that the error reporting from
the ODLS default module was abysmal. So we fixed it.
1. Further, we reorganized the code in the odsl_default_module.c a bit
to help our understanding of it.
1. We also discovered a few bugs in the original ODLS default module
logic that existed before this code shuffle; separate tickets
will be filed to fix them.
1. Next up will be some improvements to paffinity / odls default to
make the act of binding to a core ensure to bind to ''all''
hardware threads contained in that core (similar for sockets:
binding to a socket will bind to ''all'' hardware threads in that
socket).
1. Next will be improvements to paffinity to expose binding to
hardware threads through the paffinity framework API.
1. Finally, we'll expose these binding controls to the user (e.g.,
through mpirun command line arguments, MCA parameters, etc.).
This commit represents the first few bullets; the last 4 bullets are
being worked on right now, but there is no definite timeline for
completion.
= Miscelaneous =
A few points worth mentioning:
* We have tested this new code a bunch; we're pretty sure it behaves
just like the trunk -- but with better / more precise error
reporting. More testing is needed on a wider array of platforms,
however.
* A big comment at the top of odls_default_module.c explains the
(new) general scheme for the error reporting.
* The error reporting in the parent process is now really dumb;
almost all the intelligence about creating error messages is in the
child.
* The show_help file was renamed to be more consistent with other
help files (help-odls-default.txt -> help-orte-odls-default.txt)
* Removed the use of sched_yield() because of recent changes in the
Linux 2.6.3x kernels. We already had an #else clause for
select()'ing for 1us if we didn't have sched_yield() -- that is now
the only code path. This is not a performance-critical section of
the code, so this shouldn't be controversial.
* Replaced the macro-based error reporting with function-based
reporting. It's a bit more bulky, but it helped us understand the
code and saved us multiple times with compile-time parameter
checking, etc.
* Cleaned up the use of several show_help messages to ensure that
they mapped to real messages in help*.txt files.
This commit was SVN r23652.
2010-08-24 19:38:29 +00:00
|
|
|
* Struct written up the pipe from the child to the parent.
|
|
|
|
|
*/
|
|
|
|
|
typedef struct {
|
|
|
|
|
/* True if the child has died; false if this is just a warning to
|
|
|
|
|
be printed. */
|
|
|
|
|
bool fatal;
|
|
|
|
|
/* Relevant only if fatal==true */
|
|
|
|
|
int exit_status;
|
|
|
|
|
|
|
|
|
|
/* Length of the strings that are written up the pipe after this
|
|
|
|
|
struct */
|
|
|
|
|
int file_str_len;
|
|
|
|
|
int topic_str_len;
|
|
|
|
|
int msg_str_len;
|
|
|
|
|
} pipe_err_msg_t;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Max length of strings from the pipe_err_msg_t
|
|
|
|
|
*/
|
|
|
|
|
#define MAX_FILE_LEN 511
|
|
|
|
|
#define MAX_TOPIC_LEN MAX_FILE_LEN
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Module functions (function pointers used in a struct)
|
2007-06-06 20:18:37 +00:00
|
|
|
*/
|
2008-02-28 01:57:57 +00:00
|
|
|
static int orte_odls_default_launch_local_procs(opal_buffer_t *data);
|
2010-03-05 13:22:12 +00:00
|
|
|
static int orte_odls_default_kill_local_procs(opal_pointer_array_t *procs);
|
2007-10-10 15:02:10 +00:00
|
|
|
static int orte_odls_default_signal_local_procs(const orte_process_name_t *proc, int32_t signal);
|
2010-04-26 22:15:57 +00:00
|
|
|
static int orte_odls_default_restart_proc(orte_odls_child_t *child);
|
These changes were mostly captured in a prior RFC (except for #2 below) and are aimed specifically at improving startup performance and setting up the remaining modifications described in that RFC.
The commit has been tested for C/R and Cray operations, and on Odin (SLURM, rsh) and RoadRunner (TM). I tried to update all environments, but obviously could not test them. I know that Windows needs some work, and have highlighted what is know to be needed in the odls process component.
This represents a lot of work by Brian, Tim P, Josh, and myself, with much advice from Jeff and others. For posterity, I have appended a copy of the email describing the work that was done:
As we have repeatedly noted, the modex operation in MPI_Init is the single greatest consumer of time during startup. To-date, we have executed that operation as an ORTE stage gate that held the process until a startup message containing all required modex (and OOB contact info - see #3 below) info could be sent to it. Each process would send its data to the HNP's registry, which assembled and sent the message when all processes had reported in.
In addition, ORTE had taken responsibility for monitoring process status as it progressed through a series of "stage gates". The process reported its status at each gate, and ORTE would then send a "release" message once all procs had reported in.
The incoming changes revamp these procedures in three ways:
1. eliminating the ORTE stage gate system and cleanly delineating responsibility between the OMPI and ORTE layers for MPI init/finalize. The modex stage gate (STG1) has been replaced by a collective operation in the modex itself that performs an allgather on the required modex info. The allgather is implemented using the orte_grpcomm framework since the BTL's are not active at that point. At the moment, the grpcomm framework only has a "basic" component analogous to OMPI's "basic" coll framework - I would recommend that the MPI team create additional, more advanced components to improve performance of this step.
The other stage gates have been replaced by orte_grpcomm barrier functions. We tried to use MPI barriers instead (since the BTL's are active at that point), but - as we discussed on the telecon - these are not currently true barriers so the job would hang when we fell through while messages were still in process. Note that the grpcomm barrier doesn't actually resolve that problem, but Brian has pointed out that we are unlikely to ever see it violated. Again, you might want to spend a little time on an advanced barrier algorithm as the one in "basic" is very simplistic.
Summarizing this change: ORTE no longer tracks process state nor has direct responsibility for synchronizing jobs. This is now done via collective operations within the MPI layer, albeit using ORTE collective communication services. I -strongly- urge the MPI team to implement advanced collective algorithms to improve the performance of this critical procedure.
2. reducing the volume of data exchanged during modex. Data in the modex consisted of the process name, the name of the node where that process is located (expressed as a string), plus a string representation of all contact info. The nodename was required in order for the modex to determine if the process was local or not - in addition, some people like to have it to print pretty error messages when a connection failed.
The size of this data has been reduced in three ways:
(a) reducing the size of the process name itself. The process name consisted of two 32-bit fields for the jobid and vpid. This is far larger than any current system, or system likely to exist in the near future, can support. Accordingly, the default size of these fields has been reduced to 16-bits, which means you can have 32k procs in each of 32k jobs. Since the daemons must have a vpid, and we require one daemon/node, this also restricts the default configuration to 32k nodes.
To support any future "mega-clusters", a configuration option --enable-jumbo-apps has been added. This option increases the jobid and vpid field sizes to 32-bits. Someday, if necessary, someone can add yet another option to increase them to 64-bits, I suppose.
(b) replacing the string nodename with an integer nodeid. Since we have one daemon/node, the nodeid corresponds to the local daemon's vpid. This replaces an often lengthy string with only 2 (or at most 4) bytes, a substantial reduction.
(c) when the mca param requesting that nodenames be sent to support pretty error messages, a second mca param is now used to request FQDN - otherwise, the domain name is stripped (by default) from the message to save space. If someone wants to combine those into a single param somehow (perhaps with an argument?), they are welcome to do so - I didn't want to alter what people are already using.
While these may seem like small savings, they actually amount to a significant impact when aggregated across the entire modex operation. Since every proc must receive the modex data regardless of the collective used to send it, just reducing the size of the process name removes nearly 400MBytes of communication from a 32k proc job (admittedly, much of this comm may occur in parallel). So it does add up pretty quickly.
3. routing RML messages to reduce connections. The default messaging system remains point-to-point - i.e., each proc opens a socket to every proc it communicates with and sends its messages directly. A new option uses the orteds as routers - i.e., each proc only opens a single socket to its local orted. All messages are sent from the proc to the orted, which forwards the message to the orted on the node where the intended recipient proc is located - that orted then forwards the message to its local proc (the recipient). This greatly reduces the connection storm we have encountered during startup.
It also has the benefit of removing the sharing of every proc's OOB contact with every other proc. The orted routing tables are populated during launch since every orted gets a map of where every proc is being placed. Each proc, therefore, only needs to know the contact info for its local daemon, which is passed in via the environment when the proc is fork/exec'd by the daemon. This alone removes ~50 bytes/process of communication that was in the current STG1 startup message - so for our 32k proc job, this saves us roughly 32k*50 = 1.6MBytes sent to 32k procs = 51GBytes of messaging.
Note that you can use the new routing method by specifying -mca routed tree - if you so desire. This mode will become the default at some point in the future.
There are a few minor additional changes in the commit that I'll just note in passing:
* propagation of command line mca params to the orteds - fixes ticket #1073. See note there for details.
* requiring of "finalize" prior to "exit" for MPI procs - fixes ticket #1144. See note there for details.
* cleanup of some stale header files
This commit was SVN r16364.
2007-10-05 19:48:23 +00:00
|
|
|
|
This commit is the first of several steps in a paffinity makeover
extravaganza.
= Short version =
This commit does several things, but the short version is that it
re-orients the error message creation of the ODLS default module to
generate error strings in the child process for errors that occur
after the fork but before the exec (such errors are ''usually''
related to paffinity). A show_help string is rendered in the child
and then IPC'ed up to the parent, who displays the string through
normal ORTE show_help aggregation mechanisms. We also broke up the
ginormous paffinity-setting logic into a few separate functions, both
to help us understand the code, and hopefully to ease future
maintenance.
The logic for the ODLS default binding should not have changed -- this
is mainly a code reshuffle and improvement on error reporting.
= Rationale =
The reasoning for this commit is complex. As mentioned above, it's
the first step in some paffinity cleanup. Here's the line of dominoes
that must fall (in this order):
1. Add hwloc paffinity component (already done).
1. While testing hwloc, we discovered that the error reporting from
the ODLS default module was abysmal. So we fixed it.
1. Further, we reorganized the code in the odsl_default_module.c a bit
to help our understanding of it.
1. We also discovered a few bugs in the original ODLS default module
logic that existed before this code shuffle; separate tickets
will be filed to fix them.
1. Next up will be some improvements to paffinity / odls default to
make the act of binding to a core ensure to bind to ''all''
hardware threads contained in that core (similar for sockets:
binding to a socket will bind to ''all'' hardware threads in that
socket).
1. Next will be improvements to paffinity to expose binding to
hardware threads through the paffinity framework API.
1. Finally, we'll expose these binding controls to the user (e.g.,
through mpirun command line arguments, MCA parameters, etc.).
This commit represents the first few bullets; the last 4 bullets are
being worked on right now, but there is no definite timeline for
completion.
= Miscelaneous =
A few points worth mentioning:
* We have tested this new code a bunch; we're pretty sure it behaves
just like the trunk -- but with better / more precise error
reporting. More testing is needed on a wider array of platforms,
however.
* A big comment at the top of odls_default_module.c explains the
(new) general scheme for the error reporting.
* The error reporting in the parent process is now really dumb;
almost all the intelligence about creating error messages is in the
child.
* The show_help file was renamed to be more consistent with other
help files (help-odls-default.txt -> help-orte-odls-default.txt)
* Removed the use of sched_yield() because of recent changes in the
Linux 2.6.3x kernels. We already had an #else clause for
select()'ing for 1us if we didn't have sched_yield() -- that is now
the only code path. This is not a performance-critical section of
the code, so this shouldn't be controversial.
* Replaced the macro-based error reporting with function-based
reporting. It's a bit more bulky, but it helped us understand the
code and saved us multiple times with compile-time parameter
checking, etc.
* Cleaned up the use of several show_help messages to ensure that
they mapped to real messages in help*.txt files.
This commit was SVN r23652.
2010-08-24 19:38:29 +00:00
|
|
|
/*
|
|
|
|
|
* Explicitly declared functions so that we can get the noreturn
|
|
|
|
|
* attribute registered with the compiler.
|
|
|
|
|
*/
|
|
|
|
|
static void send_error_show_help(int fd, int exit_status,
|
|
|
|
|
const char *file, const char *topic, ...)
|
|
|
|
|
__opal_attribute_noreturn__;
|
|
|
|
|
static int do_child(orte_app_context_t* context,
|
|
|
|
|
orte_odls_child_t *child,
|
|
|
|
|
char **environ_copy,
|
|
|
|
|
orte_odls_job_t *jobdat, int write_fd,
|
|
|
|
|
orte_iof_base_io_conf_t opts)
|
|
|
|
|
__opal_attribute_noreturn__;
|
|
|
|
|
|
2006-09-14 21:29:51 +00:00
|
|
|
|
This commit is the first of several steps in a paffinity makeover
extravaganza.
= Short version =
This commit does several things, but the short version is that it
re-orients the error message creation of the ODLS default module to
generate error strings in the child process for errors that occur
after the fork but before the exec (such errors are ''usually''
related to paffinity). A show_help string is rendered in the child
and then IPC'ed up to the parent, who displays the string through
normal ORTE show_help aggregation mechanisms. We also broke up the
ginormous paffinity-setting logic into a few separate functions, both
to help us understand the code, and hopefully to ease future
maintenance.
The logic for the ODLS default binding should not have changed -- this
is mainly a code reshuffle and improvement on error reporting.
= Rationale =
The reasoning for this commit is complex. As mentioned above, it's
the first step in some paffinity cleanup. Here's the line of dominoes
that must fall (in this order):
1. Add hwloc paffinity component (already done).
1. While testing hwloc, we discovered that the error reporting from
the ODLS default module was abysmal. So we fixed it.
1. Further, we reorganized the code in the odsl_default_module.c a bit
to help our understanding of it.
1. We also discovered a few bugs in the original ODLS default module
logic that existed before this code shuffle; separate tickets
will be filed to fix them.
1. Next up will be some improvements to paffinity / odls default to
make the act of binding to a core ensure to bind to ''all''
hardware threads contained in that core (similar for sockets:
binding to a socket will bind to ''all'' hardware threads in that
socket).
1. Next will be improvements to paffinity to expose binding to
hardware threads through the paffinity framework API.
1. Finally, we'll expose these binding controls to the user (e.g.,
through mpirun command line arguments, MCA parameters, etc.).
This commit represents the first few bullets; the last 4 bullets are
being worked on right now, but there is no definite timeline for
completion.
= Miscelaneous =
A few points worth mentioning:
* We have tested this new code a bunch; we're pretty sure it behaves
just like the trunk -- but with better / more precise error
reporting. More testing is needed on a wider array of platforms,
however.
* A big comment at the top of odls_default_module.c explains the
(new) general scheme for the error reporting.
* The error reporting in the parent process is now really dumb;
almost all the intelligence about creating error messages is in the
child.
* The show_help file was renamed to be more consistent with other
help files (help-odls-default.txt -> help-orte-odls-default.txt)
* Removed the use of sched_yield() because of recent changes in the
Linux 2.6.3x kernels. We already had an #else clause for
select()'ing for 1us if we didn't have sched_yield() -- that is now
the only code path. This is not a performance-critical section of
the code, so this shouldn't be controversial.
* Replaced the macro-based error reporting with function-based
reporting. It's a bit more bulky, but it helped us understand the
code and saved us multiple times with compile-time parameter
checking, etc.
* Cleaned up the use of several show_help messages to ensure that
they mapped to real messages in help*.txt files.
This commit was SVN r23652.
2010-08-24 19:38:29 +00:00
|
|
|
/*
|
|
|
|
|
* Module
|
|
|
|
|
*/
|
2006-09-14 21:29:51 +00:00
|
|
|
orte_odls_base_module_t orte_odls_default_module = {
|
2007-10-10 15:02:10 +00:00
|
|
|
orte_odls_base_default_get_add_procs_data,
|
2006-09-14 21:29:51 +00:00
|
|
|
orte_odls_default_launch_local_procs,
|
|
|
|
|
orte_odls_default_kill_local_procs,
|
Bring in the code for routing xcast stage gate messages via the local orteds. This code is inactive unless you specifically request it via an mca param oob_xcast_mode (can be set to "linear" or "direct"). Direct mode is the old standard method where we send messages directly to each MPI process. Linear mode sends the xcast message via the orteds, with the HNP sending the message to each orted directly.
There is a binomial algorithm in the code (i.e., the HNP would send to a subset of the orteds, which then relay it on according to the typical log-2 algo), but that has a bug in it so the code won't let you select it even if you tried (and the mca param doesn't show, so you'd *really* have to try).
This also involved a slight change to the oob.xcast API, so propagated that as required.
Note: this has *only* been tested on rsh, SLURM, and Bproc environments (now that it has been transferred to the OMPI trunk, I'll need to re-test it [only done rsh so far]). It should work fine on any environment that uses the ORTE daemons - anywhere else, you are on your own... :-)
Also, correct a mistake where the orte_debug_flag was declared an int, but the mca param was set as a bool. Move the storage for that flag to the orte/runtime/params.c and orte/runtime/params.h files appropriately.
This commit was SVN r14475.
2007-04-23 18:41:04 +00:00
|
|
|
orte_odls_default_signal_local_procs,
|
2007-10-10 15:02:10 +00:00
|
|
|
orte_odls_base_default_deliver_message,
|
2010-04-26 22:15:57 +00:00
|
|
|
orte_odls_base_default_require_sync,
|
|
|
|
|
orte_odls_default_restart_proc
|
2006-09-14 21:29:51 +00:00
|
|
|
};
|
|
|
|
|
|
2010-04-17 01:02:41 +00:00
|
|
|
|
2010-03-28 16:08:05 +00:00
|
|
|
static bool odls_default_child_died(orte_odls_child_t *child)
|
2006-09-14 21:29:51 +00:00
|
|
|
{
|
|
|
|
|
time_t end;
|
|
|
|
|
pid_t ret;
|
2006-11-13 18:51:18 +00:00
|
|
|
struct timeval t;
|
|
|
|
|
fd_set bogus;
|
|
|
|
|
|
2010-03-28 16:08:05 +00:00
|
|
|
end = time(NULL) + orte_odls_globals.timeout_before_sigkill;
|
2006-09-14 21:29:51 +00:00
|
|
|
do {
|
2010-03-28 16:08:05 +00:00
|
|
|
ret = waitpid(child->pid, &child->exit_code, WNOHANG);
|
|
|
|
|
if (child->pid == ret) {
|
2009-11-19 19:43:10 +00:00
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"%s odls:default:WAITPID INDICATES PROC %d IS DEAD",
|
2010-03-28 16:08:05 +00:00
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), (int)(child->pid)));
|
2006-09-14 21:29:51 +00:00
|
|
|
/* It died -- return success */
|
|
|
|
|
return true;
|
2008-02-28 01:57:57 +00:00
|
|
|
} else if (0 == ret) {
|
|
|
|
|
/* with NOHANG specified, if a process has already exited
|
|
|
|
|
* while waitpid was registered, then waitpid returns 0
|
|
|
|
|
* as there is no error - this is a race condition problem
|
|
|
|
|
* that occasionally causes us to incorrectly report a proc
|
|
|
|
|
* as refusing to die. Unfortunately, errno may not be reset
|
|
|
|
|
* by waitpid in this case, so we cannot check it - just assume
|
|
|
|
|
* the proc has indeed died
|
|
|
|
|
*/
|
2009-11-19 19:43:10 +00:00
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"%s odls:default:WAITPID INDICATES PROC %d HAS ALREADY EXITED",
|
2010-03-28 16:08:05 +00:00
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), (int)(child->pid)));
|
2008-02-28 01:57:57 +00:00
|
|
|
return true;
|
2006-09-14 21:29:51 +00:00
|
|
|
} else if (-1 == ret && ECHILD == errno) {
|
|
|
|
|
/* The pid no longer exists, so we'll call this "good
|
|
|
|
|
enough for government work" */
|
2009-11-19 19:43:10 +00:00
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"%s odls:default:WAITPID INDICATES PID %d NO LONGER EXISTS",
|
2010-03-28 16:08:05 +00:00
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), (int)(child->pid)));
|
2006-09-14 21:29:51 +00:00
|
|
|
return true;
|
|
|
|
|
}
|
2008-02-28 01:57:57 +00:00
|
|
|
|
This commit is the first of several steps in a paffinity makeover
extravaganza.
= Short version =
This commit does several things, but the short version is that it
re-orients the error message creation of the ODLS default module to
generate error strings in the child process for errors that occur
after the fork but before the exec (such errors are ''usually''
related to paffinity). A show_help string is rendered in the child
and then IPC'ed up to the parent, who displays the string through
normal ORTE show_help aggregation mechanisms. We also broke up the
ginormous paffinity-setting logic into a few separate functions, both
to help us understand the code, and hopefully to ease future
maintenance.
The logic for the ODLS default binding should not have changed -- this
is mainly a code reshuffle and improvement on error reporting.
= Rationale =
The reasoning for this commit is complex. As mentioned above, it's
the first step in some paffinity cleanup. Here's the line of dominoes
that must fall (in this order):
1. Add hwloc paffinity component (already done).
1. While testing hwloc, we discovered that the error reporting from
the ODLS default module was abysmal. So we fixed it.
1. Further, we reorganized the code in the odsl_default_module.c a bit
to help our understanding of it.
1. We also discovered a few bugs in the original ODLS default module
logic that existed before this code shuffle; separate tickets
will be filed to fix them.
1. Next up will be some improvements to paffinity / odls default to
make the act of binding to a core ensure to bind to ''all''
hardware threads contained in that core (similar for sockets:
binding to a socket will bind to ''all'' hardware threads in that
socket).
1. Next will be improvements to paffinity to expose binding to
hardware threads through the paffinity framework API.
1. Finally, we'll expose these binding controls to the user (e.g.,
through mpirun command line arguments, MCA parameters, etc.).
This commit represents the first few bullets; the last 4 bullets are
being worked on right now, but there is no definite timeline for
completion.
= Miscelaneous =
A few points worth mentioning:
* We have tested this new code a bunch; we're pretty sure it behaves
just like the trunk -- but with better / more precise error
reporting. More testing is needed on a wider array of platforms,
however.
* A big comment at the top of odls_default_module.c explains the
(new) general scheme for the error reporting.
* The error reporting in the parent process is now really dumb;
almost all the intelligence about creating error messages is in the
child.
* The show_help file was renamed to be more consistent with other
help files (help-odls-default.txt -> help-orte-odls-default.txt)
* Removed the use of sched_yield() because of recent changes in the
Linux 2.6.3x kernels. We already had an #else clause for
select()'ing for 1us if we didn't have sched_yield() -- that is now
the only code path. This is not a performance-critical section of
the code, so this shouldn't be controversial.
* Replaced the macro-based error reporting with function-based
reporting. It's a bit more bulky, but it helped us understand the
code and saved us multiple times with compile-time parameter
checking, etc.
* Cleaned up the use of several show_help messages to ensure that
they mapped to real messages in help*.txt files.
This commit was SVN r23652.
2010-08-24 19:38:29 +00:00
|
|
|
/* Bogus delay for 1 usec (sched_yeild() -- even if we have it
|
|
|
|
|
-- changed behavior in 2.6.3x Linux flavors to be
|
|
|
|
|
undesirable. */
|
2006-11-13 18:51:18 +00:00
|
|
|
t.tv_sec = 0;
|
|
|
|
|
t.tv_usec = 1;
|
|
|
|
|
FD_ZERO(&bogus);
|
|
|
|
|
FD_SET(0, &bogus);
|
|
|
|
|
select(1, &bogus, NULL, NULL, &t);
|
2006-09-14 21:29:51 +00:00
|
|
|
} while (time(NULL) < end);
|
|
|
|
|
|
|
|
|
|
/* The child didn't die, so return false */
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-10 15:02:10 +00:00
|
|
|
static int odls_default_kill_local(pid_t pid, int signum)
|
2006-09-14 21:29:51 +00:00
|
|
|
{
|
2010-02-04 15:47:20 +00:00
|
|
|
if (orte_forward_job_control) {
|
|
|
|
|
pid = -pid;
|
|
|
|
|
}
|
2007-10-10 15:02:10 +00:00
|
|
|
if (0 != kill(pid, signum)) {
|
2009-11-19 19:43:10 +00:00
|
|
|
if (ESRCH != errno) {
|
|
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"%s odls:default:SENT KILL %d TO PID %d GOT ERRNO %d",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), signum, (int)pid, errno));
|
|
|
|
|
return errno;
|
|
|
|
|
}
|
2006-09-14 21:29:51 +00:00
|
|
|
}
|
2009-11-19 19:43:10 +00:00
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"%s odls:default:SENT KILL %d TO PID %d SUCCESS",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), signum, (int)pid));
|
2007-10-10 15:02:10 +00:00
|
|
|
return 0;
|
2006-09-14 21:29:51 +00:00
|
|
|
}
|
|
|
|
|
|
2010-03-05 13:22:12 +00:00
|
|
|
int orte_odls_default_kill_local_procs(opal_pointer_array_t *procs)
|
2006-09-14 21:29:51 +00:00
|
|
|
{
|
|
|
|
|
int rc;
|
Bring over the update to terminate orteds that are generated by a dynamic spawn such as comm_spawn. This introduces the concept of a job "family" - i.e., jobs that have a parent/child relationship. Comm_spawn'ed jobs have a parent (the one that spawned them). We track that relationship throughout the lineage - i.e., if a comm_spawned job in turn calls comm_spawn, then it has a parent (the one that spawned it) and a "root" job (the original job that started things).
Accordingly, there are new APIs to the name service to support the ability to get a job's parent, root, immediate children, and all its descendants. In addition, the terminate_job, terminate_orted, and signal_job APIs for the PLS have been modified to accept attributes that define the extent of their actions. For example, doing a "terminate_job" with an attribute of ORTE_NS_INCLUDE_DESCENDANTS will terminate the given jobid AND all jobs that descended from it.
I have tested this capability on a MacBook under rsh, Odin under SLURM, and LANL's Flash (bproc). It worked successfully on non-MPI jobs (both simple and including a spawn), and MPI jobs (again, both simple and with a spawn).
This commit was SVN r12597.
2006-11-14 19:34:59 +00:00
|
|
|
|
2010-03-05 13:22:12 +00:00
|
|
|
if (ORTE_SUCCESS != (rc = orte_odls_base_default_kill_local_procs(procs,
|
2007-10-10 15:02:10 +00:00
|
|
|
odls_default_kill_local, odls_default_child_died))) {
|
2006-09-14 21:29:51 +00:00
|
|
|
ORTE_ERROR_LOG(rc);
|
2007-10-10 15:02:10 +00:00
|
|
|
return rc;
|
2006-09-14 21:29:51 +00:00
|
|
|
}
|
2007-10-10 15:02:10 +00:00
|
|
|
return ORTE_SUCCESS;
|
2006-09-14 21:29:51 +00:00
|
|
|
}
|
|
|
|
|
|
This commit is the first of several steps in a paffinity makeover
extravaganza.
= Short version =
This commit does several things, but the short version is that it
re-orients the error message creation of the ODLS default module to
generate error strings in the child process for errors that occur
after the fork but before the exec (such errors are ''usually''
related to paffinity). A show_help string is rendered in the child
and then IPC'ed up to the parent, who displays the string through
normal ORTE show_help aggregation mechanisms. We also broke up the
ginormous paffinity-setting logic into a few separate functions, both
to help us understand the code, and hopefully to ease future
maintenance.
The logic for the ODLS default binding should not have changed -- this
is mainly a code reshuffle and improvement on error reporting.
= Rationale =
The reasoning for this commit is complex. As mentioned above, it's
the first step in some paffinity cleanup. Here's the line of dominoes
that must fall (in this order):
1. Add hwloc paffinity component (already done).
1. While testing hwloc, we discovered that the error reporting from
the ODLS default module was abysmal. So we fixed it.
1. Further, we reorganized the code in the odsl_default_module.c a bit
to help our understanding of it.
1. We also discovered a few bugs in the original ODLS default module
logic that existed before this code shuffle; separate tickets
will be filed to fix them.
1. Next up will be some improvements to paffinity / odls default to
make the act of binding to a core ensure to bind to ''all''
hardware threads contained in that core (similar for sockets:
binding to a socket will bind to ''all'' hardware threads in that
socket).
1. Next will be improvements to paffinity to expose binding to
hardware threads through the paffinity framework API.
1. Finally, we'll expose these binding controls to the user (e.g.,
through mpirun command line arguments, MCA parameters, etc.).
This commit represents the first few bullets; the last 4 bullets are
being worked on right now, but there is no definite timeline for
completion.
= Miscelaneous =
A few points worth mentioning:
* We have tested this new code a bunch; we're pretty sure it behaves
just like the trunk -- but with better / more precise error
reporting. More testing is needed on a wider array of platforms,
however.
* A big comment at the top of odls_default_module.c explains the
(new) general scheme for the error reporting.
* The error reporting in the parent process is now really dumb;
almost all the intelligence about creating error messages is in the
child.
* The show_help file was renamed to be more consistent with other
help files (help-odls-default.txt -> help-orte-odls-default.txt)
* Removed the use of sched_yield() because of recent changes in the
Linux 2.6.3x kernels. We already had an #else clause for
select()'ing for 1us if we didn't have sched_yield() -- that is now
the only code path. This is not a performance-critical section of
the code, so this shouldn't be controversial.
* Replaced the macro-based error reporting with function-based
reporting. It's a bit more bulky, but it helped us understand the
code and saved us multiple times with compile-time parameter
checking, etc.
* Cleaned up the use of several show_help messages to ensure that
they mapped to real messages in help*.txt files.
This commit was SVN r23652.
2010-08-24 19:38:29 +00:00
|
|
|
|
|
|
|
|
static void set_handler_default(int sig)
|
|
|
|
|
{
|
|
|
|
|
struct sigaction act;
|
|
|
|
|
|
|
|
|
|
act.sa_handler = SIG_DFL;
|
|
|
|
|
act.sa_flags = 0;
|
|
|
|
|
sigemptyset(&act.sa_mask);
|
|
|
|
|
|
|
|
|
|
sigaction(sig, &act, (struct sigaction *)0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Internal function to write a rendered show_help message back up the
|
|
|
|
|
* pipe to the waiting parent.
|
|
|
|
|
*/
|
|
|
|
|
static int write_help_msg(int fd, pipe_err_msg_t *msg, const char *file,
|
|
|
|
|
const char *topic, va_list ap)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
char *str;
|
|
|
|
|
|
|
|
|
|
if (NULL == file || NULL == topic) {
|
|
|
|
|
return OPAL_ERR_BAD_PARAM;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
str = opal_show_help_vstring(file, topic, true, ap);
|
|
|
|
|
|
|
|
|
|
msg->file_str_len = (int) strlen(file);
|
|
|
|
|
if (msg->file_str_len > MAX_FILE_LEN) {
|
|
|
|
|
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
|
|
|
|
|
return ORTE_ERR_BAD_PARAM;
|
|
|
|
|
}
|
|
|
|
|
msg->topic_str_len = (int) strlen(topic);
|
|
|
|
|
if (msg->topic_str_len > MAX_TOPIC_LEN) {
|
|
|
|
|
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
|
|
|
|
|
return ORTE_ERR_BAD_PARAM;
|
|
|
|
|
}
|
|
|
|
|
msg->msg_str_len = (int) strlen(str);
|
|
|
|
|
|
|
|
|
|
/* Only keep writing if each write() succeeds */
|
|
|
|
|
if (OPAL_SUCCESS != (ret = opal_fd_write(fd, sizeof(*msg), msg))) {
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if (msg->file_str_len > 0 &&
|
|
|
|
|
OPAL_SUCCESS != (ret = opal_fd_write(fd, msg->file_str_len, file))) {
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if (msg->topic_str_len > 0 &&
|
|
|
|
|
OPAL_SUCCESS != (ret = opal_fd_write(fd, msg->topic_str_len, topic))) {
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if (msg->msg_str_len > 0 &&
|
|
|
|
|
OPAL_SUCCESS != (ret = opal_fd_write(fd, msg->msg_str_len, str))) {
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
free(str);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Called from the child to send a warning show_help message up the
|
|
|
|
|
pipe to the waiting parent. */
|
|
|
|
|
static int send_warn_show_help(int fd, const char *file,
|
|
|
|
|
const char *topic, ...)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
va_list ap;
|
|
|
|
|
pipe_err_msg_t msg;
|
|
|
|
|
|
|
|
|
|
msg.fatal = false;
|
|
|
|
|
msg.exit_status = 0; /* ignored */
|
|
|
|
|
|
|
|
|
|
/* Send it */
|
|
|
|
|
va_start(ap, topic);
|
|
|
|
|
ret = write_help_msg(fd, &msg, file, topic, ap);
|
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Called from the child to send an error message up the pipe to the
|
|
|
|
|
waiting parent. */
|
|
|
|
|
static void send_error_show_help(int fd, int exit_status,
|
|
|
|
|
const char *file, const char *topic, ...)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
va_list ap;
|
|
|
|
|
pipe_err_msg_t msg;
|
|
|
|
|
|
|
|
|
|
msg.fatal = true;
|
|
|
|
|
msg.exit_status = exit_status;
|
|
|
|
|
|
|
|
|
|
/* Send it */
|
|
|
|
|
va_start(ap, topic);
|
|
|
|
|
ret = write_help_msg(fd, &msg, file, topic, ap);
|
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
|
|
exit(exit_status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Bind the process to a specific slot list
|
|
|
|
|
*/
|
|
|
|
|
static int bind_to_slot_list(orte_app_context_t* context,
|
|
|
|
|
orte_odls_child_t *child,
|
|
|
|
|
orte_odls_job_t *jobdat,
|
|
|
|
|
bool *bound, int pipe_fd)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
opal_paffinity_base_cpu_set_t mask;
|
|
|
|
|
char *msg = NULL;
|
|
|
|
|
|
|
|
|
|
*bound = false;
|
|
|
|
|
|
|
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"%s odls:default:fork binding child %s to slot_list %s",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME),
|
|
|
|
|
ORTE_NAME_PRINT(child->name),
|
|
|
|
|
child->slot_list));
|
|
|
|
|
if (opal_paffinity_alone) {
|
|
|
|
|
send_error_show_help(pipe_fd, 1,
|
|
|
|
|
"help-orte-odls-default.txt",
|
|
|
|
|
"slot list and paffinity_alone",
|
|
|
|
|
orte_process_info.nodename, context->app);
|
|
|
|
|
/* Does not return */
|
|
|
|
|
}
|
|
|
|
|
if (orte_report_bindings) {
|
|
|
|
|
opal_output(0, "%s odls:default:fork binding child %s to slot_list %s",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME),
|
|
|
|
|
ORTE_NAME_PRINT(child->name), child->slot_list);
|
|
|
|
|
}
|
|
|
|
|
rc = opal_paffinity_base_slot_list_set((long)child->name->vpid,
|
|
|
|
|
child->slot_list, &mask);
|
|
|
|
|
if (ORTE_SUCCESS != rc) {
|
|
|
|
|
if (ORTE_ERR_NOT_SUPPORTED == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
/* OS doesn't support providing topology information */
|
|
|
|
|
send_error_show_help(pipe_fd, 1, "help-orte-odls-default.txt",
|
|
|
|
|
"binding not supported",
|
|
|
|
|
orte_process_info.nodename, context->app);
|
|
|
|
|
/* Does not return */
|
|
|
|
|
}
|
|
|
|
|
asprintf(&msg, "opal_paffinity_base_slot_list_set() returned \"%s\"",
|
|
|
|
|
opal_strerror(OPAL_SOS_GET_ERROR_CODE(rc)));
|
|
|
|
|
if (NULL == msg) {
|
|
|
|
|
msg = "opal_paffinity_base_slot_list_set() returned failure";
|
|
|
|
|
}
|
|
|
|
|
send_error_show_help(pipe_fd, 1, "help-orte-odls-default.txt",
|
|
|
|
|
"binding generic error",
|
|
|
|
|
orte_process_info.nodename, context->app, msg,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
/* Does not return */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* if we didn't wind up bound, then generate a warning unless
|
|
|
|
|
suppressed */
|
|
|
|
|
OPAL_PAFFINITY_PROCESS_IS_BOUND((mask), bound);
|
|
|
|
|
if (!bound && orte_odls_base.warn_if_not_bound) {
|
|
|
|
|
send_warn_show_help(pipe_fd, "help-orte-odls-base.txt",
|
|
|
|
|
"warn not bound", "slot list"
|
|
|
|
|
"Request resulted in binding to all available processors",
|
|
|
|
|
orte_process_info.nodename, context->app,
|
|
|
|
|
"bind to slot list", child->slot_list);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ORTE_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This function always prints a message: it may be a warning or an
|
|
|
|
|
* error.
|
|
|
|
|
*
|
|
|
|
|
* If binding is not required for this process, then print a simple
|
|
|
|
|
* warning message and return an error code. If binding *is*
|
|
|
|
|
* required, then send an error message up the pipe to the parent and
|
|
|
|
|
* exit.
|
|
|
|
|
*/
|
|
|
|
|
static int bind_failed_msg(const char *msg, orte_mapping_policy_t policy,
|
|
|
|
|
int return_code_if_warning,
|
|
|
|
|
int pipe_fd, const char *app_name,
|
|
|
|
|
const char *filename, int line_num)
|
|
|
|
|
{
|
|
|
|
|
/* If binding is not required, then send a warning up the pipe and
|
|
|
|
|
then return an error code. */
|
|
|
|
|
if (ORTE_BINDING_NOT_REQUIRED(policy)) {
|
|
|
|
|
send_warn_show_help(pipe_fd,
|
|
|
|
|
"help-orte-odls-default.txt", "not bound",
|
|
|
|
|
orte_process_info.nodename, app_name, msg,
|
|
|
|
|
filename, line_num);
|
|
|
|
|
return return_code_if_warning;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If binding is required, send an error up the pipe (which exits
|
|
|
|
|
-- it doesn't return). */
|
|
|
|
|
send_error_show_help(pipe_fd, 1, "help-orte-odls-default.txt",
|
|
|
|
|
"binding generic error",
|
|
|
|
|
orte_process_info.nodename, app_name, msg,
|
|
|
|
|
filename, line_num);
|
|
|
|
|
/* Does not return */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Similar to bind_failed_msg(), but if binding is not required, do
|
|
|
|
|
* not output a message (just return an error code). If binding is
|
|
|
|
|
* required, handling is the same as for bind_failed_msg().
|
|
|
|
|
*/
|
|
|
|
|
static int bind_failed(const char *msg, orte_mapping_policy_t policy,
|
|
|
|
|
int return_code_if_warning,
|
|
|
|
|
int pipe_fd, const char *app_name,
|
|
|
|
|
const char *filename, int line_num)
|
|
|
|
|
{
|
|
|
|
|
if (ORTE_BINDING_NOT_REQUIRED(policy)) {
|
|
|
|
|
return return_code_if_warning;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This won't return, but use "return" statement here so that the
|
|
|
|
|
compiler won't complain. */
|
|
|
|
|
return bind_failed_msg(msg, policy, 0, pipe_fd, app_name,
|
|
|
|
|
filename, line_num);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Bind the process to a core
|
|
|
|
|
*/
|
|
|
|
|
static int bind_to_core(orte_app_context_t* context,
|
|
|
|
|
orte_odls_child_t *child,
|
|
|
|
|
orte_odls_job_t *jobdat,
|
|
|
|
|
bool *bound, int pipe_fd)
|
|
|
|
|
{
|
|
|
|
|
bool flag;
|
|
|
|
|
int i, rc;
|
|
|
|
|
char *tmp, *msg;
|
|
|
|
|
int16_t n;
|
|
|
|
|
orte_node_rank_t nrank, lrank;
|
|
|
|
|
opal_paffinity_base_cpu_set_t mask;
|
|
|
|
|
int target_socket, npersocket, logical_skt;
|
|
|
|
|
int logical_cpu, phys_core, phys_cpu, ncpu;
|
|
|
|
|
|
|
|
|
|
*bound = false;
|
|
|
|
|
|
|
|
|
|
/* we want to bind this proc to a specific core, or multiple cores
|
|
|
|
|
if the cpus_per_rank is > 0 */
|
|
|
|
|
OPAL_OUTPUT_VERBOSE((5, orte_odls_globals.output,
|
|
|
|
|
"%s odls:default:fork binding child %s to core(s) cpus/rank %d stride %d",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME),
|
|
|
|
|
ORTE_NAME_PRINT(child->name),
|
|
|
|
|
(int)jobdat->cpus_per_rank, (int)jobdat->stride));
|
|
|
|
|
|
|
|
|
|
/* get the node rank */
|
|
|
|
|
if (ORTE_NODE_RANK_INVALID ==
|
|
|
|
|
(nrank = orte_ess.get_node_rank(child->name))) {
|
|
|
|
|
send_error_show_help(pipe_fd, 1, "help-orte-odls-default.txt",
|
|
|
|
|
"binding generic error",
|
|
|
|
|
orte_process_info.nodename, context->app,
|
|
|
|
|
"ess.get_node_rank returned NODE_RANK_INVALID",
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
/* Does not return */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* get the local rank */
|
|
|
|
|
if (ORTE_LOCAL_RANK_INVALID ==
|
|
|
|
|
(lrank = orte_ess.get_local_rank(child->name))) {
|
|
|
|
|
send_error_show_help(pipe_fd, 1, "help-orte-odls-default.txt",
|
|
|
|
|
"binding generic error",
|
|
|
|
|
orte_process_info.nodename, context->app,
|
|
|
|
|
"ess.get_local_rank returned LOCAL_RANK_INVALID",
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
/* Does not return */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* init the mask */
|
|
|
|
|
OPAL_PAFFINITY_CPU_ZERO(mask);
|
|
|
|
|
if (ORTE_MAPPING_NPERXXX & jobdat->policy) {
|
|
|
|
|
/* we need to balance the children from this job
|
|
|
|
|
across the available sockets */
|
|
|
|
|
npersocket = jobdat->num_local_procs / orte_odls_globals.num_sockets;
|
|
|
|
|
/* determine the socket to use based on those available */
|
|
|
|
|
if (npersocket < 2) {
|
|
|
|
|
/* if we only have 1/sock, or we have less procs than
|
|
|
|
|
sockets, then just put it on the lrank socket */
|
|
|
|
|
logical_skt = lrank;
|
|
|
|
|
} else if (ORTE_MAPPING_BYSOCKET & jobdat->policy) {
|
|
|
|
|
logical_skt = lrank % npersocket;
|
|
|
|
|
} else {
|
|
|
|
|
logical_skt = lrank / npersocket;
|
|
|
|
|
}
|
|
|
|
|
if (orte_odls_globals.bound) {
|
|
|
|
|
/* if we are already bound (by some other entity), use
|
|
|
|
|
this as an index into our available sockets */
|
|
|
|
|
for (n = target_socket = 0;
|
|
|
|
|
n < logical_skt &&
|
|
|
|
|
target_socket < opal_bitmap_size(&orte_odls_globals.sockets);
|
|
|
|
|
target_socket++) {
|
|
|
|
|
if (opal_bitmap_is_set_bit(&orte_odls_globals.sockets,
|
|
|
|
|
target_socket)) {
|
|
|
|
|
n++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/* Did we have enough sockets? */
|
|
|
|
|
if (n < logical_skt) {
|
|
|
|
|
return bind_failed_msg("not enough processor sockets available",
|
|
|
|
|
jobdat->policy,
|
|
|
|
|
ORTE_ERR_NOT_FOUND,
|
|
|
|
|
pipe_fd, context->app,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
rc = opal_paffinity_base_get_physical_socket_id(logical_skt,
|
|
|
|
|
&target_socket);
|
|
|
|
|
if (ORTE_ERR_NOT_SUPPORTED == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
return bind_failed_msg("OS does not provide processor topology info (physical socket ID)",
|
|
|
|
|
jobdat->policy,
|
|
|
|
|
ORTE_ERR_NOT_FOUND,
|
|
|
|
|
pipe_fd, context->app,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"%s odls:default:fork child %s local rank %d npersocket %d logical socket %d target socket %d",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), ORTE_NAME_PRINT(child->name), lrank,
|
|
|
|
|
npersocket, logical_skt, target_socket));
|
|
|
|
|
/* set the starting point */
|
|
|
|
|
logical_cpu = (lrank % npersocket) * jobdat->cpus_per_rank;
|
|
|
|
|
/* bind to this socket */
|
|
|
|
|
goto bind_socket;
|
|
|
|
|
} else if (ORTE_MAPPING_BYSOCKET & jobdat->policy) {
|
|
|
|
|
/* this corresponds to a mapping policy where
|
|
|
|
|
* local rank 0 goes on socket 0, and local
|
|
|
|
|
* rank 1 goes on socket 1, etc. - round robin
|
|
|
|
|
* until all ranks are mapped
|
|
|
|
|
*
|
|
|
|
|
* NOTE: we already know our number of sockets
|
|
|
|
|
* from when we initialized
|
|
|
|
|
*/
|
|
|
|
|
rc = opal_paffinity_base_get_physical_socket_id(lrank % orte_odls_globals.num_sockets, &target_socket);
|
|
|
|
|
if (OPAL_SUCCESS != rc) {
|
|
|
|
|
/* This may be a small memory leak, but this child is
|
|
|
|
|
exiting soon anyway; keep the logic simple by not
|
|
|
|
|
worrying about the small leak. */
|
|
|
|
|
asprintf(&msg, "opal_paffinity_base_get_physical_socket_id(%d) returned \"%s\"",
|
|
|
|
|
(lrank % orte_odls_globals.num_sockets),
|
|
|
|
|
opal_strerror(OPAL_SOS_GET_ERROR_CODE(rc)));
|
|
|
|
|
if (NULL == msg) {
|
|
|
|
|
msg = "opal_paffinity_base_get_physical_socket_id() failed";
|
|
|
|
|
}
|
|
|
|
|
if (OPAL_ERR_NOT_SUPPORTED == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
msg = "OS does not provide processor topology information (physical socket ID)";
|
|
|
|
|
}
|
|
|
|
|
return bind_failed(msg, jobdat->policy, ORTE_ERR_NOT_SUPPORTED,
|
|
|
|
|
pipe_fd, context->app, __FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"bysocket lrank %d numsocks %d logical socket %d target socket %d", (int)lrank,
|
|
|
|
|
(int)orte_odls_globals.num_sockets,
|
|
|
|
|
(int)(lrank % orte_odls_globals.num_sockets),
|
|
|
|
|
target_socket));
|
|
|
|
|
/* my starting core within this socket has to be
|
|
|
|
|
offset by cpus_per_rank */
|
|
|
|
|
logical_cpu = (lrank / orte_odls_globals.num_sockets) * jobdat->cpus_per_rank;
|
|
|
|
|
|
|
|
|
|
bind_socket:
|
|
|
|
|
/* cycle across the cpus_per_rank */
|
|
|
|
|
for (n=0; n < jobdat->cpus_per_rank; n++) {
|
|
|
|
|
/* get the physical core within this target socket */
|
|
|
|
|
rc = opal_paffinity_base_get_physical_core_id(target_socket, logical_cpu, &phys_core);
|
|
|
|
|
if (OPAL_SUCCESS != rc) {
|
|
|
|
|
/* Seem comment above about "This may be a small
|
|
|
|
|
memory leak" */
|
|
|
|
|
asprintf(&msg, "opal_paffinity_base_get_physical_core_id(%d, %d) returned \"%s\"",
|
|
|
|
|
target_socket, logical_cpu,
|
|
|
|
|
opal_strerror(OPAL_SOS_GET_ERROR_CODE(rc)));
|
|
|
|
|
if (NULL == msg) {
|
|
|
|
|
msg = "opal_paffinity_base_get_physical_core_id() failed";
|
|
|
|
|
}
|
|
|
|
|
if (OPAL_ERR_NOT_SUPPORTED == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
msg = "OS does not provide processor topology information (physical core ID)";
|
|
|
|
|
}
|
|
|
|
|
return bind_failed(msg, jobdat->policy, ORTE_ERR_NOT_SUPPORTED,
|
|
|
|
|
pipe_fd, context->app, __FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
/* map this to a physical cpu on this node */
|
|
|
|
|
if (ORTE_SUCCESS != (rc = opal_paffinity_base_get_map_to_processor_id(target_socket, phys_core, &phys_cpu))) {
|
|
|
|
|
/* Seem comment above about "This may be a small
|
|
|
|
|
memory leak" */
|
|
|
|
|
asprintf(&msg, "opal_paffinity_base_get_map_to_processor_id(%d, %d) returned \"%s\"",
|
|
|
|
|
target_socket, phys_core,
|
|
|
|
|
opal_strerror(OPAL_SOS_GET_ERROR_CODE(rc)));
|
|
|
|
|
if (NULL == msg) {
|
|
|
|
|
msg = "opal_paffinity_base_get_map_to_processor_id() failed";
|
|
|
|
|
}
|
|
|
|
|
if (OPAL_ERR_NOT_SUPPORTED == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
msg = "OS does not provide processor topology information (map socket,core->ID)";
|
|
|
|
|
}
|
|
|
|
|
return bind_failed(msg, jobdat->policy, ORTE_ERR_NOT_SUPPORTED,
|
|
|
|
|
pipe_fd, context->app, __FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
/* are we bound? */
|
|
|
|
|
if (orte_odls_globals.bound) {
|
|
|
|
|
/* see if this physical cpu is available to us */
|
|
|
|
|
if (!OPAL_PAFFINITY_CPU_ISSET(phys_cpu, orte_odls_globals.my_cores)) {
|
|
|
|
|
/* no it isn't - skip it */
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"%s odls:default:fork mapping phys socket %d core %d to phys_cpu %d",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME),
|
|
|
|
|
target_socket, phys_core, phys_cpu));
|
|
|
|
|
OPAL_PAFFINITY_CPU_SET(phys_cpu, mask);
|
|
|
|
|
/* increment logical cpu */
|
|
|
|
|
logical_cpu += jobdat->stride;
|
|
|
|
|
}
|
|
|
|
|
if (orte_report_bindings) {
|
|
|
|
|
tmp = opal_paffinity_base_print_binding(mask);
|
|
|
|
|
opal_output(0, "%s odls:default:fork binding child %s to socket %d cpus %s",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME),
|
|
|
|
|
ORTE_NAME_PRINT(child->name), target_socket, tmp);
|
|
|
|
|
free(tmp);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* my starting core has to be offset by cpus_per_rank */
|
|
|
|
|
logical_cpu = nrank * jobdat->cpus_per_rank;
|
|
|
|
|
for (n=0; n < jobdat->cpus_per_rank; n++) {
|
|
|
|
|
/* are we bound? */
|
|
|
|
|
if (orte_odls_globals.bound) {
|
|
|
|
|
/* if we are bound, then use the logical_cpu as an
|
|
|
|
|
index against our available cores */
|
|
|
|
|
ncpu = 0;
|
|
|
|
|
for (i = 0; i < OPAL_PAFFINITY_BITMASK_CPU_MAX &&
|
|
|
|
|
ncpu <= logical_cpu; i++) {
|
|
|
|
|
if (OPAL_PAFFINITY_CPU_ISSET(i,
|
|
|
|
|
orte_odls_globals.my_cores)) {
|
|
|
|
|
ncpu++;
|
|
|
|
|
phys_cpu = i;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/* if we don't have enough processors, that is an
|
|
|
|
|
error */
|
|
|
|
|
if (ncpu <= logical_cpu) {
|
|
|
|
|
if (ORTE_BINDING_NOT_REQUIRED(jobdat->policy)) {
|
|
|
|
|
return ORTE_ERR_NOT_SUPPORTED;
|
|
|
|
|
}
|
|
|
|
|
send_error_show_help(pipe_fd, 1,
|
|
|
|
|
"help-orte-odls-default.txt",
|
|
|
|
|
"binding generic error",
|
|
|
|
|
orte_process_info.nodename,
|
|
|
|
|
context->app,
|
|
|
|
|
"not enough logical processors",
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
/* Does not return */
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* if we are not bound, then all processors are
|
|
|
|
|
available to us, so index into the node's array to
|
|
|
|
|
get the physical cpu */
|
|
|
|
|
rc = opal_paffinity_base_get_physical_processor_id(logical_cpu,
|
|
|
|
|
&phys_cpu);
|
|
|
|
|
if (OPAL_SUCCESS != rc) {
|
|
|
|
|
/* No processor to bind to */
|
|
|
|
|
/* Seem comment above about "This may be a small
|
|
|
|
|
memory leak" */
|
|
|
|
|
asprintf(&msg, "opal_paffinity_base_get_physical_processor_id(%d) returned \"%s\"",
|
|
|
|
|
logical_cpu,
|
|
|
|
|
opal_strerror(OPAL_SOS_GET_ERROR_CODE(rc)));
|
|
|
|
|
if (NULL == msg) {
|
|
|
|
|
msg = "opal_paffinity_base_get_physical_processor_id() failed";
|
|
|
|
|
}
|
|
|
|
|
if (OPAL_ERR_NOT_SUPPORTED == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
msg = "OS does not provide processor topology information (physical processor ID)";
|
|
|
|
|
}
|
|
|
|
|
return bind_failed(msg, jobdat->policy,
|
|
|
|
|
ORTE_ERR_NOT_SUPPORTED,
|
|
|
|
|
pipe_fd, context->app,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
OPAL_PAFFINITY_CPU_SET(phys_cpu, mask);
|
|
|
|
|
/* increment logical cpu */
|
|
|
|
|
logical_cpu += jobdat->stride;
|
|
|
|
|
}
|
|
|
|
|
if (orte_report_bindings) {
|
|
|
|
|
tmp = opal_paffinity_base_print_binding(mask);
|
|
|
|
|
opal_output(0, "%s odls:default:fork binding child %s to cpus %s",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME),
|
|
|
|
|
ORTE_NAME_PRINT(child->name), tmp);
|
|
|
|
|
free(tmp);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Bind me! */
|
|
|
|
|
if (ORTE_SUCCESS != (rc = opal_paffinity_base_set(mask))) {
|
|
|
|
|
/* Seem comment above about "This may be a small memory
|
|
|
|
|
leak" */
|
|
|
|
|
asprintf(&msg, "opal_paffinity_base_set returned \"%s\"",
|
|
|
|
|
opal_strerror(OPAL_SOS_GET_ERROR_CODE(rc)));
|
|
|
|
|
if (NULL == msg) {
|
|
|
|
|
msg = "opal_paffinity_base_set() failed";
|
|
|
|
|
}
|
|
|
|
|
return bind_failed(msg,
|
|
|
|
|
jobdat->policy,
|
|
|
|
|
OPAL_SOS_GET_ERROR_CODE(rc),
|
|
|
|
|
pipe_fd, context->app, __FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
*bound = true;
|
|
|
|
|
|
|
|
|
|
/* If the above work resulted in binding to everything (i.e.,
|
|
|
|
|
effectively not binding), warn -- unless the warning is
|
|
|
|
|
suppressed. */
|
|
|
|
|
OPAL_PAFFINITY_PROCESS_IS_BOUND(mask, &flag);
|
|
|
|
|
if (!flag && orte_odls_base.warn_if_not_bound) {
|
|
|
|
|
send_warn_show_help(pipe_fd,
|
|
|
|
|
"help-orte-odls-default.txt",
|
|
|
|
|
"bound to everything",
|
|
|
|
|
orte_process_info.nodename, context->app,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ORTE_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int bind_to_socket(orte_app_context_t* context,
|
|
|
|
|
orte_odls_child_t *child,
|
|
|
|
|
orte_odls_job_t *jobdat,
|
|
|
|
|
bool *bound, int pipe_fd)
|
|
|
|
|
{
|
|
|
|
|
bool flag;
|
|
|
|
|
int i, rc;
|
|
|
|
|
char *tmp, *msg;
|
|
|
|
|
int16_t n;
|
|
|
|
|
orte_node_rank_t lrank;
|
|
|
|
|
opal_paffinity_base_cpu_set_t mask;
|
|
|
|
|
int target_socket, npersocket, logical_skt;
|
|
|
|
|
int logical_cpu, phys_core, phys_cpu, ncpu;
|
|
|
|
|
|
|
|
|
|
*bound = false;
|
|
|
|
|
|
|
|
|
|
/* bind this proc to a socket */
|
|
|
|
|
OPAL_OUTPUT_VERBOSE((5, orte_odls_globals.output,
|
|
|
|
|
"%s odls:default:fork binding child %s to socket",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME),
|
|
|
|
|
ORTE_NAME_PRINT(child->name)));
|
|
|
|
|
/* layout this process across the sockets based on
|
|
|
|
|
* the provided mapping policy
|
|
|
|
|
*/
|
|
|
|
|
if (ORTE_LOCAL_RANK_INVALID == (lrank = orte_ess.get_local_rank(child->name))) {
|
|
|
|
|
send_error_show_help(pipe_fd, 1, "help-orte-odls-default.txt",
|
|
|
|
|
"binding generic error",
|
|
|
|
|
orte_process_info.nodename, context->app,
|
|
|
|
|
"ess.get_local_rank returned NODE_RANK_INVALID",
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
/* Does not return */
|
|
|
|
|
}
|
|
|
|
|
if (ORTE_MAPPING_NPERXXX & jobdat->policy) {
|
|
|
|
|
/* we need to balance the children from this job
|
|
|
|
|
across the available sockets */
|
|
|
|
|
npersocket = jobdat->num_local_procs / orte_odls_globals.num_sockets;
|
|
|
|
|
/* determine the socket to use based on those available */
|
|
|
|
|
if (npersocket < 2) {
|
|
|
|
|
/* if we only have 1/sock, or we have less
|
|
|
|
|
* procs than sockets, then just put it on the
|
|
|
|
|
* lrank socket
|
|
|
|
|
*/
|
|
|
|
|
logical_skt = lrank;
|
|
|
|
|
} else if (ORTE_MAPPING_BYSOCKET & jobdat->policy) {
|
|
|
|
|
logical_skt = lrank % npersocket;
|
|
|
|
|
} else {
|
|
|
|
|
logical_skt = lrank / npersocket;
|
|
|
|
|
}
|
|
|
|
|
if (orte_odls_globals.bound) {
|
|
|
|
|
/* if we are bound, use this as an index into
|
|
|
|
|
our available sockets */
|
|
|
|
|
for (target_socket=0, n = 0; target_socket < opal_bitmap_size(&orte_odls_globals.sockets) && n < logical_skt; target_socket++) {
|
|
|
|
|
if (opal_bitmap_is_set_bit(&orte_odls_globals.sockets, target_socket)) {
|
|
|
|
|
n++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/* if we don't have enough sockets, that is an error */
|
|
|
|
|
if (n < logical_skt) {
|
|
|
|
|
return bind_failed_msg("not enough processor sockets available",
|
|
|
|
|
jobdat->policy,
|
|
|
|
|
ORTE_ERR_NOT_FOUND,
|
|
|
|
|
pipe_fd, context->app,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
rc = opal_paffinity_base_get_physical_socket_id(logical_skt, &target_socket);
|
|
|
|
|
if (ORTE_ERR_NOT_SUPPORTED == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
/* OS doesn't support providing topology
|
|
|
|
|
information */
|
|
|
|
|
return bind_failed_msg("OS does not provide processor topology info (physical socket ID)",
|
|
|
|
|
jobdat->policy,
|
|
|
|
|
ORTE_ERR_NOT_FOUND,
|
|
|
|
|
pipe_fd, context->app,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"%s odls:default:fork child %s local rank %d npersocket %d logical socket %d target socket %d",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), ORTE_NAME_PRINT(child->name), lrank,
|
|
|
|
|
npersocket, logical_skt, target_socket));
|
|
|
|
|
} else if (ORTE_MAPPING_BYSOCKET & jobdat->policy) {
|
|
|
|
|
/* this corresponds to a mapping policy where
|
|
|
|
|
* local rank 0 goes on socket 0, and local
|
|
|
|
|
* rank 1 goes on socket 1, etc. - round robin
|
|
|
|
|
* until all ranks are mapped
|
|
|
|
|
*
|
|
|
|
|
* NOTE: we already know our number of sockets
|
|
|
|
|
* from when we initialized
|
|
|
|
|
*/
|
|
|
|
|
rc = opal_paffinity_base_get_physical_socket_id(lrank % orte_odls_globals.num_sockets, &target_socket);
|
|
|
|
|
if (ORTE_ERR_NOT_SUPPORTED == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
/* OS does not support providing topology
|
|
|
|
|
information */
|
|
|
|
|
return bind_failed_msg("OS does not provide processor topology info(physical socket ID)",
|
|
|
|
|
jobdat->policy,
|
|
|
|
|
ORTE_ERR_NOT_FOUND,
|
|
|
|
|
pipe_fd, context->app,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"bysocket lrank %d numsocks %d logical socket %d target socket %d", (int)lrank,
|
|
|
|
|
(int)orte_odls_globals.num_sockets,
|
|
|
|
|
(int)(lrank % orte_odls_globals.num_sockets),
|
|
|
|
|
target_socket));
|
|
|
|
|
} else {
|
|
|
|
|
/* use a byslot-like policy where local rank 0 goes on
|
|
|
|
|
* socket 0, and local rank 1 goes on socket 0, etc.
|
|
|
|
|
* following round-robin until all ranks mapped
|
|
|
|
|
*/
|
|
|
|
|
if (orte_odls_globals.bound) {
|
|
|
|
|
/* if we are bound, then we compute the
|
|
|
|
|
* logical socket id based on the number of
|
|
|
|
|
* available cores in each socket so that each
|
|
|
|
|
* rank gets its own core, adjusting for the
|
|
|
|
|
* cpus_per_task
|
|
|
|
|
*/
|
|
|
|
|
/* Find the lrank available core, accounting
|
|
|
|
|
for cpus_per_task */
|
|
|
|
|
logical_cpu = lrank * jobdat->cpus_per_rank;
|
|
|
|
|
/* use the logical_cpu as an index against our
|
|
|
|
|
available cores */
|
|
|
|
|
ncpu = 0;
|
|
|
|
|
for (i=0; i < orte_odls_globals.num_processors && ncpu <= logical_cpu; i++) {
|
|
|
|
|
if (OPAL_PAFFINITY_CPU_ISSET(i, orte_odls_globals.my_cores)) {
|
|
|
|
|
ncpu++;
|
|
|
|
|
phys_cpu = i;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/* if we don't have enough processors, that is
|
|
|
|
|
an error */
|
|
|
|
|
if (ncpu < logical_cpu) {
|
|
|
|
|
send_error_show_help(pipe_fd, 1,
|
|
|
|
|
"help-orte-odls-default.txt",
|
|
|
|
|
"binding generic error",
|
|
|
|
|
orte_process_info.nodename,
|
|
|
|
|
context->app,
|
|
|
|
|
"not enough logical processors",
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
/* Does not return */
|
|
|
|
|
}
|
|
|
|
|
/* get the physical socket of that cpu */
|
|
|
|
|
if (ORTE_SUCCESS != (rc = opal_paffinity_base_get_map_to_socket_core(phys_cpu, &target_socket, &phys_core))) {
|
|
|
|
|
/* Seem comment above about "This may be a small
|
|
|
|
|
memory leak" */
|
|
|
|
|
asprintf(&msg, "opal_paffinity_base_get_map_to_socket_core(%d) returned \"%s\"",
|
|
|
|
|
phys_cpu, opal_strerror(OPAL_SOS_GET_ERROR_CODE(rc)));
|
|
|
|
|
if (NULL == msg) {
|
|
|
|
|
msg = "opal_paffinity_base_get_map_to_socket_core() failed";
|
|
|
|
|
}
|
|
|
|
|
if (OPAL_ERR_NOT_SUPPORTED == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
msg = "OS does not provide processor topology information (map socket,core->ID)";
|
|
|
|
|
}
|
|
|
|
|
return bind_failed(msg, jobdat->policy,
|
|
|
|
|
ORTE_ERR_NOT_SUPPORTED,
|
|
|
|
|
pipe_fd, context->app,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* if we are not bound, then just use all sockets */
|
|
|
|
|
if (1 == orte_odls_globals.num_sockets) {
|
|
|
|
|
/* if we only have one socket, then just
|
|
|
|
|
put it there */
|
|
|
|
|
rc = opal_paffinity_base_get_physical_socket_id(0, &target_socket);
|
|
|
|
|
if (ORTE_ERR_NOT_SUPPORTED == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
/* OS doesn't support providing
|
|
|
|
|
topology information */
|
|
|
|
|
return bind_failed_msg("OS does not provide processor topology info (physical socket ID)",
|
|
|
|
|
jobdat->policy,
|
|
|
|
|
ORTE_ERR_NOT_FOUND,
|
|
|
|
|
pipe_fd, context->app,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* compute the logical socket,
|
|
|
|
|
compensating for the number of
|
|
|
|
|
cpus_per_rank */
|
|
|
|
|
logical_skt = lrank / (orte_default_num_cores_per_socket / jobdat->cpus_per_rank);
|
|
|
|
|
/* wrap that around the number of sockets
|
|
|
|
|
so we round-robin */
|
|
|
|
|
logical_skt = logical_skt % orte_odls_globals.num_sockets;
|
|
|
|
|
/* now get the target physical socket */
|
|
|
|
|
rc = opal_paffinity_base_get_physical_socket_id(logical_skt, &target_socket);
|
|
|
|
|
if (ORTE_ERR_NOT_SUPPORTED == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
/* OS doesn't support providing
|
|
|
|
|
topology information */
|
|
|
|
|
return bind_failed_msg("OS does not provide processor topology info (physical socket ID)",
|
|
|
|
|
jobdat->policy,
|
|
|
|
|
ORTE_ERR_NOT_FOUND,
|
|
|
|
|
pipe_fd, context->app,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"byslot lrank %d socket %d", (int)lrank, target_socket));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
OPAL_PAFFINITY_CPU_ZERO(mask);
|
|
|
|
|
|
|
|
|
|
for (n=0; n < orte_default_num_cores_per_socket; n++) {
|
|
|
|
|
/* get the physical core within this target socket */
|
|
|
|
|
rc = opal_paffinity_base_get_physical_core_id(target_socket, n, &phys_core);
|
|
|
|
|
if (OPAL_SUCCESS != rc) {
|
|
|
|
|
/* Seem comment above about "This may be a small memory
|
|
|
|
|
leak" */
|
|
|
|
|
asprintf(&msg, "opal_paffinity_base_get_physical_core_id(%d, %d) returned \"%s\"",
|
|
|
|
|
target_socket, n,
|
|
|
|
|
opal_strerror(OPAL_SOS_GET_ERROR_CODE(rc)));
|
|
|
|
|
if (NULL == msg) {
|
|
|
|
|
msg = "opal_paffinity_base_get_physical_core_id() failed";
|
|
|
|
|
}
|
|
|
|
|
if (OPAL_ERR_NOT_SUPPORTED == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
msg = "OS does not provide processor topology information (physical core ID)";
|
|
|
|
|
}
|
|
|
|
|
return bind_failed(msg, jobdat->policy,
|
|
|
|
|
ORTE_ERR_NOT_SUPPORTED,
|
|
|
|
|
pipe_fd, context->app,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
/* map this to a physical cpu on this node */
|
|
|
|
|
if (ORTE_SUCCESS != (rc = opal_paffinity_base_get_map_to_processor_id(target_socket, phys_core, &phys_cpu))) {
|
|
|
|
|
/* Seem comment above about "This may be a small memory
|
|
|
|
|
leak" */
|
|
|
|
|
asprintf(&msg, "opal_paffinity_base_get_map_to_processor_id(%d, %d) returned \"%s\"",
|
|
|
|
|
target_socket, phys_core,
|
|
|
|
|
opal_strerror(OPAL_SOS_GET_ERROR_CODE(rc)));
|
|
|
|
|
if (NULL == msg) {
|
|
|
|
|
msg = "opal_paffinity_base_get_map_to_processor_id()";
|
|
|
|
|
}
|
|
|
|
|
if (OPAL_ERR_NOT_SUPPORTED == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
msg = "OS does not provide processor topology information (map socket,core->ID)";
|
|
|
|
|
}
|
|
|
|
|
return bind_failed(msg, jobdat->policy,
|
|
|
|
|
ORTE_ERR_NOT_SUPPORTED,
|
|
|
|
|
pipe_fd, context->app,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
/* are we bound? */
|
|
|
|
|
if (orte_odls_globals.bound) {
|
|
|
|
|
/* see if this physical cpu is available to us */
|
|
|
|
|
if (!OPAL_PAFFINITY_CPU_ISSET(phys_cpu, orte_odls_globals.my_cores)) {
|
|
|
|
|
/* no it isn't - skip it */
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"%s odls:default:fork mapping phys socket %d core %d to phys_cpu %d",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME),
|
|
|
|
|
target_socket, phys_core, phys_cpu));
|
|
|
|
|
OPAL_PAFFINITY_CPU_SET(phys_cpu, mask);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Bind me! */
|
|
|
|
|
if (ORTE_SUCCESS != (rc = opal_paffinity_base_set(mask))) {
|
|
|
|
|
/* Seem comment above about "This may be a small memory
|
|
|
|
|
leak" */
|
|
|
|
|
asprintf(&msg, "opal_paffinity_base_set() returned \"%s\"",
|
|
|
|
|
opal_strerror(OPAL_SOS_GET_ERROR_CODE(rc)));
|
|
|
|
|
if (NULL == msg) {
|
|
|
|
|
msg = "opal_paffinity_base_set() failed";
|
|
|
|
|
}
|
|
|
|
|
return bind_failed(msg,
|
|
|
|
|
jobdat->policy,
|
|
|
|
|
OPAL_SOS_GET_ERROR_CODE(rc),
|
|
|
|
|
pipe_fd, context->app, __FILE__, __LINE__);
|
|
|
|
|
}
|
|
|
|
|
*bound = true;
|
|
|
|
|
|
|
|
|
|
/* If the above work resulted in binding to everything (i.e.,
|
|
|
|
|
effectively not binding), warn -- unless the warning is
|
|
|
|
|
suppressed. */
|
|
|
|
|
OPAL_PAFFINITY_PROCESS_IS_BOUND(mask, &flag);
|
|
|
|
|
if (!flag && orte_odls_base.warn_if_not_bound) {
|
|
|
|
|
send_warn_show_help(pipe_fd,
|
|
|
|
|
"help-orte-odls-default.txt",
|
|
|
|
|
"bound to everything",
|
|
|
|
|
orte_process_info.nodename, context->app,
|
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
|
} else if (orte_report_bindings) {
|
|
|
|
|
tmp = opal_paffinity_base_print_binding(mask);
|
|
|
|
|
opal_output(0, "%s odls:default:fork binding child %s to socket %d cpus %s",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME),
|
|
|
|
|
ORTE_NAME_PRINT(child->name), target_socket, tmp);
|
|
|
|
|
free(tmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ORTE_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int bind_to_board(orte_app_context_t* context,
|
|
|
|
|
orte_odls_child_t *child,
|
|
|
|
|
orte_odls_job_t *jobdat,
|
|
|
|
|
bool *bound, int pipe_fd)
|
|
|
|
|
{
|
|
|
|
|
/* Not currently supported until multi-board paffinity enabled.
|
|
|
|
|
But this is not an error -- for now. */
|
|
|
|
|
*bound = false;
|
|
|
|
|
if (orte_odls_base.warn_if_not_bound) {
|
|
|
|
|
send_warn_show_help(pipe_fd, "help-orte-odls-base.txt",
|
|
|
|
|
"warn not bound", "board",
|
|
|
|
|
"Not currently supported by Open MPI",
|
|
|
|
|
orte_process_info.nodename, context->app,
|
|
|
|
|
"Bind to board", "");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ORTE_ERR_NOT_SUPPORTED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int do_child(orte_app_context_t* context,
|
|
|
|
|
orte_odls_child_t *child,
|
|
|
|
|
char **environ_copy,
|
|
|
|
|
orte_odls_job_t *jobdat, int write_fd,
|
|
|
|
|
orte_iof_base_io_conf_t opts)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
sigset_t sigs;
|
|
|
|
|
long fd, fdmax = sysconf(_SC_OPEN_MAX);
|
|
|
|
|
bool paffinity_enabled;
|
|
|
|
|
char *param, *tmp;
|
|
|
|
|
opal_paffinity_base_cpu_set_t mask;
|
|
|
|
|
|
|
|
|
|
if (orte_forward_job_control) {
|
|
|
|
|
/* Set a new process group for this child, so that a
|
|
|
|
|
SIGSTOP can be sent to it without being sent to the
|
|
|
|
|
orted. */
|
|
|
|
|
setpgid(0, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Setup the pipe to be close-on-exec */
|
|
|
|
|
fcntl(write_fd, F_SETFD, FD_CLOEXEC);
|
|
|
|
|
|
|
|
|
|
if (NULL != child) {
|
|
|
|
|
/* setup stdout/stderr so that any error messages that we
|
|
|
|
|
may print out will get displayed back at orterun.
|
|
|
|
|
|
|
|
|
|
NOTE: Definitely do this AFTER we check contexts so
|
|
|
|
|
that any error message from those two functions doesn't
|
|
|
|
|
come out to the user. IF we didn't do it in this order,
|
|
|
|
|
THEN a user who gives us a bad executable name or
|
|
|
|
|
working directory would get N error messages, where
|
|
|
|
|
N=num_procs. This would be very annoying for large
|
|
|
|
|
jobs, so instead we set things up so that orterun
|
|
|
|
|
always outputs a nice, single message indicating what
|
|
|
|
|
happened
|
|
|
|
|
*/
|
|
|
|
|
if (ORTE_SUCCESS != (i = orte_iof_base_setup_child(&opts,
|
|
|
|
|
&environ_copy))) {
|
|
|
|
|
ORTE_ERROR_LOG(i);
|
|
|
|
|
send_error_show_help(write_fd, 1,
|
|
|
|
|
"help-orte-odls-default.txt",
|
|
|
|
|
"iof setup failed",
|
|
|
|
|
orte_process_info.nodename, context->app);
|
|
|
|
|
/* Does not return */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Setup process affinity. Not for the meek. */
|
|
|
|
|
|
|
|
|
|
paffinity_enabled = false;
|
|
|
|
|
if (NULL != child->slot_list) {
|
|
|
|
|
bind_to_slot_list(context, child, jobdat,
|
|
|
|
|
&paffinity_enabled, write_fd);
|
|
|
|
|
} else if (ORTE_BIND_TO_CORE & jobdat->policy) {
|
|
|
|
|
bind_to_core(context, child, jobdat,
|
|
|
|
|
&paffinity_enabled, write_fd);
|
|
|
|
|
} else if (ORTE_BIND_TO_SOCKET & jobdat->policy) {
|
|
|
|
|
bind_to_socket(context, child, jobdat,
|
|
|
|
|
&paffinity_enabled, write_fd);
|
|
|
|
|
} else if (ORTE_BIND_TO_BOARD & jobdat->policy) {
|
|
|
|
|
bind_to_board(context, child, jobdat,
|
|
|
|
|
&paffinity_enabled, write_fd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If we were able to set processor affinity, then also
|
|
|
|
|
setup memory affinity. */
|
|
|
|
|
if (paffinity_enabled) {
|
|
|
|
|
if (OPAL_SUCCESS == opal_maffinity_base_open() &&
|
|
|
|
|
OPAL_SUCCESS == opal_maffinity_base_select()) {
|
|
|
|
|
opal_maffinity_setup = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else if (!(ORTE_JOB_CONTROL_FORWARD_OUTPUT & jobdat->controls)) {
|
|
|
|
|
/* tie stdin/out/err/internal to /dev/null */
|
|
|
|
|
int fdnull;
|
|
|
|
|
for (i=0; i < 3; i++) {
|
|
|
|
|
fdnull = open("/dev/null", O_RDONLY, 0);
|
|
|
|
|
if (fdnull > i && i != write_fd) {
|
|
|
|
|
dup2(fdnull, i);
|
|
|
|
|
}
|
|
|
|
|
close(fdnull);
|
|
|
|
|
}
|
|
|
|
|
fdnull = open("/dev/null", O_RDONLY, 0);
|
|
|
|
|
if (fdnull > opts.p_internal[1]) {
|
|
|
|
|
dup2(fdnull, opts.p_internal[1]);
|
|
|
|
|
}
|
|
|
|
|
close(fdnull);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If we are able to bind, then set an info MCA param that tells
|
|
|
|
|
the launched processes that it was bound by us (e.g., so that
|
|
|
|
|
MPI_INIT doesn't try to bind itself) */
|
|
|
|
|
if (paffinity_enabled) {
|
|
|
|
|
param = mca_base_param_environ_variable("paffinity","base","bound");
|
|
|
|
|
opal_setenv(param, "1", true, &environ_copy);
|
|
|
|
|
free(param);
|
|
|
|
|
/* ...and provide a nice string representation of what we
|
|
|
|
|
bound to */
|
|
|
|
|
tmp = opal_paffinity_base_print_binding(mask);
|
|
|
|
|
if (NULL != tmp) {
|
|
|
|
|
param = mca_base_param_environ_variable("paffinity","base","applied_binding");
|
|
|
|
|
opal_setenv(param, tmp, true, &environ_copy);
|
|
|
|
|
free(tmp);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* close all file descriptors w/ exception of stdin/stdout/stderr,
|
|
|
|
|
the pipe used for the IOF INTERNAL messages, and the pipe up to
|
|
|
|
|
the parent. */
|
|
|
|
|
for(fd=3; fd<fdmax; fd++) {
|
|
|
|
|
if (fd != opts.p_internal[1] && fd != write_fd) {
|
|
|
|
|
close(fd);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (context->argv == NULL) {
|
|
|
|
|
context->argv = malloc(sizeof(char*)*2);
|
|
|
|
|
context->argv[0] = strdup(context->app);
|
|
|
|
|
context->argv[1] = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set signal handlers back to the default. Do this close to
|
|
|
|
|
the exev() because the event library may (and likely will)
|
|
|
|
|
reset them. If we don't do this, the event library may
|
|
|
|
|
have left some set that, at least on some OS's, don't get
|
|
|
|
|
reset via fork() or exec(). Hence, the launched process
|
|
|
|
|
could be unkillable (for example). */
|
|
|
|
|
|
|
|
|
|
set_handler_default(SIGTERM);
|
|
|
|
|
set_handler_default(SIGINT);
|
|
|
|
|
set_handler_default(SIGHUP);
|
|
|
|
|
set_handler_default(SIGPIPE);
|
|
|
|
|
set_handler_default(SIGCHLD);
|
|
|
|
|
|
|
|
|
|
/* Unblock all signals, for many of the same reasons that we
|
|
|
|
|
set the default handlers, above. This is noticable on
|
|
|
|
|
Linux where the event library blocks SIGTERM, but we don't
|
|
|
|
|
want that blocked by the launched process. */
|
|
|
|
|
sigprocmask(0, 0, &sigs);
|
|
|
|
|
sigprocmask(SIG_UNBLOCK, &sigs, 0);
|
|
|
|
|
|
|
|
|
|
/* Exec the new executable */
|
|
|
|
|
|
|
|
|
|
if (10 < opal_output_get_verbosity(orte_odls_globals.output)) {
|
|
|
|
|
int jout;
|
|
|
|
|
opal_output(0, "%s STARTING %s", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), context->app);
|
|
|
|
|
for (jout=0; NULL != context->argv[jout]; jout++) {
|
|
|
|
|
opal_output(0, "%s\tARGV[%d]: %s", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), jout, context->argv[jout]);
|
|
|
|
|
}
|
|
|
|
|
for (jout=0; NULL != environ_copy[jout]; jout++) {
|
|
|
|
|
opal_output(0, "%s\tENVIRON[%d]: %s", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), jout, environ_copy[jout]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
execve(context->app, context->argv, environ_copy);
|
|
|
|
|
send_error_show_help(write_fd, 1,
|
|
|
|
|
"help-orte-odls-default.txt", "execve error",
|
|
|
|
|
context->app, strerror(errno));
|
|
|
|
|
/* Does not return */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int do_parent(orte_app_context_t* context,
|
|
|
|
|
orte_odls_child_t *child,
|
|
|
|
|
char **environ_copy,
|
|
|
|
|
orte_odls_job_t *jobdat, int read_fd,
|
|
|
|
|
orte_iof_base_io_conf_t opts)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
pipe_err_msg_t msg;
|
|
|
|
|
char file[MAX_FILE_LEN + 1], topic[MAX_TOPIC_LEN + 1], *str = NULL;
|
|
|
|
|
|
|
|
|
|
if (NULL != child && (ORTE_JOB_CONTROL_FORWARD_OUTPUT & jobdat->controls)) {
|
|
|
|
|
/* connect endpoints IOF */
|
|
|
|
|
rc = orte_iof_base_setup_parent(child->name, &opts);
|
|
|
|
|
if (ORTE_SUCCESS != rc) {
|
|
|
|
|
ORTE_ERROR_LOG(rc);
|
|
|
|
|
close(read_fd);
|
|
|
|
|
|
|
|
|
|
if (NULL != child) {
|
|
|
|
|
child->state = ORTE_PROC_STATE_UNDEF;
|
|
|
|
|
}
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Block reading a message from the pipe */
|
|
|
|
|
while (1) {
|
|
|
|
|
rc = opal_fd_read(read_fd, sizeof(msg), &msg);
|
|
|
|
|
|
|
|
|
|
/* If the pipe closed, then the child successfully launched */
|
|
|
|
|
if (OPAL_ERR_TIMEOUT == OPAL_SOS_GET_ERROR_CODE(rc)) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If Something Bad happened in the read, error out */
|
|
|
|
|
if (OPAL_SUCCESS != rc) {
|
|
|
|
|
ORTE_ERROR_LOG(rc);
|
|
|
|
|
close(read_fd);
|
|
|
|
|
|
|
|
|
|
if (NULL != child) {
|
|
|
|
|
child->state = ORTE_PROC_STATE_UNDEF;
|
|
|
|
|
}
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Otherwise, we got a warning or error message from the child */
|
|
|
|
|
if (NULL != child) {
|
|
|
|
|
child->alive = msg.fatal ? 0 : 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Read in the strings; ensure to terminate them with \0 */
|
|
|
|
|
if (msg.file_str_len > 0) {
|
|
|
|
|
rc = opal_fd_read(read_fd, msg.file_str_len, file);
|
|
|
|
|
if (OPAL_SUCCESS != rc) {
|
|
|
|
|
orte_show_help("help-orte-odls-default.txt", "syscall fail",
|
|
|
|
|
true,
|
|
|
|
|
orte_process_info.nodename, context->app,
|
|
|
|
|
"opal_fd_read", __FILE__, __LINE__);
|
|
|
|
|
if (NULL != child) {
|
|
|
|
|
child->state = ORTE_PROC_STATE_UNDEF;
|
|
|
|
|
}
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
file[msg.file_str_len] = '\0';
|
|
|
|
|
}
|
|
|
|
|
if (msg.topic_str_len > 0) {
|
|
|
|
|
rc = opal_fd_read(read_fd, msg.topic_str_len, topic);
|
|
|
|
|
if (OPAL_SUCCESS != rc) {
|
|
|
|
|
orte_show_help("help-orte-odls-default.txt", "syscall fail",
|
|
|
|
|
true,
|
|
|
|
|
orte_process_info.nodename, context->app,
|
|
|
|
|
"opal_fd_read", __FILE__, __LINE__);
|
|
|
|
|
if (NULL != child) {
|
|
|
|
|
child->state = ORTE_PROC_STATE_UNDEF;
|
|
|
|
|
}
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
topic[msg.topic_str_len] = '\0';
|
|
|
|
|
}
|
|
|
|
|
if (msg.msg_str_len > 0) {
|
|
|
|
|
str = calloc(1, msg.msg_str_len + 1);
|
|
|
|
|
if (NULL == str) {
|
|
|
|
|
orte_show_help("help-orte-odls-default.txt", "syscall fail",
|
|
|
|
|
true,
|
|
|
|
|
orte_process_info.nodename, context->app,
|
|
|
|
|
"opal_fd_read", __FILE__, __LINE__);
|
|
|
|
|
if (NULL != child) {
|
|
|
|
|
child->state = ORTE_PROC_STATE_UNDEF;
|
|
|
|
|
}
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
rc = opal_fd_read(read_fd, msg.msg_str_len, str);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Print out what we got. We already have a rendered string,
|
|
|
|
|
so use orte_show_help_norender(). */
|
|
|
|
|
if (msg.msg_str_len > 0) {
|
|
|
|
|
orte_show_help_norender(file, topic, false, str);
|
|
|
|
|
free(str);
|
|
|
|
|
str = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If msg.fatal is true, then the child exited with an error.
|
|
|
|
|
Otherwise, whatever we just printed was a warning, so loop
|
|
|
|
|
around and see what else is on the pipe (or if the pipe
|
|
|
|
|
closed, indicating that the child launched
|
|
|
|
|
successfully). */
|
|
|
|
|
if (msg.fatal) {
|
|
|
|
|
if (NULL != child) {
|
|
|
|
|
child->state = ORTE_PROC_STATE_FAILED_TO_START;
|
|
|
|
|
child->alive = false;
|
|
|
|
|
}
|
|
|
|
|
close(read_fd);
|
|
|
|
|
return ORTE_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If we got here, it means that the pipe closed without
|
|
|
|
|
indication of a fatal error, meaning that the child process
|
|
|
|
|
launched successfully. */
|
|
|
|
|
if (NULL != child) {
|
|
|
|
|
child->state = ORTE_PROC_STATE_LAUNCHED;
|
|
|
|
|
child->alive = true;
|
|
|
|
|
}
|
|
|
|
|
close(read_fd);
|
|
|
|
|
|
|
|
|
|
return ORTE_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-09-14 21:29:51 +00:00
|
|
|
/**
|
|
|
|
|
* Fork/exec the specified processes
|
|
|
|
|
*/
|
2008-08-13 17:47:24 +00:00
|
|
|
static int odls_default_fork_local_proc(orte_app_context_t* context,
|
|
|
|
|
orte_odls_child_t *child,
|
|
|
|
|
char **environ_copy,
|
2009-08-11 02:51:27 +00:00
|
|
|
orte_odls_job_t *jobdat)
|
2006-09-14 21:29:51 +00:00
|
|
|
{
|
|
|
|
|
orte_iof_base_io_conf_t opts;
|
This commit is the first of several steps in a paffinity makeover
extravaganza.
= Short version =
This commit does several things, but the short version is that it
re-orients the error message creation of the ODLS default module to
generate error strings in the child process for errors that occur
after the fork but before the exec (such errors are ''usually''
related to paffinity). A show_help string is rendered in the child
and then IPC'ed up to the parent, who displays the string through
normal ORTE show_help aggregation mechanisms. We also broke up the
ginormous paffinity-setting logic into a few separate functions, both
to help us understand the code, and hopefully to ease future
maintenance.
The logic for the ODLS default binding should not have changed -- this
is mainly a code reshuffle and improvement on error reporting.
= Rationale =
The reasoning for this commit is complex. As mentioned above, it's
the first step in some paffinity cleanup. Here's the line of dominoes
that must fall (in this order):
1. Add hwloc paffinity component (already done).
1. While testing hwloc, we discovered that the error reporting from
the ODLS default module was abysmal. So we fixed it.
1. Further, we reorganized the code in the odsl_default_module.c a bit
to help our understanding of it.
1. We also discovered a few bugs in the original ODLS default module
logic that existed before this code shuffle; separate tickets
will be filed to fix them.
1. Next up will be some improvements to paffinity / odls default to
make the act of binding to a core ensure to bind to ''all''
hardware threads contained in that core (similar for sockets:
binding to a socket will bind to ''all'' hardware threads in that
socket).
1. Next will be improvements to paffinity to expose binding to
hardware threads through the paffinity framework API.
1. Finally, we'll expose these binding controls to the user (e.g.,
through mpirun command line arguments, MCA parameters, etc.).
This commit represents the first few bullets; the last 4 bullets are
being worked on right now, but there is no definite timeline for
completion.
= Miscelaneous =
A few points worth mentioning:
* We have tested this new code a bunch; we're pretty sure it behaves
just like the trunk -- but with better / more precise error
reporting. More testing is needed on a wider array of platforms,
however.
* A big comment at the top of odls_default_module.c explains the
(new) general scheme for the error reporting.
* The error reporting in the parent process is now really dumb;
almost all the intelligence about creating error messages is in the
child.
* The show_help file was renamed to be more consistent with other
help files (help-odls-default.txt -> help-orte-odls-default.txt)
* Removed the use of sched_yield() because of recent changes in the
Linux 2.6.3x kernels. We already had an #else clause for
select()'ing for 1us if we didn't have sched_yield() -- that is now
the only code path. This is not a performance-critical section of
the code, so this shouldn't be controversial.
* Replaced the macro-based error reporting with function-based
reporting. It's a bit more bulky, but it helped us understand the
code and saved us multiple times with compile-time parameter
checking, etc.
* Cleaned up the use of several show_help messages to ensure that
they mapped to real messages in help*.txt files.
This commit was SVN r23652.
2010-08-24 19:38:29 +00:00
|
|
|
int rc, p[2];
|
2008-08-13 17:47:24 +00:00
|
|
|
pid_t pid;
|
2009-08-11 02:51:27 +00:00
|
|
|
|
2008-08-13 17:47:24 +00:00
|
|
|
if (NULL != child) {
|
|
|
|
|
/* should pull this information from MPIRUN instead of going with
|
|
|
|
|
default */
|
2009-05-06 20:11:28 +00:00
|
|
|
opts.usepty = OPAL_ENABLE_PTY_SUPPORT;
|
2008-08-13 17:47:24 +00:00
|
|
|
|
Roll in the revamped IOF subsystem. Per the devel mailing list email, this is a complete rewrite of the iof framework designed to simplify the code for maintainability, and to support features we had planned to do, but were too difficult to implement in the old code. Specifically, the new code:
1. completely and cleanly separates responsibilities between the HNP, orted, and tool components.
2. removes all wireup messaging during launch and shutdown.
3. maintains flow control for stdin to avoid large-scale consumption of memory by orteds when large input files are forwarded. This is done using an xon/xoff protocol.
4. enables specification of stdin recipients on the mpirun cmd line. Allowed options include rank, "all", or "none". Default is rank 0.
5. creates a new MPI_Info key "ompi_stdin_target" that supports the above options for child jobs. Default is "none".
6. adds a new tool "orte-iof" that can connect to a running mpirun and display the output. Cmd line options allow selection of any combination of stdout, stderr, and stddiag. Default is stdout.
7. adds a new mpirun and orte-iof cmd line option "tag-output" that will tag each line of output with process name and stream ident. For example, "[1,0]<stdout>this is output"
This is not intended for the 1.3 release as it is a major change requiring considerable soak time.
This commit was SVN r19767.
2008-10-18 00:00:49 +00:00
|
|
|
/* do we want to setup stdin? */
|
|
|
|
|
if (NULL != child &&
|
2009-08-11 02:51:27 +00:00
|
|
|
(jobdat->stdin_target == ORTE_VPID_WILDCARD || child->name->vpid == jobdat->stdin_target)) {
|
2008-08-13 17:47:24 +00:00
|
|
|
opts.connect_stdin = true;
|
|
|
|
|
} else {
|
|
|
|
|
opts.connect_stdin = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ORTE_SUCCESS != (rc = orte_iof_base_setup_prefork(&opts))) {
|
|
|
|
|
ORTE_ERROR_LOG(rc);
|
|
|
|
|
if (NULL != child) {
|
|
|
|
|
child->state = ORTE_PROC_STATE_FAILED_TO_START;
|
|
|
|
|
child->exit_code = rc;
|
|
|
|
|
}
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
2006-09-14 21:29:51 +00:00
|
|
|
}
|
2007-04-24 18:54:45 +00:00
|
|
|
|
2006-09-14 21:29:51 +00:00
|
|
|
/* A pipe is used to communicate between the parent and child to
|
2010-06-08 20:16:07 +00:00
|
|
|
indicate whether the exec ultimately succeeded or failed. The
|
|
|
|
|
child sets the pipe to be close-on-exec; the child only ever
|
|
|
|
|
writes anything to the pipe if there is an error (e.g.,
|
|
|
|
|
executable not found, exec() fails, etc.). The parent does a
|
|
|
|
|
blocking read on the pipe; if the pipe closed with no data,
|
|
|
|
|
then the exec() succeeded. If the parent reads something from
|
|
|
|
|
the pipe, then the child was letting us know why it failed. */
|
2006-09-14 21:29:51 +00:00
|
|
|
if (pipe(p) < 0) {
|
2007-04-24 18:54:45 +00:00
|
|
|
ORTE_ERROR_LOG(ORTE_ERR_SYS_LIMITS_PIPES);
|
2008-08-13 17:47:24 +00:00
|
|
|
if (NULL != child) {
|
|
|
|
|
child->state = ORTE_PROC_STATE_FAILED_TO_START;
|
|
|
|
|
child->exit_code = ORTE_ERR_SYS_LIMITS_PIPES;
|
|
|
|
|
}
|
2007-04-24 18:54:45 +00:00
|
|
|
return ORTE_ERR_SYS_LIMITS_PIPES;
|
2006-09-14 21:29:51 +00:00
|
|
|
}
|
2009-09-18 19:48:42 +00:00
|
|
|
|
2006-09-14 21:29:51 +00:00
|
|
|
/* Fork off the child */
|
2008-08-13 17:47:24 +00:00
|
|
|
pid = fork();
|
|
|
|
|
if (NULL != child) {
|
|
|
|
|
child->pid = pid;
|
|
|
|
|
}
|
|
|
|
|
|
2010-05-06 20:57:17 +00:00
|
|
|
if (pid < 0) {
|
2007-04-24 18:54:45 +00:00
|
|
|
ORTE_ERROR_LOG(ORTE_ERR_SYS_LIMITS_CHILDREN);
|
2008-08-13 17:47:24 +00:00
|
|
|
if (NULL != child) {
|
|
|
|
|
child->state = ORTE_PROC_STATE_FAILED_TO_START;
|
|
|
|
|
child->exit_code = ORTE_ERR_SYS_LIMITS_CHILDREN;
|
|
|
|
|
}
|
2007-04-24 18:54:45 +00:00
|
|
|
return ORTE_ERR_SYS_LIMITS_CHILDREN;
|
2006-09-14 21:29:51 +00:00
|
|
|
}
|
2009-09-18 19:48:42 +00:00
|
|
|
|
2008-08-13 17:47:24 +00:00
|
|
|
if (pid == 0) {
|
This commit is the first of several steps in a paffinity makeover
extravaganza.
= Short version =
This commit does several things, but the short version is that it
re-orients the error message creation of the ODLS default module to
generate error strings in the child process for errors that occur
after the fork but before the exec (such errors are ''usually''
related to paffinity). A show_help string is rendered in the child
and then IPC'ed up to the parent, who displays the string through
normal ORTE show_help aggregation mechanisms. We also broke up the
ginormous paffinity-setting logic into a few separate functions, both
to help us understand the code, and hopefully to ease future
maintenance.
The logic for the ODLS default binding should not have changed -- this
is mainly a code reshuffle and improvement on error reporting.
= Rationale =
The reasoning for this commit is complex. As mentioned above, it's
the first step in some paffinity cleanup. Here's the line of dominoes
that must fall (in this order):
1. Add hwloc paffinity component (already done).
1. While testing hwloc, we discovered that the error reporting from
the ODLS default module was abysmal. So we fixed it.
1. Further, we reorganized the code in the odsl_default_module.c a bit
to help our understanding of it.
1. We also discovered a few bugs in the original ODLS default module
logic that existed before this code shuffle; separate tickets
will be filed to fix them.
1. Next up will be some improvements to paffinity / odls default to
make the act of binding to a core ensure to bind to ''all''
hardware threads contained in that core (similar for sockets:
binding to a socket will bind to ''all'' hardware threads in that
socket).
1. Next will be improvements to paffinity to expose binding to
hardware threads through the paffinity framework API.
1. Finally, we'll expose these binding controls to the user (e.g.,
through mpirun command line arguments, MCA parameters, etc.).
This commit represents the first few bullets; the last 4 bullets are
being worked on right now, but there is no definite timeline for
completion.
= Miscelaneous =
A few points worth mentioning:
* We have tested this new code a bunch; we're pretty sure it behaves
just like the trunk -- but with better / more precise error
reporting. More testing is needed on a wider array of platforms,
however.
* A big comment at the top of odls_default_module.c explains the
(new) general scheme for the error reporting.
* The error reporting in the parent process is now really dumb;
almost all the intelligence about creating error messages is in the
child.
* The show_help file was renamed to be more consistent with other
help files (help-odls-default.txt -> help-orte-odls-default.txt)
* Removed the use of sched_yield() because of recent changes in the
Linux 2.6.3x kernels. We already had an #else clause for
select()'ing for 1us if we didn't have sched_yield() -- that is now
the only code path. This is not a performance-critical section of
the code, so this shouldn't be controversial.
* Replaced the macro-based error reporting with function-based
reporting. It's a bit more bulky, but it helped us understand the
code and saved us multiple times with compile-time parameter
checking, etc.
* Cleaned up the use of several show_help messages to ensure that
they mapped to real messages in help*.txt files.
This commit was SVN r23652.
2010-08-24 19:38:29 +00:00
|
|
|
close(p[0]);
|
|
|
|
|
do_child(context, child, environ_copy, jobdat, p[1], opts);
|
|
|
|
|
/* Does not return */
|
|
|
|
|
}
|
2006-09-14 21:29:51 +00:00
|
|
|
|
This commit is the first of several steps in a paffinity makeover
extravaganza.
= Short version =
This commit does several things, but the short version is that it
re-orients the error message creation of the ODLS default module to
generate error strings in the child process for errors that occur
after the fork but before the exec (such errors are ''usually''
related to paffinity). A show_help string is rendered in the child
and then IPC'ed up to the parent, who displays the string through
normal ORTE show_help aggregation mechanisms. We also broke up the
ginormous paffinity-setting logic into a few separate functions, both
to help us understand the code, and hopefully to ease future
maintenance.
The logic for the ODLS default binding should not have changed -- this
is mainly a code reshuffle and improvement on error reporting.
= Rationale =
The reasoning for this commit is complex. As mentioned above, it's
the first step in some paffinity cleanup. Here's the line of dominoes
that must fall (in this order):
1. Add hwloc paffinity component (already done).
1. While testing hwloc, we discovered that the error reporting from
the ODLS default module was abysmal. So we fixed it.
1. Further, we reorganized the code in the odsl_default_module.c a bit
to help our understanding of it.
1. We also discovered a few bugs in the original ODLS default module
logic that existed before this code shuffle; separate tickets
will be filed to fix them.
1. Next up will be some improvements to paffinity / odls default to
make the act of binding to a core ensure to bind to ''all''
hardware threads contained in that core (similar for sockets:
binding to a socket will bind to ''all'' hardware threads in that
socket).
1. Next will be improvements to paffinity to expose binding to
hardware threads through the paffinity framework API.
1. Finally, we'll expose these binding controls to the user (e.g.,
through mpirun command line arguments, MCA parameters, etc.).
This commit represents the first few bullets; the last 4 bullets are
being worked on right now, but there is no definite timeline for
completion.
= Miscelaneous =
A few points worth mentioning:
* We have tested this new code a bunch; we're pretty sure it behaves
just like the trunk -- but with better / more precise error
reporting. More testing is needed on a wider array of platforms,
however.
* A big comment at the top of odls_default_module.c explains the
(new) general scheme for the error reporting.
* The error reporting in the parent process is now really dumb;
almost all the intelligence about creating error messages is in the
child.
* The show_help file was renamed to be more consistent with other
help files (help-odls-default.txt -> help-orte-odls-default.txt)
* Removed the use of sched_yield() because of recent changes in the
Linux 2.6.3x kernels. We already had an #else clause for
select()'ing for 1us if we didn't have sched_yield() -- that is now
the only code path. This is not a performance-critical section of
the code, so this shouldn't be controversial.
* Replaced the macro-based error reporting with function-based
reporting. It's a bit more bulky, but it helped us understand the
code and saved us multiple times with compile-time parameter
checking, etc.
* Cleaned up the use of several show_help messages to ensure that
they mapped to real messages in help*.txt files.
This commit was SVN r23652.
2010-08-24 19:38:29 +00:00
|
|
|
close(p[1]);
|
|
|
|
|
return do_parent(context, child, environ_copy, jobdat, p[0], opts);
|
2006-09-14 21:29:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Launch all processes allocated to the current node.
|
|
|
|
|
*/
|
|
|
|
|
|
2008-02-28 01:57:57 +00:00
|
|
|
int orte_odls_default_launch_local_procs(opal_buffer_t *data)
|
2006-09-14 21:29:51 +00:00
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
orte_jobid_t job;
|
2010-02-04 15:47:20 +00:00
|
|
|
orte_job_t *jdata;
|
2007-06-18 15:39:04 +00:00
|
|
|
|
2007-10-10 15:02:10 +00:00
|
|
|
/* construct the list of children we are to launch */
|
2008-04-30 19:49:53 +00:00
|
|
|
if (ORTE_SUCCESS != (rc = orte_odls_base_default_construct_child_list(data, &job))) {
|
2008-06-09 14:53:58 +00:00
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
2008-02-28 01:57:57 +00:00
|
|
|
"%s odls:default:launch:local failed to construct child list on error %s",
|
2009-03-05 21:50:47 +00:00
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), ORTE_ERROR_NAME(rc)));
|
2007-10-10 15:02:10 +00:00
|
|
|
goto CLEANUP;
|
2006-09-14 21:29:51 +00:00
|
|
|
}
|
2007-10-10 15:02:10 +00:00
|
|
|
|
|
|
|
|
/* launch the local procs */
|
2008-04-30 19:49:53 +00:00
|
|
|
if (ORTE_SUCCESS != (rc = orte_odls_base_default_launch_local(job, odls_default_fork_local_proc))) {
|
2008-06-09 14:53:58 +00:00
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
2008-02-28 01:57:57 +00:00
|
|
|
"%s odls:default:launch:local failed to launch on error %s",
|
2009-03-05 21:50:47 +00:00
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), ORTE_ERROR_NAME(rc)));
|
2007-10-10 15:02:10 +00:00
|
|
|
goto CLEANUP;
|
Bring in the code for routing xcast stage gate messages via the local orteds. This code is inactive unless you specifically request it via an mca param oob_xcast_mode (can be set to "linear" or "direct"). Direct mode is the old standard method where we send messages directly to each MPI process. Linear mode sends the xcast message via the orteds, with the HNP sending the message to each orted directly.
There is a binomial algorithm in the code (i.e., the HNP would send to a subset of the orteds, which then relay it on according to the typical log-2 algo), but that has a bug in it so the code won't let you select it even if you tried (and the mca param doesn't show, so you'd *really* have to try).
This also involved a slight change to the oob.xcast API, so propagated that as required.
Note: this has *only* been tested on rsh, SLURM, and Bproc environments (now that it has been transferred to the OMPI trunk, I'll need to re-test it [only done rsh so far]). It should work fine on any environment that uses the ORTE daemons - anywhere else, you are on your own... :-)
Also, correct a mistake where the orte_debug_flag was declared an int, but the mca param was set as a bool. Move the storage for that flag to the orte/runtime/params.c and orte/runtime/params.h files appropriately.
This commit was SVN r14475.
2007-04-23 18:41:04 +00:00
|
|
|
}
|
|
|
|
|
|
2010-02-04 15:47:20 +00:00
|
|
|
/* look up job data object */
|
|
|
|
|
if (NULL != (jdata = orte_get_job_data_object(job))) {
|
|
|
|
|
if (jdata->state & ORTE_JOB_STATE_SUSPENDED) {
|
|
|
|
|
if (ORTE_PROC_IS_HNP) {
|
|
|
|
|
/* Have the plm send the signal to all the nodes.
|
|
|
|
|
If the signal arrived before the orteds started,
|
|
|
|
|
then they won't know to suspend their procs.
|
|
|
|
|
The plm also arranges for any local procs to
|
|
|
|
|
be signaled.
|
|
|
|
|
*/
|
|
|
|
|
orte_plm.signal_job(jdata->jobid, SIGTSTP);
|
|
|
|
|
} else {
|
|
|
|
|
orte_odls_default_signal_local_procs(NULL, SIGTSTP);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-10 15:02:10 +00:00
|
|
|
CLEANUP:
|
2008-04-30 19:49:53 +00:00
|
|
|
|
2006-11-11 04:03:45 +00:00
|
|
|
return rc;
|
2006-09-14 21:29:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2009-05-22 14:59:27 +00:00
|
|
|
/**
|
|
|
|
|
* Send a sigal to a pid. Note that if we get an error, we set the
|
|
|
|
|
* return value and let the upper layer print out the message.
|
|
|
|
|
*/
|
2006-09-14 21:29:51 +00:00
|
|
|
static int send_signal(pid_t pid, int signal)
|
|
|
|
|
{
|
|
|
|
|
int rc = ORTE_SUCCESS;
|
|
|
|
|
|
2008-06-09 14:53:58 +00:00
|
|
|
OPAL_OUTPUT_VERBOSE((1, orte_odls_globals.output,
|
2007-09-12 14:32:31 +00:00
|
|
|
"%s sending signal %d to pid %ld",
|
2009-03-05 21:50:47 +00:00
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME),
|
2007-09-12 14:32:31 +00:00
|
|
|
signal, (long)pid));
|
2010-02-04 15:47:20 +00:00
|
|
|
|
|
|
|
|
if (orte_forward_job_control) {
|
|
|
|
|
/* Send the signal to the process group rather than the
|
|
|
|
|
process. The child is the leader of its process group. */
|
|
|
|
|
pid = -pid;
|
|
|
|
|
}
|
2006-09-14 21:29:51 +00:00
|
|
|
if (kill(pid, signal) != 0) {
|
|
|
|
|
switch(errno) {
|
|
|
|
|
case EINVAL:
|
|
|
|
|
rc = ORTE_ERR_BAD_PARAM;
|
|
|
|
|
break;
|
|
|
|
|
case ESRCH:
|
2009-05-22 14:59:27 +00:00
|
|
|
/* This case can occur when we deliver a signal to a
|
|
|
|
|
process that is no longer there. This can happen if
|
|
|
|
|
we deliver a signal while the job is shutting down.
|
|
|
|
|
This does not indicate a real problem, so just
|
|
|
|
|
ignore the error. */
|
2006-09-14 21:29:51 +00:00
|
|
|
break;
|
|
|
|
|
case EPERM:
|
|
|
|
|
rc = ORTE_ERR_PERM;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
rc = ORTE_ERROR;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
2007-09-12 14:32:31 +00:00
|
|
|
|
2007-10-10 15:02:10 +00:00
|
|
|
static int orte_odls_default_signal_local_procs(const orte_process_name_t *proc, int32_t signal)
|
Bring in the code for routing xcast stage gate messages via the local orteds. This code is inactive unless you specifically request it via an mca param oob_xcast_mode (can be set to "linear" or "direct"). Direct mode is the old standard method where we send messages directly to each MPI process. Linear mode sends the xcast message via the orteds, with the HNP sending the message to each orted directly.
There is a binomial algorithm in the code (i.e., the HNP would send to a subset of the orteds, which then relay it on according to the typical log-2 algo), but that has a bug in it so the code won't let you select it even if you tried (and the mca param doesn't show, so you'd *really* have to try).
This also involved a slight change to the oob.xcast API, so propagated that as required.
Note: this has *only* been tested on rsh, SLURM, and Bproc environments (now that it has been transferred to the OMPI trunk, I'll need to re-test it [only done rsh so far]). It should work fine on any environment that uses the ORTE daemons - anywhere else, you are on your own... :-)
Also, correct a mistake where the orte_debug_flag was declared an int, but the mca param was set as a bool. Move the storage for that flag to the orte/runtime/params.c and orte/runtime/params.h files appropriately.
This commit was SVN r14475.
2007-04-23 18:41:04 +00:00
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
|
2007-10-10 15:02:10 +00:00
|
|
|
if (ORTE_SUCCESS != (rc = orte_odls_base_default_signal_local_procs(proc, signal, send_signal))) {
|
These changes were mostly captured in a prior RFC (except for #2 below) and are aimed specifically at improving startup performance and setting up the remaining modifications described in that RFC.
The commit has been tested for C/R and Cray operations, and on Odin (SLURM, rsh) and RoadRunner (TM). I tried to update all environments, but obviously could not test them. I know that Windows needs some work, and have highlighted what is know to be needed in the odls process component.
This represents a lot of work by Brian, Tim P, Josh, and myself, with much advice from Jeff and others. For posterity, I have appended a copy of the email describing the work that was done:
As we have repeatedly noted, the modex operation in MPI_Init is the single greatest consumer of time during startup. To-date, we have executed that operation as an ORTE stage gate that held the process until a startup message containing all required modex (and OOB contact info - see #3 below) info could be sent to it. Each process would send its data to the HNP's registry, which assembled and sent the message when all processes had reported in.
In addition, ORTE had taken responsibility for monitoring process status as it progressed through a series of "stage gates". The process reported its status at each gate, and ORTE would then send a "release" message once all procs had reported in.
The incoming changes revamp these procedures in three ways:
1. eliminating the ORTE stage gate system and cleanly delineating responsibility between the OMPI and ORTE layers for MPI init/finalize. The modex stage gate (STG1) has been replaced by a collective operation in the modex itself that performs an allgather on the required modex info. The allgather is implemented using the orte_grpcomm framework since the BTL's are not active at that point. At the moment, the grpcomm framework only has a "basic" component analogous to OMPI's "basic" coll framework - I would recommend that the MPI team create additional, more advanced components to improve performance of this step.
The other stage gates have been replaced by orte_grpcomm barrier functions. We tried to use MPI barriers instead (since the BTL's are active at that point), but - as we discussed on the telecon - these are not currently true barriers so the job would hang when we fell through while messages were still in process. Note that the grpcomm barrier doesn't actually resolve that problem, but Brian has pointed out that we are unlikely to ever see it violated. Again, you might want to spend a little time on an advanced barrier algorithm as the one in "basic" is very simplistic.
Summarizing this change: ORTE no longer tracks process state nor has direct responsibility for synchronizing jobs. This is now done via collective operations within the MPI layer, albeit using ORTE collective communication services. I -strongly- urge the MPI team to implement advanced collective algorithms to improve the performance of this critical procedure.
2. reducing the volume of data exchanged during modex. Data in the modex consisted of the process name, the name of the node where that process is located (expressed as a string), plus a string representation of all contact info. The nodename was required in order for the modex to determine if the process was local or not - in addition, some people like to have it to print pretty error messages when a connection failed.
The size of this data has been reduced in three ways:
(a) reducing the size of the process name itself. The process name consisted of two 32-bit fields for the jobid and vpid. This is far larger than any current system, or system likely to exist in the near future, can support. Accordingly, the default size of these fields has been reduced to 16-bits, which means you can have 32k procs in each of 32k jobs. Since the daemons must have a vpid, and we require one daemon/node, this also restricts the default configuration to 32k nodes.
To support any future "mega-clusters", a configuration option --enable-jumbo-apps has been added. This option increases the jobid and vpid field sizes to 32-bits. Someday, if necessary, someone can add yet another option to increase them to 64-bits, I suppose.
(b) replacing the string nodename with an integer nodeid. Since we have one daemon/node, the nodeid corresponds to the local daemon's vpid. This replaces an often lengthy string with only 2 (or at most 4) bytes, a substantial reduction.
(c) when the mca param requesting that nodenames be sent to support pretty error messages, a second mca param is now used to request FQDN - otherwise, the domain name is stripped (by default) from the message to save space. If someone wants to combine those into a single param somehow (perhaps with an argument?), they are welcome to do so - I didn't want to alter what people are already using.
While these may seem like small savings, they actually amount to a significant impact when aggregated across the entire modex operation. Since every proc must receive the modex data regardless of the collective used to send it, just reducing the size of the process name removes nearly 400MBytes of communication from a 32k proc job (admittedly, much of this comm may occur in parallel). So it does add up pretty quickly.
3. routing RML messages to reduce connections. The default messaging system remains point-to-point - i.e., each proc opens a socket to every proc it communicates with and sends its messages directly. A new option uses the orteds as routers - i.e., each proc only opens a single socket to its local orted. All messages are sent from the proc to the orted, which forwards the message to the orted on the node where the intended recipient proc is located - that orted then forwards the message to its local proc (the recipient). This greatly reduces the connection storm we have encountered during startup.
It also has the benefit of removing the sharing of every proc's OOB contact with every other proc. The orted routing tables are populated during launch since every orted gets a map of where every proc is being placed. Each proc, therefore, only needs to know the contact info for its local daemon, which is passed in via the environment when the proc is fork/exec'd by the daemon. This alone removes ~50 bytes/process of communication that was in the current STG1 startup message - so for our 32k proc job, this saves us roughly 32k*50 = 1.6MBytes sent to 32k procs = 51GBytes of messaging.
Note that you can use the new routing method by specifying -mca routed tree - if you so desire. This mode will become the default at some point in the future.
There are a few minor additional changes in the commit that I'll just note in passing:
* propagation of command line mca params to the orteds - fixes ticket #1073. See note there for details.
* requiring of "finalize" prior to "exit" for MPI procs - fixes ticket #1144. See note there for details.
* cleanup of some stale header files
This commit was SVN r16364.
2007-10-05 19:48:23 +00:00
|
|
|
ORTE_ERROR_LOG(rc);
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
return ORTE_SUCCESS;
|
|
|
|
|
}
|
2010-04-26 22:15:57 +00:00
|
|
|
|
|
|
|
|
static int orte_odls_default_restart_proc(orte_odls_child_t *child)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
/* restart the local proc */
|
|
|
|
|
if (ORTE_SUCCESS != (rc = orte_odls_base_default_restart_proc(child, odls_default_fork_local_proc))) {
|
|
|
|
|
OPAL_OUTPUT_VERBOSE((2, orte_odls_globals.output,
|
|
|
|
|
"%s odls:default:restart_proc failed to launch on error %s",
|
|
|
|
|
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), ORTE_ERROR_NAME(rc)));
|
|
|
|
|
}
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|