2006-02-07 06:32:36 +03:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
|
|
|
|
* University Research and Technology
|
|
|
|
* Corporation. All rights reserved.
|
|
|
|
* Copyright (c) 2004-2005 The University of Tennessee and The University
|
|
|
|
* of Tennessee Research Foundation. All rights
|
|
|
|
* reserved.
|
|
|
|
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
|
|
|
|
* University of Stuttgart. All rights reserved.
|
|
|
|
* Copyright (c) 2004-2005 The Regents of the University of California.
|
|
|
|
* All rights reserved.
|
2015-06-24 06:59:57 +03:00
|
|
|
* Copyright (c) 2010-2011 Cisco Systems, Inc. All rights reserved.
|
Per the meeting on moving the BTLs to OPAL, move the ORTE database "db" framework to OPAL so the relocated BTLs can access it. Because the data is indexed by process, this requires that we define a new "opal_identifier_t" that corresponds to the orte_process_name_t struct. In order to support multiple run-times, this is defined in opal/mca/db/db_types.h as a uint64_t without identifying the meaning of any part of that data.
A few changes were required to support this move:
1. the PMI component used to identify rte-related data (e.g., host name, bind level) and package them as a unit to reduce the number of PMI keys. This code was moved up to the ORTE layer as the OPAL layer has no understanding of these concepts. In addition, the component locally stored data based on process jobid/vpid - this could no longer be supported (see below for the solution).
2. the hash component was updated to use the new opal_identifier_t instead of orte_process_name_t as its index for storing data in the hash tables. Previously, we did a hash on the vpid and stored the data in a 32-bit hash table. In the revised system, we don't see a separate "vpid" field - we only have a 64-bit opaque value. The orte_process_name_t hash turned out to do nothing useful, so we now store the data in a 64-bit hash table. Preliminary tests didn't show any identifiable change in behavior or performance, but we'll have to see if a move back to the 32-bit table is required at some later time.
3. the db framework was a "select one" system. However, since the PMI component could no longer use its internal storage system, the framework has now been changed to a "select many" mode of operation. This allows the hash component to handle all internal storage, while the PMI component only handles pushing/pulling things from the PMI system. This was something we had planned for some time - when fetching data, we first check internal storage to see if we already have it, and then automatically go to the global system to look for it if we don't. Accordingly, the framework was provided with a custom query function used during "select" that lets you seperately specify the "store" and "fetch" ordering.
4. the ORTE grpcomm and ess/pmi components, and the nidmap code, were updated to work with the new db framework and to specify internal/global storage options.
No changes were made to the MPI layer, except for modifying the ORTE component of the OMPI/rte framework to support the new db framework.
This commit was SVN r28112.
2013-02-26 21:50:04 +04:00
|
|
|
* Copyright (c) 2011-2013 Los Alamos National Security, LLC.
|
2012-04-06 18:23:13 +04:00
|
|
|
* All rights reserved.
|
2014-04-02 08:17:55 +04:00
|
|
|
* Copyright (c) 2014 Intel, Inc. All rights reserved.
|
2006-02-07 06:32:36 +03:00
|
|
|
* $COPYRIGHT$
|
|
|
|
*
|
|
|
|
* Additional copyrights may follow
|
|
|
|
*
|
|
|
|
* $HEADER$
|
|
|
|
*/
|
|
|
|
|
|
|
|
/** @file **/
|
|
|
|
|
|
|
|
#include "orte_config.h"
|
2008-02-28 04:57:57 +03:00
|
|
|
#include "orte/constants.h"
|
2006-02-07 06:32:36 +03:00
|
|
|
|
2006-02-07 08:41:31 +03:00
|
|
|
#include <stdio.h>
|
2011-02-14 22:29:09 +03:00
|
|
|
#ifdef HAVE_SYS_SIGNAL_H
|
|
|
|
#include <sys/signal.h>
|
|
|
|
#else
|
|
|
|
#include <signal.h>
|
|
|
|
#endif
|
2006-02-07 06:32:36 +03:00
|
|
|
|
2012-04-06 18:23:13 +04:00
|
|
|
#include "orte/mca/plm/plm_types.h"
|
2010-04-23 08:44:41 +04:00
|
|
|
#include "orte/util/error_strings.h"
|
2010-10-16 07:29:47 +04:00
|
|
|
#include "orte/runtime/orte_globals.h"
|
2010-04-23 08:44:41 +04:00
|
|
|
|
2011-02-13 19:09:17 +03:00
|
|
|
int orte_err2str(int errnum, const char **errmsg)
|
2006-02-07 06:32:36 +03:00
|
|
|
{
|
|
|
|
const char *retval;
|
2011-11-23 01:24:35 +04:00
|
|
|
switch (errnum) {
|
2014-01-24 01:35:20 +04:00
|
|
|
case ORTE_SUCCESS:
|
|
|
|
retval = "Success";
|
|
|
|
break;
|
2006-02-07 06:32:36 +03:00
|
|
|
case ORTE_ERR_RECV_LESS_THAN_POSTED:
|
|
|
|
retval = "Receive was less than posted size";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_RECV_MORE_THAN_POSTED:
|
|
|
|
retval = "Receive was greater than posted size";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_NO_MATCH_YET:
|
|
|
|
retval = "No match for receive posted";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_REQUEST:
|
|
|
|
retval = "Request error";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_NO_CONNECTION_ALLOWED:
|
|
|
|
retval = "No connection allowed";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_CONNECTION_REFUSED:
|
|
|
|
retval = "Connection refused";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_TYPE_MISMATCH:
|
|
|
|
retval = "Type mismatch";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_COMPARE_FAILURE:
|
|
|
|
retval = "Data comparison failure";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_COPY_FAILURE:
|
|
|
|
retval = "Data copy failure";
|
|
|
|
break;
|
2006-03-23 18:31:43 +03:00
|
|
|
case ORTE_ERR_PROC_STATE_MISSING:
|
|
|
|
retval = "The process state information is missing on the registry";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_PROC_EXIT_STATUS_MISSING:
|
|
|
|
retval = "The process exit status is missing on the registry";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_INDETERMINATE_STATE_INFO:
|
|
|
|
retval = "Request for state returned multiple responses";
|
|
|
|
break;
|
2006-07-10 18:10:21 +04:00
|
|
|
case ORTE_ERR_NODE_FULLY_USED:
|
|
|
|
retval = "All the slots on a given node have been used";
|
|
|
|
break;
|
2006-07-11 01:25:33 +04:00
|
|
|
case ORTE_ERR_INVALID_NUM_PROCS:
|
|
|
|
retval = "Multiple applications were specified, but at least one failed to specify the number of processes to run";
|
|
|
|
break;
|
2006-12-11 21:07:07 +03:00
|
|
|
case ORTE_ERR_SILENT:
|
2010-10-16 07:29:47 +04:00
|
|
|
if (orte_report_silent_errors) {
|
|
|
|
retval = "Silent error";
|
|
|
|
} else {
|
|
|
|
retval = NULL;
|
|
|
|
}
|
2006-12-11 21:07:07 +03:00
|
|
|
break;
|
2007-04-23 22:25:03 +04:00
|
|
|
case ORTE_ERR_ADDRESSEE_UNKNOWN:
|
|
|
|
retval = "A message is attempting to be sent to a process whose contact information is unknown";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_SYS_LIMITS_PIPES:
|
|
|
|
retval = "The system limit on number of pipes a process can open was reached";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_PIPE_SETUP_FAILURE:
|
|
|
|
retval = "A pipe could not be setup between a daemon and one of its local processes";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_SYS_LIMITS_CHILDREN:
|
|
|
|
retval = "The system limit on number of children a process can have was reached";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_FAILED_GET_TERM_ATTRS:
|
|
|
|
retval = "The I/O forwarding system was unable to get the attributes of your terminal";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_WDIR_NOT_FOUND:
|
|
|
|
retval = "The specified working directory could not be found";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_EXE_NOT_FOUND:
|
|
|
|
retval = "The specified executable could not be found";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_PIPE_READ_FAILURE:
|
|
|
|
retval = "A pipe could not be read";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_EXE_NOT_ACCESSIBLE:
|
|
|
|
retval = "The specified executable could not be executed";
|
|
|
|
break;
|
2007-05-18 17:29:11 +04:00
|
|
|
case ORTE_ERR_FAILED_TO_START:
|
|
|
|
retval = "The specified application failed to start";
|
|
|
|
break;
|
2007-07-12 23:53:18 +04:00
|
|
|
case ORTE_ERR_FILE_NOT_EXECUTABLE:
|
|
|
|
retval = "A system-required executable either could not be found or was not executable by this user";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_HNP_COULD_NOT_START:
|
|
|
|
retval = "Unable to start a daemon on the local node";
|
|
|
|
break;
|
2009-05-27 00:03:21 +04:00
|
|
|
case ORTE_ERR_SYS_LIMITS_SOCKETS:
|
|
|
|
retval = "The system limit on number of network connections a process can open was reached";
|
|
|
|
break;
|
2009-08-22 06:58:20 +04:00
|
|
|
case ORTE_ERR_SOCKET_NOT_AVAILABLE:
|
|
|
|
retval = "Unable to open a TCP socket for out-of-band communications";
|
|
|
|
break;
|
2009-10-01 03:30:24 +04:00
|
|
|
case ORTE_ERR_SYSTEM_WILL_BOOTSTRAP:
|
|
|
|
retval = "System will determine resources during bootstrap of daemons";
|
|
|
|
break;
|
2011-02-14 22:29:09 +03:00
|
|
|
case ORTE_ERR_RESTART_LIMIT_EXCEEDED:
|
|
|
|
retval = "Limit on number of process restarts was exceeded";
|
2010-05-04 17:44:33 +04:00
|
|
|
break;
|
2011-08-08 08:21:02 +04:00
|
|
|
case ORTE_ERR_INVALID_NODE_RANK:
|
|
|
|
retval = "Invalid node rank";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_INVALID_LOCAL_RANK:
|
|
|
|
retval = "Invalid local rank";
|
|
|
|
break;
|
2010-05-11 04:34:12 +04:00
|
|
|
case ORTE_ERR_UNRECOVERABLE:
|
|
|
|
retval = "Unrecoverable error";
|
|
|
|
break;
|
2011-08-08 08:21:02 +04:00
|
|
|
case ORTE_ERR_MEM_LIMIT_EXCEEDED:
|
|
|
|
retval = "Memory limit exceeded";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_HEARTBEAT_LOST:
|
|
|
|
retval = "Heartbeat lost";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_PROC_STALLED:
|
|
|
|
retval = "Proc appears to be stalled";
|
|
|
|
break;
|
2011-01-13 04:54:05 +03:00
|
|
|
case ORTE_ERR_NO_APP_SPECIFIED:
|
|
|
|
retval = "No application specified";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_NO_EXE_SPECIFIED:
|
|
|
|
retval = "No executable specified";
|
|
|
|
break;
|
2010-12-01 16:41:19 +03:00
|
|
|
case ORTE_ERR_COMM_DISABLED:
|
|
|
|
retval = "Communications have been disabled";
|
|
|
|
break;
|
2011-02-16 02:24:31 +03:00
|
|
|
case ORTE_ERR_FAILED_TO_MAP:
|
|
|
|
retval = "Unable to map job";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_TAKE_NEXT_OPTION:
|
|
|
|
if (orte_report_silent_errors) {
|
|
|
|
retval = "Next option";
|
|
|
|
} else {
|
|
|
|
retval = NULL;
|
|
|
|
}
|
|
|
|
break;
|
2011-06-28 23:47:16 +04:00
|
|
|
case ORTE_ERR_SENSOR_LIMIT_EXCEEDED:
|
|
|
|
retval = "Sensor limit exceeded";
|
|
|
|
break;
|
2012-11-18 21:57:19 +04:00
|
|
|
case ORTE_ERR_PROC_ENTRY_NOT_FOUND:
|
|
|
|
retval = "Proc entry not found";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_DATA_VALUE_NOT_FOUND:
|
|
|
|
retval = "Data not found";
|
|
|
|
break;
|
2013-01-20 04:30:27 +04:00
|
|
|
case ORTE_ERR_ALLOCATION_PENDING:
|
|
|
|
retval = "Allocation pending";
|
|
|
|
break;
|
As per the RFC, bring in the ORTE async progress code and the rewrite of OOB:
*** THIS RFC INCLUDES A MINOR CHANGE TO THE MPI-RTE INTERFACE ***
Note: during the course of this work, it was necessary to completely separate the MPI and RTE progress engines. There were multiple places in the MPI layer where ORTE_WAIT_FOR_COMPLETION was being used. A new OMPI_WAIT_FOR_COMPLETION macro was created (defined in ompi/mca/rte/rte.h) that simply cycles across opal_progress until the provided flag becomes false. Places where the MPI layer blocked waiting for RTE to complete an event have been modified to use this macro.
***************************************************************************************
I am reissuing this RFC because of the time that has passed since its original release. Since its initial release and review, I have debugged it further to ensure it fully supports tests like loop_spawn. It therefore seems ready for merge back to the trunk. Given its prior review, I have set the timeout for one week.
The code is in https://bitbucket.org/rhc/ompi-oob2
WHAT: Rewrite of ORTE OOB
WHY: Support asynchronous progress and a host of other features
WHEN: Wed, August 21
SYNOPSIS:
The current OOB has served us well, but a number of limitations have been identified over the years. Specifically:
* it is only progressed when called via opal_progress, which can lead to hangs or recursive calls into libevent (which is not supported by that code)
* we've had issues when multiple NICs are available as the code doesn't "shift" messages between transports - thus, all nodes had to be available via the same TCP interface.
* the OOB "unloads" incoming opal_buffer_t objects during the transmission, thus preventing use of OBJ_RETAIN in the code when repeatedly sending the same message to multiple recipients
* there is no failover mechanism across NICs - if the selected NIC (or its attached switch) fails, we are forced to abort
* only one transport (i.e., component) can be "active"
The revised OOB resolves these problems:
* async progress is used for all application processes, with the progress thread blocking in the event library
* each available TCP NIC is supported by its own TCP module. The ability to asynchronously progress each module independently is provided, but not enabled by default (a runtime MCA parameter turns it "on")
* multi-address TCP NICs (e.g., a NIC with both an IPv4 and IPv6 address, or with virtual interfaces) are supported - reachability is determined by comparing the contact info for a peer against all addresses within the range covered by the address/mask pairs for the NIC.
* a message that arrives on one TCP NIC is automatically shifted to whatever NIC that is connected to the next "hop" if that peer cannot be reached by the incoming NIC. If no TCP module will reach the peer, then the OOB attempts to send the message via all other available components - if none can reach the peer, then an "error" is reported back to the RML, which then calls the errmgr for instructions.
* opal_buffer_t now conforms to standard object rules re OBJ_RETAIN as we no longer "unload" the incoming object
* NIC failure is reported to the TCP component, which then tries to resend the message across any other available TCP NIC. If that doesn't work, then the message is given back to the OOB base to try using other components. If all that fails, then the error is reported to the RML, which reports to the errmgr for instructions
* obviously from the above, multiple OOB components (e.g., TCP and UD) can be active in parallel
* the matching code has been moved to the RML (and out of the OOB/TCP component) so it is independent of transport
* routing is done by the individual OOB modules (as opposed to the RML). Thus, both routed and non-routed transports can simultaneously be active
* all blocking send/recv APIs have been removed. Everything operates asynchronously.
KNOWN LIMITATIONS:
* although provision is made for component failover as described above, the code for doing so has not been fully implemented yet. At the moment, if all connections for a given peer fail, the errmgr is notified of a "lost connection", which by default results in termination of the job if it was a lifeline
* the IPv6 code is present and compiles, but is not complete. Since the current IPv6 support in the OOB doesn't work anyway, I don't consider this a blocker
* routing is performed at the individual module level, yet the active routed component is selected on a global basis. We probably should update that to reflect that different transports may need/choose to route in different ways
* obviously, not every error path has been tested nor necessarily covered
* determining abnormal termination is more challenging than in the old code as we now potentially have multiple ways of connecting to a process. Ideally, we would declare "connection failed" when *all* transports can no longer reach the process, but that requires some additional (possibly complex) code. For now, the code replicates the old behavior only somewhat modified - i.e., if a module sees its connection fail, it checks to see if it is a lifeline. If so, it notifies the errmgr that the lifeline is lost - otherwise, it notifies the errmgr that a non-lifeline connection was lost.
* reachability is determined solely on the basis of a shared subnet address/mask - more sophisticated algorithms (e.g., the one used in the tcp btl) are required to handle routing via gateways
* the RML needs to assign sequence numbers to each message on a per-peer basis. The receiving RML will then deliver messages in order, thus preventing out-of-order messaging in the case where messages travel across different transports or a message needs to be redirected/resent due to failure of a NIC
This commit was SVN r29058.
2013-08-22 20:37:40 +04:00
|
|
|
case ORTE_ERR_NO_PATH_TO_TARGET:
|
|
|
|
retval = "No OOB path to target";
|
|
|
|
break;
|
2015-05-08 21:15:21 +03:00
|
|
|
case ORTE_ERR_OP_IN_PROGRESS:
|
|
|
|
retval = "Operation in progress";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_OPEN_CHANNEL_PEER_FAIL:
|
|
|
|
retval = "Open channel to peer failed";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_OPEN_CHANNEL_PEER_REJECT:
|
|
|
|
retval = "Open channel to peer was rejected";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_QOS_TYPE_UNSUPPORTED:
|
|
|
|
retval = "QoS type unsupported";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_QOS_ACK_WINDOW_FULL:
|
|
|
|
retval = "QoS ack window full";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_ACK_TIMEOUT_SENDER:
|
|
|
|
retval = "Send ack timed out";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_ACK_TIMEOUT_RECEIVER:
|
|
|
|
retval = "Recv ack timed out";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_LOST_MSG_IN_WINDOW:
|
|
|
|
retval = "Msg lost in window";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_CHANNEL_BUSY:
|
|
|
|
retval = "Channel busy";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_DUPLICATE_MSG:
|
|
|
|
retval = "Duplicate message";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_OUT_OF_ORDER_MSG:
|
|
|
|
retval = "Out of order message";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_OPEN_CHANNEL_DUPLICATE:
|
|
|
|
retval = "Duplicate channel open request";
|
|
|
|
break;
|
|
|
|
case ORTE_ERR_FORCE_SELECT:
|
|
|
|
retval = "Force select";
|
|
|
|
break;
|
2015-12-17 02:30:40 +03:00
|
|
|
case ORTE_ERR_JOB_CANCELLED:
|
|
|
|
retval = "Job cancelled";
|
|
|
|
break;
|
2016-06-02 02:34:03 +03:00
|
|
|
case ORTE_ERR_DEBUGGER_RELEASE:
|
|
|
|
retval = "Debugger release";
|
2006-02-07 06:32:36 +03:00
|
|
|
default:
|
2010-10-16 07:29:47 +04:00
|
|
|
if (orte_report_silent_errors) {
|
|
|
|
retval = "Unknown error";
|
|
|
|
} else {
|
|
|
|
retval = NULL;
|
|
|
|
}
|
2006-02-07 06:32:36 +03:00
|
|
|
}
|
|
|
|
|
2011-02-13 19:09:17 +03:00
|
|
|
*errmsg = retval;
|
|
|
|
return ORTE_SUCCESS;
|
2006-02-07 06:32:36 +03:00
|
|
|
}
|
2010-04-23 08:44:41 +04:00
|
|
|
|
|
|
|
const char *orte_job_state_to_str(orte_job_state_t state)
|
|
|
|
{
|
|
|
|
switch(state) {
|
2012-04-06 18:23:13 +04:00
|
|
|
case ORTE_JOB_STATE_UNDEF:
|
|
|
|
return "UNDEFINED";
|
|
|
|
case ORTE_JOB_STATE_INIT:
|
|
|
|
return "PENDING INIT";
|
2012-05-03 01:00:22 +04:00
|
|
|
case ORTE_JOB_STATE_INIT_COMPLETE:
|
|
|
|
return "INIT_COMPLETE";
|
2012-04-06 18:23:13 +04:00
|
|
|
case ORTE_JOB_STATE_ALLOCATE:
|
|
|
|
return "PENDING ALLOCATION";
|
2012-08-03 20:30:05 +04:00
|
|
|
case ORTE_JOB_STATE_ALLOCATION_COMPLETE:
|
|
|
|
return "ALLOCATION COMPLETE";
|
2012-04-06 18:23:13 +04:00
|
|
|
case ORTE_JOB_STATE_MAP:
|
|
|
|
return "PENDING MAPPING";
|
2012-08-03 20:30:05 +04:00
|
|
|
case ORTE_JOB_STATE_MAP_COMPLETE:
|
|
|
|
return "MAP COMPLETE";
|
2012-04-06 18:23:13 +04:00
|
|
|
case ORTE_JOB_STATE_SYSTEM_PREP:
|
|
|
|
return "PENDING FINAL SYSTEM PREP";
|
|
|
|
case ORTE_JOB_STATE_LAUNCH_DAEMONS:
|
|
|
|
return "PENDING DAEMON LAUNCH";
|
|
|
|
case ORTE_JOB_STATE_DAEMONS_LAUNCHED:
|
|
|
|
return "DAEMONS LAUNCHED";
|
|
|
|
case ORTE_JOB_STATE_DAEMONS_REPORTED:
|
|
|
|
return "ALL DAEMONS REPORTED";
|
2012-07-28 19:33:09 +04:00
|
|
|
case ORTE_JOB_STATE_VM_READY:
|
|
|
|
return "VM READY";
|
2012-04-06 18:23:13 +04:00
|
|
|
case ORTE_JOB_STATE_LAUNCH_APPS:
|
|
|
|
return "PENDING APP LAUNCH";
|
|
|
|
case ORTE_JOB_STATE_RUNNING:
|
|
|
|
return "RUNNING";
|
|
|
|
case ORTE_JOB_STATE_SUSPENDED:
|
|
|
|
return "SUSPENDED";
|
|
|
|
case ORTE_JOB_STATE_REGISTERED:
|
|
|
|
return "SYNC REGISTERED";
|
|
|
|
case ORTE_JOB_STATE_READY_FOR_DEBUGGERS:
|
|
|
|
return "READY FOR DEBUGGERS";
|
|
|
|
case ORTE_JOB_STATE_LOCAL_LAUNCH_COMPLETE:
|
|
|
|
return "LOCAL LAUNCH COMPLETE";
|
|
|
|
case ORTE_JOB_STATE_UNTERMINATED:
|
|
|
|
return "UNTERMINATED";
|
|
|
|
case ORTE_JOB_STATE_TERMINATED:
|
|
|
|
return "NORMALLY TERMINATED";
|
2012-07-03 02:16:32 +04:00
|
|
|
case ORTE_JOB_STATE_NOTIFY_COMPLETED:
|
|
|
|
return "NOTIFY COMPLETED";
|
|
|
|
case ORTE_JOB_STATE_NOTIFIED:
|
|
|
|
return "NOTIFIED";
|
2012-04-06 18:23:13 +04:00
|
|
|
case ORTE_JOB_STATE_ALL_JOBS_COMPLETE:
|
|
|
|
return "ALL JOBS COMPLETE";
|
|
|
|
case ORTE_JOB_STATE_ERROR:
|
|
|
|
return "ARTIFICIAL BOUNDARY - ERROR";
|
|
|
|
case ORTE_JOB_STATE_KILLED_BY_CMD:
|
|
|
|
return "KILLED BY INTERNAL COMMAND";
|
|
|
|
case ORTE_JOB_STATE_ABORTED:
|
|
|
|
return "ABORTED";
|
|
|
|
case ORTE_JOB_STATE_FAILED_TO_START:
|
|
|
|
return "FAILED TO START";
|
|
|
|
case ORTE_JOB_STATE_ABORTED_BY_SIG:
|
|
|
|
return "ABORTED BY SIGNAL";
|
|
|
|
case ORTE_JOB_STATE_ABORTED_WO_SYNC:
|
|
|
|
return "TERMINATED WITHOUT SYNC";
|
|
|
|
case ORTE_JOB_STATE_COMM_FAILED:
|
|
|
|
return "COMMUNICATION FAILURE";
|
|
|
|
case ORTE_JOB_STATE_SENSOR_BOUND_EXCEEDED:
|
|
|
|
return "SENSOR BOUND EXCEEDED";
|
|
|
|
case ORTE_JOB_STATE_CALLED_ABORT:
|
|
|
|
return "PROC CALLED ABORT";
|
|
|
|
case ORTE_JOB_STATE_HEARTBEAT_FAILED:
|
|
|
|
return "HEARTBEAT FAILED";
|
|
|
|
case ORTE_JOB_STATE_NEVER_LAUNCHED:
|
|
|
|
return "NEVER LAUNCHED";
|
|
|
|
case ORTE_JOB_STATE_ABORT_ORDERED:
|
|
|
|
return "ABORT IN PROGRESS";
|
|
|
|
case ORTE_JOB_STATE_NON_ZERO_TERM:
|
|
|
|
return "AT LEAST ONE PROCESS EXITED WITH NON-ZERO STATUS";
|
|
|
|
case ORTE_JOB_STATE_FAILED_TO_LAUNCH:
|
|
|
|
return "FAILED TO LAUNCH";
|
|
|
|
case ORTE_JOB_STATE_FORCED_EXIT:
|
|
|
|
return "FORCED EXIT";
|
|
|
|
case ORTE_JOB_STATE_DAEMONS_TERMINATED:
|
|
|
|
return "DAEMONS TERMINATED";
|
|
|
|
case ORTE_JOB_STATE_SILENT_ABORT:
|
|
|
|
return "ERROR REPORTED ELSEWHERE";
|
2012-04-26 04:10:09 +04:00
|
|
|
case ORTE_JOB_STATE_REPORT_PROGRESS:
|
|
|
|
return "REPORT PROGRESS";
|
2013-01-20 04:30:27 +04:00
|
|
|
case ORTE_JOB_STATE_ALLOC_FAILED:
|
|
|
|
return "ALLOCATION FAILED";
|
2014-04-02 08:17:55 +04:00
|
|
|
case ORTE_JOB_STATE_MAP_FAILED:
|
|
|
|
return "MAP FAILED";
|
|
|
|
case ORTE_JOB_STATE_CANNOT_LAUNCH:
|
|
|
|
return "CANNOT LAUNCH";
|
2014-03-12 16:34:25 +04:00
|
|
|
case ORTE_JOB_STATE_FT_CHECKPOINT:
|
|
|
|
return "FAULT TOLERANCE CHECKPOINT";
|
|
|
|
case ORTE_JOB_STATE_FT_CONTINUE:
|
|
|
|
return "FAULT TOLERANCE CONTINUE";
|
|
|
|
case ORTE_JOB_STATE_FT_RESTART:
|
|
|
|
return "FAULT TOLERANCE RESTART";
|
2012-04-06 18:23:13 +04:00
|
|
|
case ORTE_JOB_STATE_ANY:
|
|
|
|
return "ANY";
|
|
|
|
default:
|
|
|
|
return "UNKNOWN STATE!";
|
2010-04-23 08:44:41 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-29 01:20:17 +04:00
|
|
|
const char *orte_app_ctx_state_to_str(orte_app_state_t state)
|
|
|
|
{
|
|
|
|
switch(state) {
|
|
|
|
case ORTE_APP_STATE_UNDEF:
|
|
|
|
return "UNDEFINED";
|
|
|
|
case ORTE_APP_STATE_INIT:
|
|
|
|
return "PENDING INIT";
|
|
|
|
case ORTE_APP_STATE_ALL_MAPPED:
|
|
|
|
return "ALL MAPPED";
|
|
|
|
case ORTE_APP_STATE_RUNNING:
|
|
|
|
return "RUNNING";
|
|
|
|
case ORTE_APP_STATE_COMPLETED:
|
|
|
|
return "COMPLETED";
|
|
|
|
default:
|
|
|
|
return "UNKNOWN STATE!";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-23 08:44:41 +04:00
|
|
|
const char *orte_proc_state_to_str(orte_proc_state_t state)
|
|
|
|
{
|
|
|
|
switch(state) {
|
2012-04-06 18:23:13 +04:00
|
|
|
case ORTE_PROC_STATE_UNDEF:
|
|
|
|
return "UNDEFINED";
|
|
|
|
case ORTE_PROC_STATE_INIT:
|
|
|
|
return "INITIALIZED";
|
|
|
|
case ORTE_PROC_STATE_RESTART:
|
|
|
|
return "RESTARTING";
|
|
|
|
case ORTE_PROC_STATE_TERMINATE:
|
|
|
|
return "MARKED FOR TERMINATION";
|
|
|
|
case ORTE_PROC_STATE_RUNNING:
|
|
|
|
return "RUNNING";
|
|
|
|
case ORTE_PROC_STATE_REGISTERED:
|
|
|
|
return "SYNC REGISTERED";
|
|
|
|
case ORTE_PROC_STATE_IOF_COMPLETE:
|
|
|
|
return "IOF COMPLETE";
|
|
|
|
case ORTE_PROC_STATE_WAITPID_FIRED:
|
|
|
|
return "WAITPID FIRED";
|
|
|
|
case ORTE_PROC_STATE_UNTERMINATED:
|
|
|
|
return "UNTERMINATED";
|
|
|
|
case ORTE_PROC_STATE_TERMINATED:
|
|
|
|
return "NORMALLY TERMINATED";
|
|
|
|
case ORTE_PROC_STATE_ERROR:
|
|
|
|
return "ARTIFICIAL BOUNDARY - ERROR";
|
|
|
|
case ORTE_PROC_STATE_KILLED_BY_CMD:
|
|
|
|
return "KILLED BY INTERNAL COMMAND";
|
|
|
|
case ORTE_PROC_STATE_ABORTED:
|
|
|
|
return "ABORTED";
|
|
|
|
case ORTE_PROC_STATE_FAILED_TO_START:
|
|
|
|
return "FAILED TO START";
|
|
|
|
case ORTE_PROC_STATE_ABORTED_BY_SIG:
|
|
|
|
return "ABORTED BY SIGNAL";
|
|
|
|
case ORTE_PROC_STATE_TERM_WO_SYNC:
|
|
|
|
return "TERMINATED WITHOUT SYNC";
|
|
|
|
case ORTE_PROC_STATE_COMM_FAILED:
|
|
|
|
return "COMMUNICATION FAILURE";
|
|
|
|
case ORTE_PROC_STATE_SENSOR_BOUND_EXCEEDED:
|
|
|
|
return "SENSOR BOUND EXCEEDED";
|
|
|
|
case ORTE_PROC_STATE_CALLED_ABORT:
|
|
|
|
return "CALLED ABORT";
|
|
|
|
case ORTE_PROC_STATE_HEARTBEAT_FAILED:
|
|
|
|
return "HEARTBEAT FAILED";
|
|
|
|
case ORTE_PROC_STATE_MIGRATING:
|
|
|
|
return "MIGRATING";
|
|
|
|
case ORTE_PROC_STATE_CANNOT_RESTART:
|
|
|
|
return "CANNOT BE RESTARTED";
|
|
|
|
case ORTE_PROC_STATE_TERM_NON_ZERO:
|
|
|
|
return "EXITED WITH NON-ZERO STATUS";
|
|
|
|
case ORTE_PROC_STATE_FAILED_TO_LAUNCH:
|
|
|
|
return "FAILED TO LAUNCH";
|
As per the RFC, bring in the ORTE async progress code and the rewrite of OOB:
*** THIS RFC INCLUDES A MINOR CHANGE TO THE MPI-RTE INTERFACE ***
Note: during the course of this work, it was necessary to completely separate the MPI and RTE progress engines. There were multiple places in the MPI layer where ORTE_WAIT_FOR_COMPLETION was being used. A new OMPI_WAIT_FOR_COMPLETION macro was created (defined in ompi/mca/rte/rte.h) that simply cycles across opal_progress until the provided flag becomes false. Places where the MPI layer blocked waiting for RTE to complete an event have been modified to use this macro.
***************************************************************************************
I am reissuing this RFC because of the time that has passed since its original release. Since its initial release and review, I have debugged it further to ensure it fully supports tests like loop_spawn. It therefore seems ready for merge back to the trunk. Given its prior review, I have set the timeout for one week.
The code is in https://bitbucket.org/rhc/ompi-oob2
WHAT: Rewrite of ORTE OOB
WHY: Support asynchronous progress and a host of other features
WHEN: Wed, August 21
SYNOPSIS:
The current OOB has served us well, but a number of limitations have been identified over the years. Specifically:
* it is only progressed when called via opal_progress, which can lead to hangs or recursive calls into libevent (which is not supported by that code)
* we've had issues when multiple NICs are available as the code doesn't "shift" messages between transports - thus, all nodes had to be available via the same TCP interface.
* the OOB "unloads" incoming opal_buffer_t objects during the transmission, thus preventing use of OBJ_RETAIN in the code when repeatedly sending the same message to multiple recipients
* there is no failover mechanism across NICs - if the selected NIC (or its attached switch) fails, we are forced to abort
* only one transport (i.e., component) can be "active"
The revised OOB resolves these problems:
* async progress is used for all application processes, with the progress thread blocking in the event library
* each available TCP NIC is supported by its own TCP module. The ability to asynchronously progress each module independently is provided, but not enabled by default (a runtime MCA parameter turns it "on")
* multi-address TCP NICs (e.g., a NIC with both an IPv4 and IPv6 address, or with virtual interfaces) are supported - reachability is determined by comparing the contact info for a peer against all addresses within the range covered by the address/mask pairs for the NIC.
* a message that arrives on one TCP NIC is automatically shifted to whatever NIC that is connected to the next "hop" if that peer cannot be reached by the incoming NIC. If no TCP module will reach the peer, then the OOB attempts to send the message via all other available components - if none can reach the peer, then an "error" is reported back to the RML, which then calls the errmgr for instructions.
* opal_buffer_t now conforms to standard object rules re OBJ_RETAIN as we no longer "unload" the incoming object
* NIC failure is reported to the TCP component, which then tries to resend the message across any other available TCP NIC. If that doesn't work, then the message is given back to the OOB base to try using other components. If all that fails, then the error is reported to the RML, which reports to the errmgr for instructions
* obviously from the above, multiple OOB components (e.g., TCP and UD) can be active in parallel
* the matching code has been moved to the RML (and out of the OOB/TCP component) so it is independent of transport
* routing is done by the individual OOB modules (as opposed to the RML). Thus, both routed and non-routed transports can simultaneously be active
* all blocking send/recv APIs have been removed. Everything operates asynchronously.
KNOWN LIMITATIONS:
* although provision is made for component failover as described above, the code for doing so has not been fully implemented yet. At the moment, if all connections for a given peer fail, the errmgr is notified of a "lost connection", which by default results in termination of the job if it was a lifeline
* the IPv6 code is present and compiles, but is not complete. Since the current IPv6 support in the OOB doesn't work anyway, I don't consider this a blocker
* routing is performed at the individual module level, yet the active routed component is selected on a global basis. We probably should update that to reflect that different transports may need/choose to route in different ways
* obviously, not every error path has been tested nor necessarily covered
* determining abnormal termination is more challenging than in the old code as we now potentially have multiple ways of connecting to a process. Ideally, we would declare "connection failed" when *all* transports can no longer reach the process, but that requires some additional (possibly complex) code. For now, the code replicates the old behavior only somewhat modified - i.e., if a module sees its connection fail, it checks to see if it is a lifeline. If so, it notifies the errmgr that the lifeline is lost - otherwise, it notifies the errmgr that a non-lifeline connection was lost.
* reachability is determined solely on the basis of a shared subnet address/mask - more sophisticated algorithms (e.g., the one used in the tcp btl) are required to handle routing via gateways
* the RML needs to assign sequence numbers to each message on a per-peer basis. The receiving RML will then deliver messages in order, thus preventing out-of-order messaging in the case where messages travel across different transports or a message needs to be redirected/resent due to failure of a NIC
This commit was SVN r29058.
2013-08-22 20:37:40 +04:00
|
|
|
case ORTE_PROC_STATE_UNABLE_TO_SEND_MSG:
|
|
|
|
return "UNABLE TO SEND MSG";
|
|
|
|
case ORTE_PROC_STATE_LIFELINE_LOST:
|
|
|
|
return "LIFELINE LOST";
|
2012-04-06 18:23:13 +04:00
|
|
|
case ORTE_PROC_STATE_ANY:
|
|
|
|
return "ANY";
|
2011-02-14 22:29:09 +03:00
|
|
|
default:
|
2012-04-06 18:23:13 +04:00
|
|
|
return "UNKNOWN STATE!";
|
2011-02-14 22:29:09 +03:00
|
|
|
}
|
|
|
|
}
|
2014-05-01 02:26:18 +04:00
|
|
|
|
|
|
|
const char *orte_node_state_to_str(orte_node_state_t state)
|
|
|
|
{
|
|
|
|
switch(state) {
|
|
|
|
case ORTE_NODE_STATE_UNDEF:
|
|
|
|
return "UNDEF";
|
|
|
|
case ORTE_NODE_STATE_UNKNOWN:
|
|
|
|
return "UNKNOWN";
|
|
|
|
case ORTE_NODE_STATE_DOWN:
|
|
|
|
return "DOWN";
|
|
|
|
case ORTE_NODE_STATE_UP:
|
|
|
|
return "UP";
|
|
|
|
case ORTE_NODE_STATE_REBOOT:
|
|
|
|
return "REBOOT";
|
|
|
|
case ORTE_NODE_STATE_DO_NOT_USE:
|
|
|
|
return "DO_NOT_USE";
|
|
|
|
case ORTE_NODE_STATE_NOT_INCLUDED:
|
|
|
|
return "NOT_INCLUDED";
|
|
|
|
case ORTE_NODE_STATE_ADDED:
|
|
|
|
return "ADDED";
|
|
|
|
default:
|
|
|
|
return "UNKNOWN STATE!";
|
|
|
|
}
|
|
|
|
}
|