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

Commit the orted-failed-to-start code. This correctly causes the system to detect the failure of an orted to start and allows the system to terminate all procs/orteds that *did* start.

Просмотр исходного кода 
The primary change that underlies all this is in the OOB. Specifically, the problem in the code until now has been that the OOB attempts to resolve an address when we call the "send" to an unknown recipient. The OOB would then wait forever if that recipient never actually started (and hence, never reported back its OOB contact info). In the case of an orted that failed to start, we would correctly detect that the orted hadn't started, but then we would attempt to order all orteds (including the one that failed to start) to die. This would cause the OOB to "hang" the system.

Unfortunately, revising how the OOB resolves addresses introduced a number of additional problems. Specifically, and most troublesome, was the fact that comm_spawn involved the immediate transmission of the rendezvous point from parent-to-child after the child was spawned. The current code used the OOB address resolution as a "barrier" - basically, the parent would attempt to send the info to the child, and then "hold" there until the child's contact info had arrived (meaning the child had started) and the send could be completed.

Note that this also caused comm_spawn to "hang" the entire system if the child never started... The app-failed-to-start helped improve that behavior - this code provides additional relief.

With this change, the OOB will return an ADDRESSEE_UNKNOWN error if you attempt to send to a recipient whose contact info isn't already in the OOB's hash tables. To resolve comm_spawn issues, we also now force the cross-sharing of connection info between parent and child jobs during spawn.

Finally, to aid in setting triggers to the right values, we introduce the "arith" API for the GPR. This function allows you to atomically change the value in a registry location (either divide, multiply, add, or subtract) by the provided operand. It is equivalent to first fetching the value using a "get", then modifying it, and then putting the result back into the registry via a "put".

This commit was SVN r14711.
Этот коммит содержится в:
Ralph Castain 2007-05-21 18:31:28 +00:00
родитель c9c2922706
Коммит 4fff584a68
93 изменённых файлов: 3398 добавлений и 818 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

9
ompi/communicator/comm_dyn.c
Просмотреть файл

@ -361,6 +361,7 @@ ompi_comm_start_processes(int count, char **array_of_commands,
orte_std_cntr_t num_apps, ai;
orte_jobid_t new_jobid=ORTE_JOBID_INVALID;
orte_app_context_t **apps=NULL;
orte_proc_state_t state;
opal_list_t attributes;
opal_list_item_t *item;
@ -572,7 +573,7 @@ ompi_comm_start_processes(int count, char **array_of_commands,
free(base_prefix);
}
/* tell the RTE that we want to be a child of this process' job */
/* tell the RTE that we want to be the new job to be a child of this process' job */
if (ORTE_SUCCESS != (rc = orte_rmgr.add_attribute(&attributes, ORTE_NS_USE_PARENT,
ORTE_JOBID, &(orte_process_info.my_name->jobid),
ORTE_RMGR_ATTR_OVERRIDE))) {
@ -605,10 +606,12 @@ ompi_comm_start_processes(int count, char **array_of_commands,
}
/* tell the RTE that we want to be cross-connected to the children so we receive
* their ORTE-level information - e.g., OOB contact info
* their ORTE-level information - e.g., OOB contact info - when they
* reach the STG1 stage gate
*/
state = ORTE_PROC_STATE_AT_STG1;
if (ORTE_SUCCESS != (rc = orte_rmgr.add_attribute(&attributes, ORTE_RMGR_XCONNECT_AT_SPAWN,
ORTE_JOBID, &(orte_process_info.my_name->jobid),
ORTE_PROC_STATE, &state,
ORTE_RMGR_ATTR_OVERRIDE))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&attributes);

6
ompi/mca/pml/ob1/pml_ob1.c
Просмотреть файл

@ -485,8 +485,7 @@ int mca_pml_ob1_ft_event( int state )
return ret;
}
if (ORTE_SUCCESS != (ret = orte_rml.xcast(ORTE_PROC_MY_NAME->jobid,
NULL, orte_gpr.deliver_notify_msg))) {
if (ORTE_SUCCESS != (ret = orte_rml.xcast_gate(orte_gpr.deliver_notify_msg))) {
opal_output(0,
"pml:ob1: ft_event(Restart): Stage Gate 1 Failed %d",
ret);
@ -510,8 +509,7 @@ int mca_pml_ob1_ft_event( int state )
return ret;
}
if (ORTE_SUCCESS != (ret = orte_rml.xcast(ORTE_PROC_MY_NAME->jobid,
NULL, orte_gpr.deliver_notify_msg))) {
if (ORTE_SUCCESS != (ret = orte_rml.xcast_gate(orte_gpr.deliver_notify_msg))) {
opal_output(0,"pml:ob1: ft_event(Restart): Stage Gate 1 Failed %d",
ret);
return ret;

6
ompi/runtime/ompi_mpi_finalize.c
Просмотреть файл

@ -156,8 +156,7 @@ int ompi_mpi_finalize(void)
/*
* Wait for everyone to get here
*/
if (ORTE_SUCCESS != (ret = orte_rml.xcast(ORTE_PROC_MY_NAME->jobid,
NULL, orte_gpr.deliver_notify_msg))) {
if (ORTE_SUCCESS != (ret = orte_rml.xcast_gate(orte_gpr.deliver_notify_msg))) {
ORTE_ERROR_LOG(ret);
return ret;
}
@ -308,8 +307,7 @@ int ompi_mpi_finalize(void)
* the RTE while the smr is trying to do the update - which causes
* an ugly race condition
*/
if (ORTE_SUCCESS != (ret = orte_rml.xcast(ORTE_PROC_MY_NAME->jobid,
NULL, orte_gpr.deliver_notify_msg))) {
if (ORTE_SUCCESS != (ret = orte_rml.xcast_gate(orte_gpr.deliver_notify_msg))) {
ORTE_ERROR_LOG(ret);
return ret;
}

17
ompi/runtime/ompi_mpi_init.c
Просмотреть файл

@ -277,7 +277,7 @@ int ompi_mpi_init(int argc, char **argv, int requested, int *provided)
/* Now do the things that hit the registry */
if (ORTE_SUCCESS != (ret = orte_init_stage2())) {
if (ORTE_SUCCESS != (ret = orte_init_stage2(ORTE_STG1_TRIGGER))) {
ORTE_ERROR_LOG(ret);
error = "ompi_mpi_init: orte_init_stage2 failed";
goto error;
@ -551,13 +551,8 @@ int ompi_mpi_init(int argc, char **argv, int requested, int *provided)
gettimeofday(&ompistart, NULL);
}
/* FIRST BARRIER - WAIT FOR MSG FROM RMGR_PROC_STAGE_GATE_MGR TO ARRIVE.
* We pass a "process_first" flag of "true" to indicate that we need to
* process the STG1 message prior to sending it along the xcast chain
* as this message contains all the oob contact info we need!
*/
if (ORTE_SUCCESS != (ret = orte_rml.xcast(ORTE_PROC_MY_NAME->jobid,
NULL, orte_gpr.deliver_notify_msg))) {
/* FIRST BARRIER - WAIT FOR XCAST STG1 MESSAGE TO ARRIVE */
if (ORTE_SUCCESS != (ret = orte_rml.xcast_gate(orte_gpr.deliver_notify_msg))) {
ORTE_ERROR_LOG(ret);
error = "ompi_mpi_init: failed to see all procs register\n";
goto error;
@ -663,11 +658,9 @@ int ompi_mpi_init(int argc, char **argv, int requested, int *provided)
(ompistop.tv_usec - ompistart.tv_usec)));
}
/* Second barrier -- wait for message from
RMGR_PROC_STAGE_GATE_MGR to arrive */
/* Second barrier -- wait for XCAST STG2 MESSAGE to arrive */
if (ORTE_SUCCESS != (ret = orte_rml.xcast(ORTE_PROC_MY_NAME->jobid,
NULL, orte_gpr.deliver_notify_msg))) {
if (ORTE_SUCCESS != (ret = orte_rml.xcast_gate(orte_gpr.deliver_notify_msg))) {
ORTE_ERROR_LOG(ret);
error = "ompi_mpi_init: failed to see all procs register\n";
goto error;

25
orte/dss/dss.h
Просмотреть файл

@ -330,6 +330,29 @@ typedef int (*orte_dss_load_fn_t)(orte_buffer_t *buffer,
orte_std_cntr_t size);
/**
* Transfer a payload from one buffer to another
* This function is a convenience shortcut that basically unloads the
* payload from one buffer and loads it into another. This is a destructive
* action - see the unload and load descriptions above.
*/
typedef int (*orte_dss_xfer_payload_fn_t)(orte_buffer_t *dest,
orte_buffer_t *src);
/**
* Copy a payload from one buffer to another
* This function will append a copy of the payload in one buffer into
* another buffer. If the destination buffer is NOT empty, then the
* type of the two buffers MUST match or else an
* error will be returned. If the destination buffer IS empty, then
* its type will be set to that of the source buffer.
* NOTE: This is NOT a destructive procedure - the
* source buffer's payload will remain intact, as will any pre-existing
* payload in the destination's buffer.
*/
typedef int (*orte_dss_copy_payload_fn_t)(orte_buffer_t *dest,
orte_buffer_t *src);
/**
* DSS initialization function.
*
@ -598,6 +621,8 @@ struct orte_dss_t {
orte_dss_peek_next_item_fn_t peek;
orte_dss_unload_fn_t unload;
orte_dss_load_fn_t load;
orte_dss_xfer_payload_fn_t xfer_payload;
orte_dss_copy_payload_fn_t copy_payload;
orte_dss_register_fn_t register_type;
orte_dss_lookup_data_type_fn_t lookup_data_type;
orte_dss_dump_data_types_fn_t dump_data_types;

4
orte/dss/dss_internal.h
Просмотреть файл

@ -251,6 +251,10 @@ extern orte_data_type_t orte_dss_num_reg_types;
orte_std_cntr_t *bytes_used);
int orte_dss_load(orte_buffer_t *buffer, void *payload, orte_std_cntr_t bytes_used);
int orte_dss_xfer_payload(orte_buffer_t *dest, orte_buffer_t *src);
int orte_dss_copy_payload(orte_buffer_t *dest, orte_buffer_t *src);
int orte_dss_register(orte_dss_pack_fn_t pack_fn,
orte_dss_unpack_fn_t unpack_fn,
orte_dss_copy_fn_t copy_fn,

69
orte/dss/dss_load_unload.c
Просмотреть файл

@ -31,7 +31,7 @@
#include <netinet/in.h>
#endif
#include "orte/mca/ns/base/base.h"
#include "orte/mca/errmgr/errmgr.h"
#include "orte/dss/dss_internal.h"
@ -129,3 +129,70 @@ int orte_dss_load(orte_buffer_t *buffer, void *payload,
return ORTE_SUCCESS;
}
int orte_dss_xfer_payload(orte_buffer_t *dest, orte_buffer_t *src)
{
void *payload;
orte_std_cntr_t bytes_used;
int rc;
/* ensure we have valid source and destination */
if (NULL == dest || NULL == src) {
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
return ORTE_ERR_BAD_PARAM;
}
/* unload the src payload */
if (ORTE_SUCCESS != (rc = orte_dss_unload(src, &payload, &bytes_used))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* load it into the dest, overwriting anything already there */
if (ORTE_SUCCESS != (rc = orte_dss_load(dest, payload, bytes_used))) {
ORTE_ERROR_LOG(rc);
return rc;
}
return ORTE_SUCCESS;
}
int orte_dss_copy_payload(orte_buffer_t *dest, orte_buffer_t *src)
{
char *dst_ptr;
/* ensure we have valid source and destination */
if (NULL == dest || NULL == src) {
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
return ORTE_ERR_BAD_PARAM;
}
/* if the dest is already populated, check to ensure that both
* source and dest are of the same buffer type
*/
if (0 != dest->bytes_used) {
if (dest->type != src->type) {
ORTE_ERROR_LOG(ORTE_ERR_BUFFER);
return ORTE_ERR_BUFFER;
}
}
/* either the dest was empty or the two types already match -
* either way, just ensure the two types DO match
*/
dest->type = src->type;
/* add room to the dest for the src buffer's payload */
if (NULL == (dst_ptr = orte_dss_buffer_extend(dest, src->bytes_used))) {
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* copy the src payload to the specified location in dest */
memcpy(dst_ptr, src->base_ptr, src->bytes_used);
/* adjust the dest buffer's bookkeeping */
dest->bytes_used += src->bytes_used;
dest->pack_ptr = ((char*)dest->pack_ptr) + src->bytes_used;
return ORTE_SUCCESS;
}

2
orte/dss/dss_open_close.c
Просмотреть файл

@ -57,6 +57,8 @@ orte_dss_t orte_dss = {
orte_dss_peek,
orte_dss_unload,
orte_dss_load,
orte_dss_xfer_payload,
orte_dss_copy_payload,
orte_dss_register,
orte_dss_lookup_data_type,
orte_dss_dump_data_types,

6
orte/dss/dss_register.c
Просмотреть файл

@ -55,10 +55,16 @@ int orte_dss_register(orte_dss_pack_fn_t pack_fn,
i < orte_dss_types->size; i++) {
if (NULL != ptr[i]) {
j++;
/* check if the name exists */
if (0 == strcmp(ptr[i]->odti_name, name)) {
ORTE_ERROR_LOG(ORTE_ERR_DATA_TYPE_REDEF);
return ORTE_ERR_DATA_TYPE_REDEF;
}
/* check if the specified type exists */
if (*type > 0 && ptr[i]->odti_type == *type) {
ORTE_ERROR_LOG(ORTE_ERR_DATA_TYPE_REDEF);
return ORTE_ERR_DATA_TYPE_REDEF;
}
}
}

8
orte/include/orte/orte_types.h
Просмотреть файл

@ -129,13 +129,15 @@ typedef void* orte_iov_base_ptr_t;
#define ORTE_MAPPED_NODE (orte_data_type_t) 56 /**< node entry on map */
#define ORTE_ATTRIBUTE (orte_data_type_t) 57 /**< attribute used to control framework behavior */
#define ORTE_ATTR_LIST (orte_data_type_t) 58 /**< list of attributes */
/* RML types */
#define ORTE_RML_TAG (orte_data_type_t) 59 /**< tag for sending/receiving messages */
/* DAEMON communication type */
#define ORTE_DAEMON_CMD (orte_data_type_t) 59 /**< command flag for communicating with the daemon */
/* DAEMON communication type */
#define ORTE_DAEMON_CMD (orte_data_type_t) 60 /**< command flag for communicating with the daemon */
/* Need a command separate from ORTE_DAEMON_CMD, so that we can receive on
* them both at the same time */
#define ORTE_CKPT_CMD (orte_data_type_t) 60 /**< command flag for communicating with HNP */
#define ORTE_CKPT_CMD (orte_data_type_t) 61 /**< command flag for communicating with HNP */
/* define the starting point for dynamically assigning data types */

24
orte/mca/gpr/base/base.h
Просмотреть файл

@ -100,14 +100,15 @@ extern "C" {
#define ORTE_GPR_DUMP_TRIGGERS_CMD (uint8_t) 14
#define ORTE_GPR_DUMP_SUBSCRIPTIONS_CMD (uint8_t) 15
#define ORTE_GPR_DUMP_CALLBACKS_CMD (uint8_t) 16
#define ORTE_GPR_INCREMENT_VALUE_CMD (uint8_t) 17
#define ORTE_GPR_DECREMENT_VALUE_CMD (uint8_t) 18
#define ORTE_GPR_COMPOUND_CMD (uint8_t) 19
#define ORTE_GPR_CLEANUP_JOB_CMD (uint8_t) 20
#define ORTE_GPR_CLEANUP_PROC_CMD (uint8_t) 21
#define ORTE_GPR_DUMP_A_TRIGGER_CMD (uint8_t) 22
#define ORTE_GPR_DUMP_A_SUBSCRIPTION_CMD (uint8_t) 23
#define ORTE_GPR_DUMP_SEGMENT_SIZE_CMD (uint8_t) 24
#define ORTE_GPR_ARITH_CMD (uint8_t) 17
#define ORTE_GPR_INCREMENT_VALUE_CMD (uint8_t) 18
#define ORTE_GPR_DECREMENT_VALUE_CMD (uint8_t) 19
#define ORTE_GPR_COMPOUND_CMD (uint8_t) 20
#define ORTE_GPR_CLEANUP_JOB_CMD (uint8_t) 21
#define ORTE_GPR_CLEANUP_PROC_CMD (uint8_t) 22
#define ORTE_GPR_DUMP_A_TRIGGER_CMD (uint8_t) 23
#define ORTE_GPR_DUMP_A_SUBSCRIPTION_CMD (uint8_t) 24
#define ORTE_GPR_DUMP_SEGMENT_SIZE_CMD (uint8_t) 25
#define ORTE_GPR_ERROR (uint8_t)0xff
typedef uint8_t orte_gpr_cmd_flag_t;
@ -262,6 +263,13 @@ typedef uint8_t orte_gpr_cmd_flag_t;
orte_process_name_t *proc);
ORTE_DECLSPEC int orte_gpr_base_unpack_cleanup_proc(orte_buffer_t *buffer, int *ret);
ORTE_DECLSPEC int orte_gpr_base_pack_arith(orte_buffer_t *cmd,
orte_gpr_addr_mode_t addr_mode,
char *segment, char **tokens, char **keys,
orte_dss_arith_op_t operation,
orte_data_value_t *operand);
ORTE_DECLSPEC int orte_gpr_base_unpack_arith(orte_buffer_t *buffer, int *ret);
ORTE_DECLSPEC int orte_gpr_base_pack_increment_value(orte_buffer_t *cmd, orte_gpr_value_t *value);
ORTE_DECLSPEC int orte_gpr_base_unpack_increment_value(orte_buffer_t *buffer, int *ret);

89
orte/mca/gpr/base/pack_api_cmd/gpr_base_pack_arithmetic_ops.c
Просмотреть файл

@ -36,6 +36,95 @@
#include "orte/mca/gpr/base/base.h"
int orte_gpr_base_pack_arith(orte_buffer_t *cmd,
orte_gpr_addr_mode_t addr_mode,
char *segment, char **tokens, char **keys,
orte_dss_arith_op_t operation,
orte_data_value_t *operand)
{
orte_gpr_cmd_flag_t command;
orte_std_cntr_t n;
char **ptr;
int rc;
OPAL_TRACE(3);
command = ORTE_GPR_ARITH_CMD;
if (ORTE_SUCCESS != (rc = orte_dss.pack(cmd, &command, 1, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (ORTE_SUCCESS != (rc = orte_dss.pack(cmd, &addr_mode, 1, ORTE_GPR_ADDR_MODE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (ORTE_SUCCESS != (rc = orte_dss.pack(cmd, &segment, 1, ORTE_STRING))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* compute number of tokens */
n = 0;
if (NULL != tokens) {
ptr = tokens;
while (NULL != ptr[n]) {
n++;
}
}
/* pack number of tokens */
if (ORTE_SUCCESS != (rc = orte_dss.pack(cmd, &n, 1, ORTE_STD_CNTR))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (n > 0) {
if (ORTE_SUCCESS != (rc = orte_dss.pack(cmd, tokens, n, ORTE_STRING))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
/* compute number of keys */
n = 0;
if (NULL != keys) {
ptr = keys;
while (NULL != ptr[n]) {
n++;
}
}
/* pack number of keys */
if (ORTE_SUCCESS != (rc = orte_dss.pack(cmd, &n, 1, ORTE_STD_CNTR))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (n > 0) {
if (ORTE_SUCCESS != (rc = orte_dss.pack(cmd, keys, n, ORTE_STRING))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
/** pack the operation flag */
if (ORTE_SUCCESS != (rc = orte_dss.pack(cmd, &operation, 1, ORTE_ARITH_OP))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/** pack the operand */
if (ORTE_SUCCESS != (rc = orte_dss.pack(cmd, &operand, 1, ORTE_DATA_VALUE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
return ORTE_SUCCESS;
}
int orte_gpr_base_pack_increment_value(orte_buffer_t *cmd, orte_gpr_value_t *value)
{
orte_gpr_cmd_flag_t command;

29
orte/mca/gpr/base/unpack_api_response/gpr_base_unpack_arithmetic_ops.c
Просмотреть файл

@ -36,6 +36,34 @@
#include "orte/mca/gpr/base/base.h"
int orte_gpr_base_unpack_arith(orte_buffer_t *buffer, int *ret)
{
orte_gpr_cmd_flag_t command;
int rc;
orte_std_cntr_t n;
OPAL_TRACE(3);
n=1;
if (ORTE_SUCCESS != (rc = orte_dss.unpack(buffer, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (ORTE_GPR_ARITH_CMD != command) {
ORTE_ERROR_LOG(ORTE_ERR_COMM_FAILURE);
return ORTE_ERR_COMM_FAILURE;
}
n=1;
if (ORTE_SUCCESS != (rc = orte_dss.unpack(buffer, ret, &n, ORTE_INT))) {
ORTE_ERROR_LOG(rc);
return rc;
}
return ORTE_SUCCESS;
}
int orte_gpr_base_unpack_increment_value(orte_buffer_t *cmd, int *ret)
{
orte_gpr_cmd_flag_t command;
@ -62,7 +90,6 @@ int orte_gpr_base_unpack_increment_value(orte_buffer_t *cmd, int *ret)
}
return ORTE_SUCCESS;
}
int orte_gpr_base_unpack_decrement_value(orte_buffer_t *cmd, int *ret)

115
orte/mca/gpr/gpr.h
Просмотреть файл

@ -624,6 +624,28 @@ typedef int (*orte_gpr_base_module_increment_value_fn_t)(orte_gpr_value_t *value
*/
typedef int (*orte_gpr_base_module_decrement_value_fn_t)(orte_gpr_value_t *value);
/*
* General arithmetic operation
* This function performs the specified arithmetic operation on registry entries
* defined by the search criteria. Note that the operation flags are those defined in
* orte/dss/dss_types.h (ORTE_DSS_ADD, ORTE_DSS_SUB, etc.).
*
* @param operation orte_dss_arith_op_t value indicating the operation to be performed
* @param value Pointer to an orte_data_value_t object containing the value to be used
* in the operation. This value will be added to or subtracted from the values found by
* the search criteria, or will multiply or divide those values, according to what was
* specified. The point here is that this value is always the right most in the specified
* operation (e.g., for division, it is (found entry) / value).
*
* The results of the operation are stored back in their original location, thus overwriting
* the original values. If no pre-existing entry is found, the entry will be created
* with the specified value.
*/
typedef int (*orte_gpr_base_module_arith_fn_t)(orte_gpr_addr_mode_t addr_mode,
char *segment, char **tokens, char **keys,
orte_dss_arith_op_t operation,
orte_data_value_t *value);
/* Deliver a notify message
* To support the broadcast of stage gate messages that supply all subscribed
@ -682,61 +704,62 @@ typedef int (*orte_gpr_base_module_create_keyval_fn_t)(orte_gpr_keyval_t **keyva
*/
struct orte_gpr_base_module_1_0_0_t {
/* INIT */
orte_gpr_base_module_init_fn_t init;
orte_gpr_base_module_init_fn_t init;
/* BLOCKING OPERATIONS */
orte_gpr_base_module_get_fn_t get;
orte_gpr_base_module_get_conditional_fn_t get_conditional;
orte_gpr_base_module_put_fn_t put;
orte_gpr_base_module_put_1_fn_t put_1;
orte_gpr_base_module_put_N_fn_t put_N;
orte_gpr_base_module_delete_entries_fn_t delete_entries;
orte_gpr_base_module_delete_segment_fn_t delete_segment;
orte_gpr_base_module_index_fn_t index;
orte_gpr_base_module_get_fn_t get;
orte_gpr_base_module_get_conditional_fn_t get_conditional;
orte_gpr_base_module_put_fn_t put;
orte_gpr_base_module_put_1_fn_t put_1;
orte_gpr_base_module_put_N_fn_t put_N;
orte_gpr_base_module_delete_entries_fn_t delete_entries;
orte_gpr_base_module_delete_segment_fn_t delete_segment;
orte_gpr_base_module_index_fn_t index;
/* NON-BLOCKING OPERATIONS */
orte_gpr_base_module_get_nb_fn_t get_nb;
orte_gpr_base_module_put_nb_fn_t put_nb;
orte_gpr_base_module_delete_entries_nb_fn_t delete_entries_nb;
orte_gpr_base_module_delete_segment_nb_fn_t delete_segment_nb;
orte_gpr_base_module_index_nb_fn_t index_nb;
orte_gpr_base_module_get_nb_fn_t get_nb;
orte_gpr_base_module_put_nb_fn_t put_nb;
orte_gpr_base_module_delete_entries_nb_fn_t delete_entries_nb;
orte_gpr_base_module_delete_segment_nb_fn_t delete_segment_nb;
orte_gpr_base_module_index_nb_fn_t index_nb;
/* GENERAL OPERATIONS */
orte_gpr_base_module_create_value_fn_t create_value;
orte_gpr_base_module_create_keyval_fn_t create_keyval;
orte_gpr_base_module_preallocate_segment_fn_t preallocate_segment;
orte_gpr_base_module_deliver_notify_msg_t deliver_notify_msg;
orte_gpr_base_module_create_value_fn_t create_value;
orte_gpr_base_module_create_keyval_fn_t create_keyval;
orte_gpr_base_module_preallocate_segment_fn_t preallocate_segment;
orte_gpr_base_module_deliver_notify_msg_t deliver_notify_msg;
/* ARITHMETIC OPERATIONS */
orte_gpr_base_module_increment_value_fn_t increment_value;
orte_gpr_base_module_decrement_value_fn_t decrement_value;
orte_gpr_base_module_arith_fn_t arith;
orte_gpr_base_module_increment_value_fn_t increment_value;
orte_gpr_base_module_decrement_value_fn_t decrement_value;
/* SUBSCRIBE OPERATIONS */
orte_gpr_base_module_subscribe_fn_t subscribe;
orte_gpr_base_module_subscribe_1_fn_t subscribe_1;
orte_gpr_base_module_subscribe_N_fn_t subscribe_N;
orte_gpr_base_module_define_trigger_fn_t define_trigger;
orte_gpr_base_module_define_trigger_level_fn_t define_trigger_level;
orte_gpr_base_module_unsubscribe_fn_t unsubscribe;
orte_gpr_base_module_cancel_trigger_fn_t cancel_trigger;
orte_gpr_base_module_subscribe_fn_t subscribe;
orte_gpr_base_module_subscribe_1_fn_t subscribe_1;
orte_gpr_base_module_subscribe_N_fn_t subscribe_N;
orte_gpr_base_module_define_trigger_fn_t define_trigger;
orte_gpr_base_module_define_trigger_level_fn_t define_trigger_level;
orte_gpr_base_module_unsubscribe_fn_t unsubscribe;
orte_gpr_base_module_cancel_trigger_fn_t cancel_trigger;
/* COMPOUND COMMANDS */
orte_gpr_base_module_begin_compound_cmd_fn_t begin_compound_cmd;
orte_gpr_base_module_stop_compound_cmd_fn_t stop_compound_cmd;
orte_gpr_base_module_exec_compound_cmd_fn_t exec_compound_cmd;
orte_gpr_base_module_begin_compound_cmd_fn_t begin_compound_cmd;
orte_gpr_base_module_stop_compound_cmd_fn_t stop_compound_cmd;
orte_gpr_base_module_exec_compound_cmd_fn_t exec_compound_cmd;
/* DIAGNOSTIC OPERATIONS */
orte_gpr_base_module_dump_all_fn_t dump_all;
orte_gpr_base_module_dump_segment_fn_t dump_segment;
orte_gpr_base_module_dump_triggers_fn_t dump_triggers;
orte_gpr_base_module_dump_subscriptions_fn_t dump_subscriptions;
orte_gpr_base_module_dump_a_trigger_fn_t dump_a_trigger;
orte_gpr_base_module_dump_a_subscription_fn_t dump_a_subscription;
orte_gpr_base_module_dump_local_triggers_fn_t dump_local_triggers;
orte_gpr_base_module_dump_local_subscriptions_fn_t dump_local_subscriptions;
orte_gpr_base_module_dump_callbacks_fn_t dump_callbacks;
orte_gpr_base_module_dump_notify_msg_fn_t dump_notify_msg;
orte_gpr_base_module_dump_notify_data_fn_t dump_notify_data;
orte_gpr_base_module_dump_value_fn_t dump_value;
orte_gpr_base_module_dump_segment_size_fn_t dump_segment_size;
orte_gpr_base_module_dump_all_fn_t dump_all;
orte_gpr_base_module_dump_segment_fn_t dump_segment;
orte_gpr_base_module_dump_triggers_fn_t dump_triggers;
orte_gpr_base_module_dump_subscriptions_fn_t dump_subscriptions;
orte_gpr_base_module_dump_a_trigger_fn_t dump_a_trigger;
orte_gpr_base_module_dump_a_subscription_fn_t dump_a_subscription;
orte_gpr_base_module_dump_local_triggers_fn_t dump_local_triggers;
orte_gpr_base_module_dump_local_subscriptions_fn_t dump_local_subscriptions;
orte_gpr_base_module_dump_callbacks_fn_t dump_callbacks;
orte_gpr_base_module_dump_notify_msg_fn_t dump_notify_msg;
orte_gpr_base_module_dump_notify_data_fn_t dump_notify_data;
orte_gpr_base_module_dump_value_fn_t dump_value;
orte_gpr_base_module_dump_segment_size_fn_t dump_segment_size;
/* CLEANUP OPERATIONS */
orte_gpr_base_module_cleanup_job_fn_t cleanup_job;
orte_gpr_base_module_cleanup_proc_fn_t cleanup_process;
orte_gpr_base_module_cleanup_job_fn_t cleanup_job;
orte_gpr_base_module_cleanup_proc_fn_t cleanup_process;
orte_gpr_base_module_ft_event_fn_t ft_event;
orte_gpr_base_module_ft_event_fn_t ft_event;
};
typedef struct orte_gpr_base_module_1_0_0_t orte_gpr_base_module_1_0_0_t;
typedef orte_gpr_base_module_1_0_0_t orte_gpr_base_module_t;

10
orte/mca/gpr/null/gpr_null.c
Просмотреть файл

@ -251,6 +251,15 @@ orte_gpr_null_decrement_value(orte_gpr_value_t * value)
return ORTE_SUCCESS;
}
static int
orte_gpr_null_arith(orte_gpr_addr_mode_t addr_mode,
char *segment, char **tokens, char **keys,
orte_dss_arith_op_t operation,
orte_data_value_t *value)
{
return ORTE_SUCCESS;
}
static int orte_gpr_null_put_1(orte_gpr_addr_mode_t addr_mode,
char *segment, char **tokens,
char *key, orte_data_value_t* value)
@ -372,6 +381,7 @@ orte_gpr_base_module_t orte_gpr_null_module = {
orte_gpr_null_preallocate_segment,
orte_gpr_null_deliver_notify_msg,
/* ARITHMETIC OPERATIONS */
orte_gpr_null_arith,
orte_gpr_null_increment_value,
orte_gpr_null_decrement_value,
/* SUBSCRIBE OPERATIONS */

5
orte/mca/gpr/proxy/gpr_proxy.h
Просмотреть файл

@ -112,6 +112,11 @@ int orte_gpr_proxy_exec_compound_cmd(void);
/*
* Arithmetic operations
*/
int orte_gpr_proxy_arith(orte_gpr_addr_mode_t addr_mode,
char *segment, char **tokens, char **keys,
orte_dss_arith_op_t operation,
orte_data_value_t *value);
int orte_gpr_proxy_increment_value(orte_gpr_value_t *value);
int orte_gpr_proxy_decrement_value(orte_gpr_value_t *value);

62
orte/mca/gpr/proxy/gpr_proxy_arithmetic_ops.c
Просмотреть файл

@ -41,6 +41,68 @@
#include "gpr_proxy.h"
int orte_gpr_proxy_arith(orte_gpr_addr_mode_t addr_mode,
char *segment, char **tokens, char **keys,
orte_dss_arith_op_t operation,
orte_data_value_t *value)
{
orte_buffer_t *cmd, *answer;
int rc, ret;
OPAL_TRACE(1);
if (orte_gpr_proxy_globals.compound_cmd_mode) {
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_arith(orte_gpr_proxy_globals.compound_cmd,
addr_mode, segment, tokens,
keys, operation, value))) {
ORTE_ERROR_LOG(rc);
}
return rc;
}
cmd = OBJ_NEW(orte_buffer_t);
if (NULL == cmd) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_arith(cmd, addr_mode, segment, tokens,
keys, operation, value))) {
OBJ_RELEASE(cmd);
ORTE_ERROR_LOG(rc);
return rc;
}
if (0 > orte_rml.send_buffer(orte_process_info.gpr_replica, cmd, ORTE_RML_TAG_GPR, 0)) {
ORTE_ERROR_LOG(ORTE_ERR_COMM_FAILURE);
OBJ_RELEASE(cmd);
return ORTE_ERR_COMM_FAILURE;
}
OBJ_RELEASE(cmd);
answer = OBJ_NEW(orte_buffer_t);
if (NULL == answer) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
if (0 > orte_rml.recv_buffer(orte_process_info.gpr_replica, answer, ORTE_RML_TAG_GPR)) {
ORTE_ERROR_LOG(ORTE_ERR_COMM_FAILURE);
OBJ_RELEASE(answer);
return ORTE_ERR_COMM_FAILURE;
}
if (ORTE_SUCCESS != (rc = orte_gpr_base_unpack_arith(answer, &ret))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(answer);
return rc;
}
OBJ_RELEASE(answer);
return ret;
}
int orte_gpr_proxy_increment_value(orte_gpr_value_t *value)
{
orte_buffer_t *cmd, *answer;

1
orte/mca/gpr/proxy/gpr_proxy_component.c
Просмотреть файл

@ -91,6 +91,7 @@ static orte_gpr_base_module_t orte_gpr_proxy = {
orte_gpr_proxy_preallocate_segment,
orte_gpr_proxy_deliver_notify_msg,
/* ARITHMETIC OPERATIONS */
orte_gpr_proxy_arith,
orte_gpr_proxy_increment_value,
orte_gpr_proxy_decrement_value,
/* SUBSCRIBE OPERATIONS */

5
orte/mca/gpr/replica/api_layer/gpr_replica_api.h
Просмотреть файл

@ -61,6 +61,11 @@ int orte_gpr_replica_exec_compound_cmd(void);
/*
* Arithmetic operations
*/
int orte_gpr_replica_arith(orte_gpr_addr_mode_t addr_mode,
char *segment, char **tokens, char **keys,
orte_dss_arith_op_t operation,
orte_data_value_t *operand);
int orte_gpr_replica_increment_value(orte_gpr_value_t *value);
int orte_gpr_replica_decrement_value(orte_gpr_value_t *value);

63
orte/mca/gpr/replica/api_layer/gpr_replica_arithmetic_ops_api.c
Просмотреть файл

@ -36,6 +36,69 @@
#include "gpr_replica_api.h"
int orte_gpr_replica_arith(orte_gpr_addr_mode_t addr_mode,
char *segment, char **tokens, char **keys,
orte_dss_arith_op_t operation,
orte_data_value_t *operand)
{
int rc;
orte_std_cntr_t num_tokens, num_keys;
orte_gpr_replica_segment_t *seg=NULL;
orte_gpr_replica_itag_t *itags=NULL, *keytags=NULL;
OPAL_TRACE(1);
OPAL_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
/** find the segment */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_seg(&seg, true, segment))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/** convert tokens to array of itags */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_get_itag_list(&itags, seg,
tokens, &num_tokens))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/** convert keys to array of itags */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_get_itag_list(&keytags, seg,
keys, &num_keys))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
if (ORTE_SUCCESS != (rc = orte_gpr_replica_arith_op_fn(addr_mode, seg, itags, num_tokens,
num_keys, keytags, operation, operand))) {
ORTE_ERROR_LOG(rc);
}
CLEANUP:
/** release lists of itags */
if (NULL != itags) {
free(itags);
}
if (NULL != keytags) {
free(keytags);
}
if (ORTE_SUCCESS == rc) {
if (ORTE_SUCCESS !=
(rc = orte_gpr_replica_check_events())) {
ORTE_ERROR_LOG(rc);
OPAL_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
rc = orte_gpr_replica_process_callbacks();
}
OPAL_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
int orte_gpr_replica_increment_value(orte_gpr_value_t *value)
{
int rc;

139
orte/mca/gpr/replica/communications/gpr_replica_arithmetic_ops_cm.c
Просмотреть файл

@ -34,6 +34,145 @@
#include "orte/mca/gpr/replica/communications/gpr_replica_comm.h"
int orte_gpr_replica_recv_arith_op_cmd(orte_buffer_t *input_buffer, orte_buffer_t *answer)
{
orte_gpr_cmd_flag_t command=ORTE_GPR_ARITH_CMD;
orte_std_cntr_t n, num_tokens, num_keys;
orte_gpr_addr_mode_t addr_mode;
orte_gpr_replica_segment_t *seg=NULL;
orte_gpr_replica_itag_t *tokentags=NULL, *keytags=NULL;
orte_dss_arith_op_t op_flag;
orte_data_value_t *operand;
int rc, ret;
char *segment=NULL, **tokens=NULL, **keys=NULL;
OPAL_TRACE(3);
if (ORTE_SUCCESS != (rc = orte_dss.pack(answer, &command, 1, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
n = 1;
if (ORTE_SUCCESS != (ret = orte_dss.unpack(input_buffer, &addr_mode, &n, ORTE_GPR_ADDR_MODE))) {
ORTE_ERROR_LOG(ret);
goto RETURN_ERROR;
}
n = 1;
if (ORTE_SUCCESS != (ret = orte_dss.unpack(input_buffer, &segment, &n, ORTE_STRING))) {
ORTE_ERROR_LOG(ret);
goto RETURN_ERROR;
}
n = 1;
if (ORTE_SUCCESS != (ret = orte_dss.unpack(input_buffer, &num_tokens, &n, ORTE_STD_CNTR))) {
ORTE_ERROR_LOG(ret);
goto RETURN_ERROR;
}
if (0 < num_tokens) { /* tokens provided - get them */
tokens = (char**)malloc(num_tokens*sizeof(char*));
if (NULL == tokens) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
ret = ORTE_ERR_OUT_OF_RESOURCE;
goto RETURN_ERROR;
}
n = num_tokens;
if (ORTE_SUCCESS != (ret = orte_dss.unpack(input_buffer, tokens, &n, ORTE_STRING))) {
ORTE_ERROR_LOG(ret);
free(tokens);
goto RETURN_ERROR;
}
} else { /* no tokens provided */
tokens = NULL;
}
n = 1;
if (ORTE_SUCCESS != (ret = orte_dss.unpack(input_buffer, &num_keys, &n, ORTE_STD_CNTR))) {
ORTE_ERROR_LOG(ret);
goto RETURN_ERROR;
}
if (0 < num_keys) { /* keys provided - get them */
keys = (char**)malloc(num_keys*sizeof(char*));
if (NULL == keys) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
ret = ORTE_ERR_OUT_OF_RESOURCE;
goto RETURN_ERROR;
}
n = num_keys;
if (ORTE_SUCCESS != (ret = orte_dss.unpack(input_buffer, keys, &n, ORTE_STRING))) {
ORTE_ERROR_LOG(ret);
goto RETURN_ERROR;
}
} else { /* no keys provided */
keys = NULL;
}
/* find the segment */
if (ORTE_SUCCESS != (ret = orte_gpr_replica_find_seg(&seg, true, segment))) {
ORTE_ERROR_LOG(ret);
goto RETURN_ERROR;
}
/* convert tokens to array of itags */
if (ORTE_SUCCESS != (ret = orte_gpr_replica_get_itag_list(&tokentags, seg,
tokens, &num_tokens))) {
ORTE_ERROR_LOG(ret);
goto RETURN_ERROR;
}
/* convert keys to array of itags */
if (ORTE_SUCCESS != (ret = orte_gpr_replica_get_itag_list(&keytags, seg,
keys, &num_keys))) {
ORTE_ERROR_LOG(ret);
goto RETURN_ERROR;
}
/** unpack the operation flag */
n = 1;
if (ORTE_SUCCESS != (rc = orte_dss.unpack(input_buffer, &op_flag, &n, ORTE_ARITH_OP))) {
ORTE_ERROR_LOG(rc);
ret = rc;
goto RETURN_ERROR;
}
/** unpack the operand */
n = 1;
if (ORTE_SUCCESS != (rc = orte_dss.unpack(input_buffer, &operand, &n, ORTE_DATA_VALUE))) {
ORTE_ERROR_LOG(rc);
ret = rc;
goto RETURN_ERROR;
}
if (ORTE_SUCCESS != (rc = orte_gpr_replica_arith_op_fn(addr_mode, seg, tokentags, num_tokens,
num_keys, keytags, op_flag, operand))) {
ORTE_ERROR_LOG(rc);
ret = rc;
goto RETURN_ERROR;
}
RETURN_ERROR:
/** cleanup memory */
OBJ_RELEASE(operand);
if (NULL != tokentags) free(tokentags);
if (NULL != keytags) free(keytags);
/** pack the resulting status to return to caller */
if (ORTE_SUCCESS != (rc = orte_dss.pack(answer, &ret, 1, ORTE_INT))) {
ORTE_ERROR_LOG(rc);
}
if (ORTE_SUCCESS == ret) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_check_events())) {
ORTE_ERROR_LOG(rc);
}
}
return ret;
}
int orte_gpr_replica_recv_increment_value_cmd(orte_buffer_t *cmd, orte_buffer_t *answer)
{
orte_gpr_cmd_flag_t command=ORTE_GPR_INCREMENT_VALUE_CMD;

17
orte/mca/gpr/replica/communications/gpr_replica_cmd_processor.c
Просмотреть файл

@ -290,7 +290,22 @@ int orte_gpr_replica_process_command_buffer(orte_buffer_t *input_buffer,
break;
case ORTE_GPR_INCREMENT_VALUE_CMD: /***** INCREMENT_VALUE *****/
case ORTE_GPR_ARITH_CMD: /***** ARITH *****/
if (orte_gpr_replica_globals.debug) {
opal_output(0, "\tarith cmd");
}
if (ORTE_SUCCESS != (ret =
orte_gpr_replica_recv_arith_op_cmd(input_buffer, answer))) {
ORTE_ERROR_LOG(ret);
goto RETURN_ERROR;
}
break;
case ORTE_GPR_INCREMENT_VALUE_CMD: /***** INCREMENT_VALUE *****/
if (orte_gpr_replica_globals.debug) {
opal_output(0, "\tincrement_value cmd");
}

2
orte/mca/gpr/replica/communications/gpr_replica_comm.h
Просмотреть файл

@ -141,6 +141,8 @@ int orte_gpr_replica_recv_cleanup_job_cmd(orte_buffer_t *input_buffer,
int orte_gpr_replica_recv_cleanup_proc_cmd(orte_buffer_t *input_buffer,
orte_buffer_t *output_buffer);
int orte_gpr_replica_recv_arith_op_cmd(orte_buffer_t *cmd, orte_buffer_t *answer);
int orte_gpr_replica_recv_increment_value_cmd(orte_buffer_t *input_buffer,
orte_buffer_t *output_buffer);

163
orte/mca/gpr/replica/functional_layer/gpr_replica_arithmetic_ops_fn.c
Просмотреть файл

@ -36,6 +36,116 @@
#include "orte/mca/gpr/replica/functional_layer/gpr_replica_fn.h"
static int add_zero_itagval(orte_gpr_replica_itagval_t **iptr,
orte_gpr_replica_segment_t *seg,
orte_gpr_replica_container_t *cptr,
orte_gpr_replica_itag_t keytag,
orte_data_type_t type);
int orte_gpr_replica_arith_op_fn(orte_gpr_addr_mode_t addr_mode,
orte_gpr_replica_segment_t *seg,
orte_gpr_replica_itag_t *tokentags,
orte_std_cntr_t num_tokens,
orte_std_cntr_t cnt,
orte_gpr_replica_itag_t *keytags,
orte_dss_arith_op_t op_flag,
orte_data_value_t *operand)
{
orte_gpr_replica_container_t **cptr, *cptr2;
orte_gpr_replica_addr_mode_t tok_mode;
orte_gpr_replica_itagval_t **ival, *ivptr;
int rc;
orte_std_cntr_t j, k, m, n;
OPAL_TRACE(2);
/** extract the token address mode */
tok_mode = 0x004f & addr_mode;
if (0x00 == tok_mode) { /** default tokens addressing mode to AND */
tok_mode = ORTE_GPR_REPLICA_AND;
}
/** find the specified container(s) */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_containers(seg, tok_mode,
tokentags, num_tokens))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (0 == orte_gpr_replica_globals.num_srch_cptr) {
/* no container found - let's create the container */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_create_container(&cptr2, seg,
num_tokens, tokentags))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* for each provided value... */
for (n=0; n < cnt; n++) {
/* store "zero" value for that key in the container - since we already
* have converted keys into itags, all we need to do is store the data
* in the container
*/
if (ORTE_SUCCESS != (rc = add_zero_itagval(&ivptr, seg, cptr2, keytags[n], operand->type))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* now perform the desired operation on *that* value */
if (ORTE_SUCCESS != (rc = orte_dss.arith(ivptr->value, operand, op_flag))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
/* all done */
return ORTE_SUCCESS;
}
/* otherwise, go through list of containers. For each one,
* find the entry and then perform operation
*/
cptr = (orte_gpr_replica_container_t**)(orte_gpr_replica_globals.srch_cptr)->addr;
for (j=0, m=0; m < orte_gpr_replica_globals.num_srch_cptr &&
j < (orte_gpr_replica_globals.srch_cptr)->size; j++) { /* for each container */
if (NULL != cptr[j]) {
m++;
if (ORTE_SUCCESS == orte_gpr_replica_search_container(ORTE_GPR_REPLICA_OR, keytags, cnt, cptr[j])) {
if (0 < orte_gpr_replica_globals.num_srch_ival) {
/* if one or more of the keyvals were found */
ival = (orte_gpr_replica_itagval_t**)((orte_gpr_replica_globals.srch_ival)->addr);
for (k=0, n=0; n < orte_gpr_replica_globals.num_srch_ival &&
k < (orte_gpr_replica_globals.srch_ival)->size; k++) { /* for each found keyval */
if (NULL != ival[k]) {
n++;
if (ORTE_SUCCESS != (rc = orte_dss.arith(ival[k]->value, operand, op_flag))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
}
}
} else {
/* if none of the keyvals were found, then add them and perform the operation */
for (n=0; n < cnt; n++) {
/* store "zero" value for that key in the container - since we already
* have converted keys into itags, all we need to do is store the data
* in the container
*/
if (ORTE_SUCCESS != (rc = add_zero_itagval(&ivptr, seg, cptr[j], keytags[n], operand->type))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* now perform the desired operation on *that* value */
if (ORTE_SUCCESS != (rc = orte_dss.arith(ivptr->value, operand, op_flag))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
}
}
}
return ORTE_SUCCESS;
}
int orte_gpr_replica_increment_value_fn(orte_gpr_addr_mode_t addr_mode,
orte_gpr_replica_segment_t *seg,
@ -165,3 +275,56 @@ int orte_gpr_replica_decrement_value_fn(orte_gpr_addr_mode_t addr_mode,
}
return ORTE_SUCCESS;
}
static int add_zero_itagval(orte_gpr_replica_itagval_t **iptr,
orte_gpr_replica_segment_t *seg,
orte_gpr_replica_container_t *cptr,
orte_gpr_replica_itag_t keytag,
orte_data_type_t op_type)
{
orte_data_type_t type;
orte_data_value_t zval = ORTE_DATA_VALUE_EMPTY;
int8_t z8=0;
int16_t z16=0;
int32_t z32=0;
int64_t z64=0;
int rc;
zval.type = op_type; /* make the type match */
/* get the corresponding value - must ensure size matches */
type = op_type;
if (ORTE_STD_CNTR == type) {
type = ORTE_STD_CNTR_T;
}
switch (type) {
case ORTE_UINT8:
case ORTE_INT8:
zval.data = (void*)&z8;
break;
case ORTE_UINT16:
case ORTE_INT16:
zval.data = (void*)&z16;
break;
case ORTE_UINT32:
case ORTE_INT32:
zval.data = (void*)&z32;
break;
case ORTE_UINT64:
case ORTE_INT64:
zval.data = (void*)&z64;
break;
}
/* add the zero value */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_add_itagval(iptr, seg, cptr, keytag, &zval))) {
ORTE_ERROR_LOG(rc);
return rc;
}
return ORTE_SUCCESS;
}

15
orte/mca/gpr/replica/functional_layer/gpr_replica_fn.h
Просмотреть файл

@ -42,6 +42,15 @@ extern "C" {
/*
* Arithemetic operations
*/
int orte_gpr_replica_arith_op_fn(orte_gpr_addr_mode_t addr_mode,
orte_gpr_replica_segment_t *seg,
orte_gpr_replica_itag_t *itags,
orte_std_cntr_t num_tokens,
orte_std_cntr_t cnt,
orte_gpr_replica_itag_t *keytags,
orte_dss_arith_op_t op_flag,
orte_data_value_t *operand);
int orte_gpr_replica_increment_value_fn(orte_gpr_addr_mode_t addr_mode,
orte_gpr_replica_segment_t *seg,
orte_gpr_replica_itag_t *itags,
@ -176,6 +185,12 @@ int orte_gpr_replica_add_keyval(orte_gpr_replica_itagval_t **ivalptr,
orte_gpr_replica_container_t *cptr,
orte_gpr_keyval_t *kptr);
int orte_gpr_replica_add_itagval(orte_gpr_replica_itagval_t **ivalptr,
orte_gpr_replica_segment_t *seg,
orte_gpr_replica_container_t *cptr,
orte_gpr_replica_itag_t itag,
orte_data_value_t *dval);
int orte_gpr_replica_update_keyval(orte_gpr_replica_itagval_t **iptr,
orte_gpr_replica_segment_t *seg,
orte_gpr_replica_container_t *cptr,

45
orte/mca/gpr/replica/functional_layer/gpr_replica_segment_fn.c
Просмотреть файл

@ -151,7 +151,7 @@ int orte_gpr_replica_add_keyval(orte_gpr_replica_itagval_t **ivalptr,
orte_gpr_replica_container_t *cptr,
orte_gpr_keyval_t *kptr)
{
orte_gpr_replica_itagval_t *iptr;
orte_gpr_replica_itag_t itag;
int rc;
OPAL_TRACE(3);
@ -162,33 +162,50 @@ int orte_gpr_replica_add_keyval(orte_gpr_replica_itagval_t **ivalptr,
return ORTE_ERR_BAD_PARAM;
}
if (ORTE_SUCCESS != (rc = orte_gpr_replica_create_itag(&itag, seg, kptr->key))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (ORTE_SUCCESS != (rc = orte_gpr_replica_add_itagval(ivalptr, seg, cptr, itag, kptr->value))) {
ORTE_ERROR_LOG(rc);
return rc;
}
return ORTE_SUCCESS;
}
int orte_gpr_replica_add_itagval(orte_gpr_replica_itagval_t **ivalptr,
orte_gpr_replica_segment_t *seg,
orte_gpr_replica_container_t *cptr,
orte_gpr_replica_itag_t itag,
orte_data_value_t *dval)
{
orte_gpr_replica_itagval_t *iptr;
int rc;
iptr = OBJ_NEW(orte_gpr_replica_itagval_t);
if (NULL == iptr) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
iptr->itag = itag;
iptr->value = OBJ_NEW(orte_data_value_t);
if (NULL == iptr->value) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_RELEASE(iptr);
return ORTE_ERR_OUT_OF_RESOURCE;
}
if (ORTE_SUCCESS != (rc = orte_gpr_replica_create_itag(&(iptr->itag),
seg, kptr->key))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(iptr);
return rc;
}
/* it is perfectly acceptable to give us a keyval that doesn't have a value. For
/* it is perfectly acceptable to give us an itag that doesn't have a value. For
* example, we may want to predefine a location when we setup a trigger, then actually
* put a value in it later.
*/
if (NULL != kptr->value) {
iptr->value->type = kptr->value->type;
if (NULL != kptr->value->data) {
if (ORTE_SUCCESS != (rc = orte_dss.copy(&((iptr->value)->data), kptr->value->data, kptr->value->type))) {
if (NULL != dval) {
iptr->value->type = dval->type;
if (NULL != dval->data) {
if (ORTE_SUCCESS != (rc = orte_dss.copy(&((iptr->value)->data), dval->data, dval->type))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(iptr);
return rc;

1
orte/mca/gpr/replica/gpr_replica_component.c
Просмотреть файл

@ -91,6 +91,7 @@ static orte_gpr_base_module_t orte_gpr_replica_module = {
orte_gpr_replica_preallocate_segment,
orte_gpr_replica_deliver_notify_msg,
/* ARITHMETIC OPERATIONS */
orte_gpr_replica_arith,
orte_gpr_replica_increment_value,
orte_gpr_replica_decrement_value,
/* SUBSCRIBE OPERATIONS */

4
orte/mca/odls/default/odls_default_module.c
Просмотреть файл

@ -1535,8 +1535,8 @@ int orte_odls_default_deliver_message(orte_jobid_t job, orte_buffer_t *buffer, o
if (ORTE_EQUAL != orte_dss.compare(&job, &(child->name->jobid), ORTE_JOBID)) {
continue;
}
opal_output(orte_odls_globals.output, "odls: sending message to child [%ld, %ld, %ld]",
ORTE_NAME_ARGS(child->name));
opal_output(orte_odls_globals.output, "odls: sending message to tag %lu on child [%ld, %ld, %ld]",
(unsigned long)tag, ORTE_NAME_ARGS(child->name));
/* if so, send the message */
rc = orte_rml.send_buffer(child->name, buffer, tag, 0);

48
orte/mca/oob/base/base.h
Просмотреть файл

@ -33,11 +33,13 @@
#endif
#include "opal/mca/mca.h"
#include "opal/threads/condition.h"
#include "orte/dss/dss_types.h"
#include "orte/mca/ns/ns_types.h"
#include "orte/mca/gpr/gpr_types.h"
#include "orte/mca/oob/oob_types.h"
#include "orte/mca/rml/rml_types.h"
#if defined(c_plusplus) || defined(__cplusplus)
extern "C" {
@ -49,6 +51,8 @@ extern "C" {
ORTE_DECLSPEC extern bool orte_oob_base_timing;
ORTE_DECLSPEC extern bool orte_oob_xcast_timing;
ORTE_DECLSPEC extern int orte_oob_xcast_mode;
ORTE_DECLSPEC extern opal_mutex_t orte_oob_xcast_mutex;
ORTE_DECLSPEC extern opal_condition_t orte_oob_xcast_cond;
/*
* Flag indicating if this framework has been opened
@ -89,7 +93,7 @@ ORTE_DECLSPEC extern bool orte_oob_base_already_opened;
* an OOB module prior to calling this routine.
*/
ORTE_DECLSPEC char* mca_oob_get_contact_info(void);
ORTE_DECLSPEC char* mca_oob_get_my_contact_info(void);
/**
* Pre-populate the cache of contact information required by the OOB
@ -141,6 +145,11 @@ ORTE_DECLSPEC int mca_oob_parse_contact_info(const char* uri, orte_process_name_
ORTE_DECLSPEC int mca_oob_set_contact_info(const char*);
/**
* Update the contact info tables
*/
ORTE_DECLSPEC void mca_oob_update_contact_info(orte_gpr_notify_data_t* data, void* cbdata);
/**
* Similiar to unix writev(2).
*
@ -406,8 +415,41 @@ ORTE_DECLSPEC int mca_oob_recv_packed_nb(
*/
ORTE_DECLSPEC int mca_oob_xcast(orte_jobid_t job,
orte_gpr_notify_message_t *msg,
orte_gpr_trigger_cb_fn_t cbfunc);
orte_buffer_t *buffer,
orte_rml_tag_t tag);
ORTE_DECLSPEC int mca_oob_xcast_nb(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag);
ORTE_DECLSPEC int mca_oob_xcast_gate(orte_gpr_trigger_cb_fn_t cbfunc);
/*
* Register my contact info with the General Purpose Registry
* This function causes the component to "put" its contact info
* on the registry.
*/
ORTE_DECLSPEC int mca_oob_register_contact_info(void);
/*
* Register a subscription to receive contact info on other processes
* This function will typically be called from within a GPR compound command
* to register a subscription against a stage gate trigger. When fired, this
* will return the OOB contact info for all processes in the specified job
*/
ORTE_DECLSPEC int mca_oob_register_subscription(orte_jobid_t job, char *trigger);
/*
* Get contact info for a process or job
* Returns contact info for the specified process. If the vpid in the process name
* is WILDCARD, then it returns the contact info for all processes in the specified
* job. If the jobid is WILDCARD, then it returns the contact info for processes
* of the specified vpid across all jobs. Obviously, combining the two WILDCARD
* values will return contact info for everyone!
*/
ORTE_DECLSPEC int mca_oob_get_contact_info(orte_process_name_t *name, orte_gpr_notify_data_t **data);
/*
* Callback on exception condition.

4
orte/mca/oob/base/oob_base_close.c
Просмотреть файл

@ -41,6 +41,10 @@ int mca_oob_base_close(void)
}
/* destruct the condition variables for xcast */
OBJ_DESTRUCT(&orte_oob_xcast_mutex);
OBJ_DESTRUCT(&orte_oob_xcast_cond);
/* Finalize all the oob modules and free their list items */
for (item = opal_list_remove_first(&mca_oob_base_modules);
item != NULL;

97
orte/mca/oob/base/oob_base_init.c
Просмотреть файл

@ -186,7 +186,7 @@ int mca_oob_base_init(void)
* The caller is responsible for freeing the returned string.
*/
char* mca_oob_get_contact_info()
char* mca_oob_get_my_contact_info()
{
char *proc_name=NULL;
char *proc_addr = mca_oob.oob_get_addr();
@ -242,15 +242,14 @@ int mca_oob_set_contact_info(const char* contact_info)
}
/**
* Called to request the selected oob components to
* register their address with the seed daemon.
*/
* Called to request the selected oob components to
* initialize their connections to the HNP (if not an HNP), or
* to setup a listener for incoming connections (if an HNP)
*/
int mca_oob_base_module_init(void)
{
opal_list_item_t* item;
/* Initialize all modules after oob/gpr/ns have initialized */
for (item = opal_list_get_first(&mca_oob_base_modules);
item != opal_list_get_end(&mca_oob_base_modules);
item = opal_list_get_next(item)) {
@ -261,3 +260,89 @@ int mca_oob_base_module_init(void)
return ORTE_SUCCESS;
}
/**
* Called to have all selected oob components register their
* contact info on the GPR
*/
int mca_oob_register_contact_info(void)
{
opal_list_item_t* item;
int rc;
for (item = opal_list_get_first(&mca_oob_base_modules);
item != opal_list_get_end(&mca_oob_base_modules);
item = opal_list_get_next(item)) {
mca_oob_base_info_t* base = (mca_oob_base_info_t *) item;
if (NULL != base->oob_module->oob_register_contact_info) {
if (ORTE_SUCCESS != (rc = base->oob_module->oob_register_contact_info())) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
}
return ORTE_SUCCESS;
}
/**
* Called to have all selected oob components register a subscription
* to receive their required contact info from all processes in the
* specified job when the provided trigger fires
*/
int mca_oob_register_subscription(orte_jobid_t job, char *trigger)
{
opal_list_item_t* item;
int rc;
for (item = opal_list_get_first(&mca_oob_base_modules);
item != opal_list_get_end(&mca_oob_base_modules);
item = opal_list_get_next(item)) {
mca_oob_base_info_t* base = (mca_oob_base_info_t *) item;
if (NULL != base->oob_module->oob_register_subscription) {
if (ORTE_SUCCESS != (rc = base->oob_module->oob_register_subscription(job, trigger))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
}
return ORTE_SUCCESS;
}
/*
* Called to get contact info for a process or job from all selected
* oob components
*/
int mca_oob_get_contact_info(orte_process_name_t *name, orte_gpr_notify_data_t **data)
{
opal_list_item_t* item;
int rc;
for (item = opal_list_get_first(&mca_oob_base_modules);
item != opal_list_get_end(&mca_oob_base_modules);
item = opal_list_get_next(item)) {
mca_oob_base_info_t* base = (mca_oob_base_info_t *) item;
if (NULL != base->oob_module->oob_get_contact_info) {
if (ORTE_SUCCESS != (rc = base->oob_module->oob_get_contact_info(name, data))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
}
return ORTE_SUCCESS;
}
/*
* Called to update contact info tables in all selected oob components
*/
void mca_oob_update_contact_info(orte_gpr_notify_data_t* data, void* cbdata)
{
opal_list_item_t* item;
for (item = opal_list_get_first(&mca_oob_base_modules);
item != opal_list_get_end(&mca_oob_base_modules);
item = opal_list_get_next(item)) {
mca_oob_base_info_t* base = (mca_oob_base_info_t *) item;
if (NULL != base->oob_module->oob_update_contact_info) {
base->oob_module->oob_update_contact_info(data, cbdata);
}
}
}

51
orte/mca/oob/base/oob_base_open.c
Просмотреть файл

@ -20,10 +20,13 @@
#include "orte_config.h"
#include "orte/orte_constants.h"
#include "opal/mca/mca.h"
#include "opal/mca/base/base.h"
#include "opal/util/output.h"
#include "opal/mca/base/mca_base_param.h"
#include "opal/threads/condition.h"
#include "orte/mca/oob/oob.h"
@ -49,6 +52,8 @@ opal_list_t mca_oob_base_exception_handlers;
bool orte_oob_base_timing;
bool orte_oob_xcast_timing;
int orte_oob_xcast_mode;
opal_mutex_t orte_oob_xcast_mutex;
opal_condition_t orte_oob_xcast_cond;
bool orte_oob_base_already_opened = false;
@ -69,7 +74,11 @@ int mca_oob_base_open(void)
return ORTE_SUCCESS;
}
/* Open up all available components */
/* initialize the condition variables for xcast */
OBJ_CONSTRUCT(&orte_oob_xcast_mutex, opal_mutex_t);
OBJ_CONSTRUCT(&orte_oob_xcast_cond, opal_condition_t);
/* Open up all available components */
OBJ_CONSTRUCT(&mca_oob_base_components, opal_list_t);
OBJ_CONSTRUCT(&mca_oob_base_modules, opal_list_t);
@ -110,26 +119,26 @@ int mca_oob_base_open(void)
param = mca_base_param_reg_string_name("oob", "xcast_mode",
#if 0
"Select xcast mode (\"linear\" | \"binomial\" | \"direct [default] \")",
"Select xcast mode (\"linear\" | \"binomial\" | \"direct [default] \")",
#endif
"Select xcast mode (\"linear\" | \"direct [default] \")",
false, false, "direct", &mode);
if (0 == strcmp(mode, "binomial")) {
opal_output(0, "oob_xcast_mode: %s option not supported at this time", mode);
return ORTE_ERROR;
orte_oob_xcast_mode = 0;
} else if (0 == strcmp(mode, "linear")) {
orte_oob_xcast_mode = 1;
} else if (0 == strcmp(mode, "direct")) {
orte_oob_xcast_mode = 2;
} else {
opal_output(0, "oob_xcast_mode: unknown option %s", mode);
return ORTE_ERROR;
}
/* All done */
orte_oob_base_already_opened = true;
return ORTE_SUCCESS;
"Select xcast mode (\"linear\" | \"direct [default] \")",
false, false, "direct", &mode);
if (0 == strcmp(mode, "binomial")) {
opal_output(0, "oob_xcast_mode: %s option not supported at this time", mode);
return ORTE_ERROR;
orte_oob_xcast_mode = 0;
} else if (0 == strcmp(mode, "linear")) {
orte_oob_xcast_mode = 1;
} else if (0 == strcmp(mode, "direct")) {
orte_oob_xcast_mode = 2;
} else {
opal_output(0, "oob_xcast_mode: unknown option %s", mode);
return ORTE_ERROR;
}
/* All done */
orte_oob_base_already_opened = true;
return ORTE_SUCCESS;
}

745
orte/mca/oob/base/oob_base_xcast.c
Просмотреть файл

@ -41,56 +41,157 @@
#include "orte/mca/oob/oob.h"
#include "orte/mca/oob/base/base.h"
/* Local variables */
static orte_std_cntr_t xcast_num_active;
static bool xcast_in_progress=false;
/* Local functions */
static int mca_oob_xcast_binomial_tree(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag);
static int mca_oob_xcast_linear(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag);
static int mca_oob_xcast_direct(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag);
/* define a callback function for use by the blocking version
* of xcast so we can "hold" the caller here until all non-blocking
* sends have completed
*/
static void mca_oob_xcast_send_cb(int status,
orte_process_name_t* peer,
orte_buffer_t* buffer,
int tag,
void* cbdata)
{
OPAL_THREAD_LOCK(&orte_oob_xcast_mutex);
xcast_num_active--;
if (xcast_num_active == 0) {
xcast_in_progress = false;
opal_condition_signal(&orte_oob_xcast_cond);
}
OPAL_THREAD_UNLOCK(&orte_oob_xcast_mutex);
return;
}
/**
* A "broadcast-like" function to a job's processes.
* @param jobid The job whose processes are to receive the message
* @param process_first Whether or not to process the message locally before sending it on
* @param buffer The data to broadcast - only significant at root.
* @param cbfunc Callback function on receipt of data - not significant at root.
* @param buffer The data to broadcast
*/
static opal_mutex_t xcastmutex;
static int mca_oob_xcast_binomial_tree(orte_jobid_t job,
orte_gpr_notify_message_t *msg,
orte_gpr_trigger_cb_fn_t cbfunc);
static int mca_oob_xcast_linear(orte_jobid_t job,
orte_gpr_notify_message_t *msg,
orte_gpr_trigger_cb_fn_t cbfunc);
static int mca_oob_xcast_direct(orte_jobid_t job,
orte_gpr_notify_message_t *msg,
orte_gpr_trigger_cb_fn_t cbfunc);
int mca_oob_xcast(orte_jobid_t job,
orte_gpr_notify_message_t *msg,
orte_gpr_trigger_cb_fn_t cbfunc)
/* Non-blocking version */
int mca_oob_xcast_nb(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag)
{
int rc = ORTE_SUCCESS;
struct timeval start, stop;
/* if there is no message to send, then just return ok */
if (NULL == buffer) {
return ORTE_SUCCESS;
}
if (xcast_in_progress) {
/* you can't have two xcasts simultaneously ongoing */
ORTE_ERROR_LOG(ORTE_ERR_RESOURCE_BUSY);
return ORTE_ERR_RESOURCE_BUSY;
}
OPAL_THREAD_LOCK(&orte_oob_xcast_mutex);
xcast_in_progress = true;
xcast_num_active = 0;
OPAL_THREAD_UNLOCK(&orte_oob_xcast_mutex);
if (orte_oob_xcast_timing) {
gettimeofday(&start, NULL);
}
switch(orte_oob_xcast_mode) {
case 0: /* binomial tree */
rc = mca_oob_xcast_binomial_tree(job, msg, cbfunc);
rc = mca_oob_xcast_binomial_tree(job, buffer, tag);
break;
case 1: /* linear */
rc = mca_oob_xcast_linear(job, msg, cbfunc);
rc = mca_oob_xcast_linear(job, buffer, tag);
break;
case 2: /* direct */
rc = mca_oob_xcast_direct(job, msg, cbfunc);
rc = mca_oob_xcast_direct(job, buffer, tag);
break;
}
if (orte_oob_xcast_timing) {
gettimeofday(&stop, NULL);
opal_output(0, "xcast [%ld,%ld,%ld]: mode %s time %ld usec", ORTE_NAME_ARGS(ORTE_PROC_MY_NAME),
opal_output(0, "xcast_nb [%ld,%ld,%ld]: mode %s time %ld usec", ORTE_NAME_ARGS(ORTE_PROC_MY_NAME),
orte_oob_xcast_mode ? "linear" : "binomial",
(long int)((stop.tv_sec - start.tv_sec)*1000000 +
(stop.tv_usec - start.tv_usec)));
}
return rc;
}
/* Blocking version */
int mca_oob_xcast(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag)
{
int rc = ORTE_SUCCESS;
struct timeval start, stop;
/* if there is no message to send, then just return ok */
if (NULL == buffer) {
return ORTE_SUCCESS;
}
if (xcast_in_progress) {
/* you can't have two xcasts simultaneously ongoing */
ORTE_ERROR_LOG(ORTE_ERR_RESOURCE_BUSY);
return ORTE_ERR_RESOURCE_BUSY;
}
OPAL_THREAD_LOCK(&orte_oob_xcast_mutex);
xcast_in_progress = true;
xcast_num_active = 0;
OPAL_THREAD_UNLOCK(&orte_oob_xcast_mutex);
if (orte_oob_xcast_timing) {
gettimeofday(&start, NULL);
}
switch(orte_oob_xcast_mode) {
case 0: /* binomial tree */
rc = mca_oob_xcast_binomial_tree(job, buffer, tag);
break;
case 1: /* linear */
rc = mca_oob_xcast_linear(job, buffer, tag);
break;
case 2: /* direct */
rc = mca_oob_xcast_direct(job, buffer, tag);
break;
}
/* now go to sleep until woken up */
OPAL_THREAD_LOCK(&orte_oob_xcast_mutex);
if (xcast_num_active > 0) {
opal_condition_wait(&orte_oob_xcast_cond, &orte_oob_xcast_mutex);
}
OPAL_THREAD_UNLOCK(&orte_oob_xcast_mutex);
if (orte_oob_xcast_timing) {
gettimeofday(&stop, NULL);
opal_output(0, "xcast_nb [%ld,%ld,%ld]: mode %s time %ld usec", ORTE_NAME_ARGS(ORTE_PROC_MY_NAME),
orte_oob_xcast_mode ? "linear" : "binomial",
(long int)((stop.tv_sec - start.tv_sec)*1000000 +
(stop.tv_usec - start.tv_usec)));
@ -100,376 +201,334 @@ int mca_oob_xcast(orte_jobid_t job,
}
static int mca_oob_xcast_binomial_tree(orte_jobid_t job,
orte_gpr_notify_message_t *msg,
orte_gpr_trigger_cb_fn_t cbfunc)
orte_buffer_t *buffer,
orte_rml_tag_t tag)
{
orte_std_cntr_t i;
int rc, ret;
int peer, size, rank, hibit, mask;
orte_process_name_t target;
orte_buffer_t buffer;
orte_buffer_t *buf;
orte_daemon_cmd_flag_t command=ORTE_DAEMON_MESSAGE_LOCAL_PROCS;
orte_daemon_cmd_flag_t mode=ORTE_DAEMON_ROUTE_BINOMIAL;
orte_vpid_t daemon_start=0, num_daemons;
int bitmap;
/* check to see if there is something to send - this is only true on the HNP end.
* However, we cannot just test to see if we are the HNP since, if we are a singleton,
* we are the HNP *and* we still need to handle both ends of the xcast
/* this is the HNP end, so it starts the procedure. Since the HNP is always the
* vpid=0 at this time, we take advantage of that fact to figure out who we
* should send this to on the first step
*/
if (NULL != msg) {
/* this is the HNP end, so it starts the procedure. Since the HNP is always the
* vpid=0 at this time, we take advantage of that fact to figure out who we
* should send this to on the first step
*/
OBJ_CONSTRUCT(&xcastmutex, opal_mutex_t);
OPAL_THREAD_LOCK(&xcastmutex);
/* need to pack the msg for sending - be sure to include routing info so it
* can properly be sent through the daemons
*/
OBJ_CONSTRUCT(&buffer, orte_buffer_t);
/* tell the daemon this is a message for its local procs */
if (ORTE_SUCCESS != (rc = orte_dss.pack(&buffer, &command, 1, ORTE_DAEMON_CMD))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* tell the daemon the routing algorithm is binomial so it can figure
* out who to forward the message to
*/
if (ORTE_SUCCESS != (rc = orte_dss.pack(&buffer, &mode, 1, ORTE_DAEMON_CMD))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* need to pack the msg for sending - be sure to include routing info so it
* can properly be sent through the daemons
*/
buf = OBJ_NEW(orte_buffer_t);
/* tell the daemon this is a message for its local procs */
if (ORTE_SUCCESS != (rc = orte_dss.pack(buf, &command, 1, ORTE_DAEMON_CMD))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* tell the daemon the routing algorithm is binomial so it can figure
* out who to forward the message to
*/
if (ORTE_SUCCESS != (rc = orte_dss.pack(buf, &mode, 1, ORTE_DAEMON_CMD))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* get the number of daemons currently in the system and tell the daemon so
* it can properly route
*/
if (ORTE_SUCCESS != (rc = orte_ns.get_vpid_range(0, &num_daemons))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
if (ORTE_SUCCESS != (rc = orte_dss.pack(buf, &daemon_start, 1, ORTE_STD_CNTR))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
if (ORTE_SUCCESS != (rc = orte_dss.pack(buf, &num_daemons, 1, ORTE_STD_CNTR))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* tell the daemon the jobid of the procs that are to receive the message */
if (ORTE_SUCCESS != (rc = orte_dss.pack(buf, &job, 1, ORTE_JOBID))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* copy the payload into the new buffer - this is non-destructive, so our
* caller is still responsible for releasing any memory in the buffer they
* gave to us
*/
if (ORTE_SUCCESS != (rc = orte_dss.copy_payload(buf, buffer))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* get the number of daemons currently in the system and tell the daemon so
* it can properly route
*/
if (ORTE_SUCCESS != (rc = orte_ns.get_vpid_range(0, &num_daemons))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
if (ORTE_SUCCESS != (rc = orte_dss.pack(&buffer, &daemon_start, 1, ORTE_STD_CNTR))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
if (ORTE_SUCCESS != (rc = orte_dss.pack(&buffer, &num_daemons, 1, ORTE_STD_CNTR))) {
ORTE_ERROR_LOG(rc);
if (orte_oob_xcast_timing) {
opal_output(0, "xcast [%ld,%ld,%ld]: buffer size %ld",
ORTE_NAME_ARGS(ORTE_PROC_MY_NAME), (long)buf->bytes_used);
}
/* start setting up the target recipients */
target.cellid = ORTE_PROC_MY_NAME->cellid;
target.jobid = 0;
/* if there is only one daemon, then we just send it - don't try to
* compute the binomial algorithm as it won't yield a meaningful
* result for just one
*/
if (num_daemons < 2) {
target.vpid = 1;
if (0 > (ret = mca_oob_send_packed(&target, buf, ORTE_RML_TAG_PLS_ORTED, 0))) {
ORTE_ERROR_LOG(ret);
rc = ret;
goto CLEANUP;
}
} else {
/* compute the bitmap */
bitmap = opal_cube_dim((int)num_daemons);
rank = 0;
size = (int)num_daemons;
/* tell the daemon the jobid of the procs that are to receive the message */
if (ORTE_SUCCESS != (rc = orte_dss.pack(&buffer, &job, 1, ORTE_JOBID))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* pack the message itself */
if (ORTE_SUCCESS != (rc = orte_dss.pack(&buffer, &msg, 1, ORTE_GPR_NOTIFY_MSG))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
if (orte_oob_xcast_timing) {
opal_output(0, "xcast [%ld,%ld,%ld]: buffer size %ld",
ORTE_NAME_ARGS(ORTE_PROC_MY_NAME), (long)buffer.bytes_used);
}
/* start setting up the target recipients */
hibit = opal_hibit(rank, bitmap);
--bitmap;
target.cellid = ORTE_PROC_MY_NAME->cellid;
target.jobid = 0;
/* if there is only one daemon, then we just send it - don't try to
* compute the binomial algorithm as it won't yield a meaningful
* result for just one
*/
if (num_daemons < 2) {
target.vpid = 1;
if (0 > (ret = mca_oob_send_packed(&target, &buffer, ORTE_RML_TAG_PLS_ORTED, 0))) {
ORTE_ERROR_LOG(ret);
OBJ_RELEASE(msg);
rc = ret;
goto CLEANUP;
}
} else {
/* compute the bitmap */
bitmap = opal_cube_dim((int)num_daemons);
rank = 0;
size = (int)num_daemons;
hibit = opal_hibit(rank, bitmap);
--bitmap;
target.cellid = ORTE_PROC_MY_NAME->cellid;
target.jobid = 0;
for (i = hibit + 1, mask = 1 << i; i <= bitmap; ++i, mask <<= 1) {
peer = rank | mask;
if (peer < size) {
target.vpid = (orte_vpid_t)(daemon_start+peer);
if (0 > (ret = mca_oob_send_packed(&target, &buffer, ORTE_RML_TAG_PLS_ORTED, 0))) {
ORTE_ERROR_LOG(ret);
OBJ_RELEASE(msg);
rc = ret;
goto CLEANUP;
}
for (i = hibit + 1, mask = 1 << i; i <= bitmap; ++i, mask <<= 1) {
peer = rank | mask;
if (peer < size) {
target.vpid = (orte_vpid_t)(daemon_start+peer);
if (0 > (ret = mca_oob_send_packed(&target, buf, ORTE_RML_TAG_PLS_ORTED, 0))) {
ORTE_ERROR_LOG(ret);
rc = ret;
goto CLEANUP;
}
}
}
}
CLEANUP:
OBJ_DESTRUCT(&buffer);
OPAL_THREAD_UNLOCK(&xcastmutex);
OBJ_DESTRUCT(&xcastmutex);
return rc;
} else {
/* if we are not the HNP, then we need to just receive the message and process it */
orte_std_cntr_t i;
orte_buffer_t rbuf;
orte_gpr_notify_message_t *mesg;
OBJ_CONSTRUCT(&rbuf, orte_buffer_t);
rc = mca_oob_recv_packed(ORTE_NAME_WILDCARD, &rbuf, ORTE_RML_TAG_XCAST);
if(rc < 0) {
OBJ_DESTRUCT(&rbuf);
return rc;
}
if (cbfunc != NULL) {
mesg = OBJ_NEW(orte_gpr_notify_message_t);
if (NULL == mesg) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
i=1;
if (ORTE_SUCCESS != (rc = orte_dss.unpack(&rbuf, &mesg, &i, ORTE_GPR_NOTIFY_MSG))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(mesg);
return rc;
}
cbfunc(mesg);
OBJ_RELEASE(mesg);
}
OBJ_DESTRUCT(&rbuf);
return ORTE_SUCCESS;
}
OBJ_RELEASE(buf); /* done with this object */
return rc;
}
static int mca_oob_xcast_linear(orte_jobid_t job,
orte_gpr_notify_message_t *msg,
orte_gpr_trigger_cb_fn_t cbfunc)
orte_buffer_t *buffer,
orte_rml_tag_t tag)
{
int rc;
orte_buffer_t buffer;
orte_buffer_t *buf;
orte_daemon_cmd_flag_t command=ORTE_DAEMON_MESSAGE_LOCAL_PROCS;
orte_daemon_cmd_flag_t mode=ORTE_DAEMON_ROUTE_NONE;
orte_vpid_t i, range;
orte_process_name_t dummy;
if (NULL != msg) {
/* if we are the HNP, then we need to send the message out */
OBJ_CONSTRUCT(&xcastmutex, opal_mutex_t);
OPAL_THREAD_LOCK(&xcastmutex);
/* pack the msg for sending - indicate that no further routing is required */
OBJ_CONSTRUCT(&buffer, orte_buffer_t);
/* tell the daemon this is a message for its local procs */
if (ORTE_SUCCESS != (rc = orte_dss.pack(&buffer, &command, 1, ORTE_DAEMON_CMD))) {
ORTE_ERROR_LOG(rc);
/* since we have to pack some additional info into the buffer to be
* sent to the daemons, we create a new buffer into which we will
* put the intermediate payload - i.e., the info that goes to the
* daemon. This buffer will contain all the info needed by the
* daemon, plus the payload intended for the processes themselves
*/
buf = OBJ_NEW(orte_buffer_t);
/* tell the daemon this is a message for its local procs */
if (ORTE_SUCCESS != (rc = orte_dss.pack(buf, &command, 1, ORTE_DAEMON_CMD))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* tell the daemon that no further routing required */
if (ORTE_SUCCESS != (rc = orte_dss.pack(buf, &mode, 1, ORTE_DAEMON_CMD))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* tell the daemon the jobid of the procs that are to receive the message */
if (ORTE_SUCCESS != (rc = orte_dss.pack(buf, &job, 1, ORTE_JOBID))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* tell the daemon the tag where the message is to be sent */
if (ORTE_SUCCESS != (rc = orte_dss.pack(buf, &tag, 1, ORTE_RML_TAG))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* copy the payload into the new buffer - this is non-destructive, so our
* caller is still responsible for releasing any memory in the buffer they
* gave to us
*/
if (ORTE_SUCCESS != (rc = orte_dss.copy_payload(buf, buffer))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
if (orte_oob_xcast_timing) {
opal_output(0, "xcast [%ld,%ld,%ld]: buffer size %ld",
ORTE_NAME_ARGS(ORTE_PROC_MY_NAME), (long)buf->bytes_used);
}
/* get the number of daemons out there */
orte_ns.get_vpid_range(0, &range);
/* we have to account for all of the messages we are about to send
* because the non-blocking send can come back almost immediately - before
* we would get the chance to increment the num_active. This causes us
* to not correctly wakeup and reset the xcast_in_progress flag
*/
OPAL_THREAD_LOCK(&orte_oob_xcast_mutex);
xcast_num_active = range;
if (orte_process_info.daemon ||
orte_process_info.seed ||
orte_process_info.singleton) {
/* we never send to ourselves,
* so we need to adjust the number of sends
* we are expecting to complete
*/
xcast_num_active--;
if (xcast_num_active <= 0) {
/* if we aren't going to send anything at all, we
* need to reset the xcast_in_progress flag so
* we don't block the entire system and return
*/
xcast_in_progress = false;
OPAL_THREAD_UNLOCK(&orte_oob_xcast_mutex);
rc = ORTE_SUCCESS;
goto CLEANUP;
}
/* tell the daemon that no further routing required */
if (ORTE_SUCCESS != (rc = orte_dss.pack(&buffer, &mode, 1, ORTE_DAEMON_CMD))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* tell the daemon the jobid of the procs that are to receive the message */
if (ORTE_SUCCESS != (rc = orte_dss.pack(&buffer, &job, 1, ORTE_JOBID))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* pack the message itself */
if (ORTE_SUCCESS != (rc = orte_dss.pack(&buffer, &msg, 1, ORTE_GPR_NOTIFY_MSG))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
if (orte_oob_xcast_timing) {
opal_output(0, "xcast [%ld,%ld,%ld]: buffer size %ld",
ORTE_NAME_ARGS(ORTE_PROC_MY_NAME), (long)buffer.bytes_used);
}
/* get the number of daemons out there */
orte_ns.get_vpid_range(0, &range);
/* send the message to each daemon as fast as we can */
dummy.cellid = ORTE_PROC_MY_NAME->cellid;
dummy.jobid = 0;
for (i=0; i < range; i++) {
if (ORTE_PROC_MY_NAME->vpid != i) { /* don't send to myself */
dummy.vpid = i;
if (0 > (rc = orte_rml.send_buffer(&dummy, &buffer, ORTE_RML_TAG_PLS_ORTED, 0))) {
if (ORTE_ERR_ADDRESSEE_UNKNOWN != rc) {
ORTE_ERROR_LOG(ORTE_ERR_COMM_FAILURE);
rc = ORTE_ERR_COMM_FAILURE;
goto CLEANUP;
}
}
OPAL_THREAD_UNLOCK(&orte_oob_xcast_mutex);
/* send the message to each daemon as fast as we can */
dummy.cellid = ORTE_PROC_MY_NAME->cellid;
dummy.jobid = 0;
for (i=0; i < range; i++) {
if (ORTE_PROC_MY_NAME->vpid != i) { /* don't send to myself */
dummy.vpid = i;
if (0 > (rc = mca_oob_send_packed_nb(&dummy, buf, ORTE_RML_TAG_PLS_ORTED,
0, mca_oob_xcast_send_cb, NULL))) {
if (ORTE_ERR_ADDRESSEE_UNKNOWN != rc) {
ORTE_ERROR_LOG(ORTE_ERR_COMM_FAILURE);
rc = ORTE_ERR_COMM_FAILURE;
OPAL_THREAD_LOCK(&orte_oob_xcast_mutex);
xcast_num_active -= (range-i);
OPAL_THREAD_UNLOCK(&orte_oob_xcast_mutex);
goto CLEANUP;
}
/* decrement the number we are waiting to see */
OPAL_THREAD_LOCK(&orte_oob_xcast_mutex);
xcast_num_active--;
OPAL_THREAD_UNLOCK(&orte_oob_xcast_mutex);
}
}
rc = ORTE_SUCCESS;
/* cleanup */
}
rc = ORTE_SUCCESS;
/* cleanup */
CLEANUP:
OBJ_DESTRUCT(&buffer);
OPAL_THREAD_UNLOCK(&xcastmutex);
OBJ_DESTRUCT(&xcastmutex);
return rc;
} else {
/* if we are not the HNP, then we need to just receive the message and process it */
orte_std_cntr_t i;
orte_buffer_t rbuf;
orte_gpr_notify_message_t *mesg;
OBJ_CONSTRUCT(&rbuf, orte_buffer_t);
rc = mca_oob_recv_packed(ORTE_NAME_WILDCARD, &rbuf, ORTE_RML_TAG_XCAST);
if(rc < 0) {
OBJ_DESTRUCT(&rbuf);
return rc;
}
if (cbfunc != NULL) {
mesg = OBJ_NEW(orte_gpr_notify_message_t);
if (NULL == mesg) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
i=1;
if (ORTE_SUCCESS != (rc = orte_dss.unpack(&rbuf, &mesg, &i, ORTE_GPR_NOTIFY_MSG))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(mesg);
return rc;
}
cbfunc(mesg);
OBJ_RELEASE(mesg);
}
OBJ_DESTRUCT(&rbuf);
return ORTE_SUCCESS;
}
OBJ_RELEASE(buf); /* done with this object */
return rc;
}
static int mca_oob_xcast_direct(orte_jobid_t job,
orte_gpr_notify_message_t *msg,
orte_gpr_trigger_cb_fn_t cbfunc)
orte_buffer_t *buffer,
orte_rml_tag_t tag)
{
orte_std_cntr_t i;
int rc;
int tag = ORTE_RML_TAG_XCAST;
int status;
orte_process_name_t *peers=NULL;
orte_std_cntr_t n=0;
orte_proc_state_t state;
opal_list_t attrs;
opal_list_item_t *item;
orte_buffer_t buffer;
/* check to see if there is something to send - this is only true on the HNP end.
* However, we cannot just test to see if we are the HNP since, if we are a singleton,
* we are the HNP *and* we still need to handle both ends of the xcast
*/
if (NULL != msg) {
OBJ_CONSTRUCT(&xcastmutex, opal_mutex_t);
OPAL_THREAD_LOCK(&xcastmutex);
/* this is the HNP end, so it does all the sends in this algorithm. First, we need
* to get the job peers so we know who to send the message to
*/
OBJ_CONSTRUCT(&attrs, opal_list_t);
orte_rmgr.add_attribute(&attrs, ORTE_NS_USE_JOBID, ORTE_JOBID, &job, ORTE_RMGR_ATTR_OVERRIDE);
if (ORTE_SUCCESS != (rc = orte_ns.get_peers(&peers, &n, &attrs))) {
ORTE_ERROR_LOG(rc);
OPAL_THREAD_UNLOCK(&xcastmutex);
OBJ_DESTRUCT(&xcastmutex);
return rc;
}
item = opal_list_remove_first(&attrs);
OBJ_RELEASE(item);
/* need to get the job peers so we know who to send the message to */
OBJ_CONSTRUCT(&attrs, opal_list_t);
orte_rmgr.add_attribute(&attrs, ORTE_NS_USE_JOBID, ORTE_JOBID, &job, ORTE_RMGR_ATTR_OVERRIDE);
if (ORTE_SUCCESS != (rc = orte_ns.get_peers(&peers, &n, &attrs))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&attrs);
/* need to pack the msg for sending - no routing info here as this message
* goes DIRECTLY to the processes
*/
OBJ_CONSTRUCT(&buffer, orte_buffer_t);
if (ORTE_SUCCESS != (rc = orte_dss.pack(&buffer, &msg, 1, ORTE_GPR_NOTIFY_MSG))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&buffer);
free(peers);
return rc;
}
if (orte_oob_xcast_timing) {
opal_output(0, "xcast [%ld,%ld,%ld]: buffer size %ld",
ORTE_NAME_ARGS(ORTE_PROC_MY_NAME), (long)buffer.bytes_used);
}
for(i=0; i<n; i++) {
/* check status of peer to ensure they are alive */
if (ORTE_SUCCESS != (rc = orte_smr.get_proc_state(&state, &status, peers+i))) {
ORTE_ERROR_LOG(rc);
free(peers);
OPAL_THREAD_UNLOCK(&xcastmutex);
OBJ_DESTRUCT(&xcastmutex);
return rc;
}
if (state != ORTE_PROC_STATE_TERMINATED && state != ORTE_PROC_STATE_ABORTED) {
rc = mca_oob_send_packed(peers+i, &buffer, tag, 0);
if (rc < 0) {
ORTE_ERROR_LOG(rc);
free(peers);
OPAL_THREAD_UNLOCK(&xcastmutex);
OBJ_DESTRUCT(&xcastmutex);
return rc;
}
}
}
free(peers);
OBJ_DESTRUCT(&buffer);
OPAL_THREAD_UNLOCK(&xcastmutex);
OBJ_DESTRUCT(&xcastmutex);
return ORTE_SUCCESS;
/* if we are not the HNP, then we need to just receive the message and process it */
} else {
orte_buffer_t rbuf;
orte_gpr_notify_message_t *mesg;
OBJ_CONSTRUCT(&rbuf, orte_buffer_t);
rc = mca_oob_recv_packed(ORTE_NAME_WILDCARD, &rbuf, tag);
if(rc < 0) {
OBJ_DESTRUCT(&rbuf);
return rc;
}
if (cbfunc != NULL) {
mesg = OBJ_NEW(orte_gpr_notify_message_t);
if (NULL == mesg) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
i=1;
if (ORTE_SUCCESS != (rc = orte_dss.unpack(&rbuf, &mesg, &i, ORTE_GPR_NOTIFY_MSG))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(mesg);
return rc;
}
cbfunc(mesg);
OBJ_RELEASE(mesg);
}
OBJ_DESTRUCT(&rbuf);
return rc;
}
return ORTE_SUCCESS;
item = opal_list_remove_first(&attrs);
OBJ_RELEASE(item);
OBJ_DESTRUCT(&attrs);
/* no need to re-pack the msg for sending - no routing info here as this message
* goes DIRECTLY to the processes
*/
if (orte_oob_xcast_timing) {
opal_output(0, "xcast [%ld,%ld,%ld]: buffer size %ld",
ORTE_NAME_ARGS(ORTE_PROC_MY_NAME), (long)buffer->bytes_used);
}
/* we have to account for all of the messages we are about to send
* because the non-blocking send can come back almost immediately - before
* we would get the chance to increment the num_active. This causes us
* to not correctly wakeup and reset the xcast_in_progress flag
*/
OPAL_THREAD_LOCK(&orte_oob_xcast_mutex);
xcast_num_active = n;
OPAL_THREAD_UNLOCK(&orte_oob_xcast_mutex);
for(i=0; i<n; i++) {
if (0 > (rc = mca_oob_send_packed_nb(peers+i, buffer, tag, 0, mca_oob_xcast_send_cb, NULL))) {
if (ORTE_ERR_ADDRESSEE_UNKNOWN != rc) {
ORTE_ERROR_LOG(ORTE_ERR_COMM_FAILURE);
rc = ORTE_ERR_COMM_FAILURE;
OPAL_THREAD_LOCK(&orte_oob_xcast_mutex);
xcast_num_active -= (n-i);
OPAL_THREAD_UNLOCK(&orte_oob_xcast_mutex);
goto CLEANUP;
}
/* decrement the number we are waiting to see */
OPAL_THREAD_LOCK(&orte_oob_xcast_mutex);
xcast_num_active--;
OPAL_THREAD_UNLOCK(&orte_oob_xcast_mutex);
}
}
rc = ORTE_SUCCESS;
CLEANUP:
free(peers);
return rc;
}
int mca_oob_xcast_gate(orte_gpr_trigger_cb_fn_t cbfunc)
{
int rc;
orte_std_cntr_t i;
orte_buffer_t rbuf;
orte_gpr_notify_message_t *mesg;
OBJ_CONSTRUCT(&rbuf, orte_buffer_t);
rc = mca_oob_recv_packed(ORTE_NAME_WILDCARD, &rbuf, ORTE_RML_TAG_XCAST_BARRIER);
if(rc < 0) {
OBJ_DESTRUCT(&rbuf);
return rc;
}
if (cbfunc != NULL) {
mesg = OBJ_NEW(orte_gpr_notify_message_t);
if (NULL == mesg) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
i=1;
if (ORTE_SUCCESS != (rc = orte_dss.unpack(&rbuf, &mesg, &i, ORTE_GPR_NOTIFY_MSG))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(mesg);
return rc;
}
cbfunc(mesg);
OBJ_RELEASE(mesg);
}
OBJ_DESTRUCT(&rbuf);
return ORTE_SUCCESS;
}

73
orte/mca/oob/oob.h
Просмотреть файл

@ -81,6 +81,11 @@ typedef char* (*mca_oob_base_module_get_addr_fn_t)(void);
typedef int (*mca_oob_base_module_set_addr_fn_t)(const orte_process_name_t*, const char* uri);
/**
* Implementation of mca_oob_base_module_update_contact_info()
*/
typedef void (*mca_oob_module_update_contact_info_fn_t)(orte_gpr_notify_data_t* data,
void* cbdata);
/**
* Implementation of mca_oob_ping().
@ -200,27 +205,67 @@ typedef int (*mca_oob_base_module_fini_fn_t)(void);
* xcast function for sending common messages to all processes
*/
typedef int (*mca_oob_base_module_xcast_fn_t)(orte_jobid_t job,
orte_gpr_notify_message_t *msg,
orte_gpr_trigger_cb_fn_t cbfunc);
orte_buffer_t *buffer,
orte_rml_tag_t tag);
typedef int (*mca_oob_base_module_xcast_nb_fn_t)(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag);
typedef int (*mca_oob_base_module_xcast_gate_fn_t)(orte_gpr_trigger_cb_fn_t cbfunc);
/* ft event */
typedef int (*mca_oob_base_module_ft_event_fn_t)( int state );
/*
* Register my contact info with the General Purpose Registry
* This function causes the component to "put" its contact info
* on the registry.
*/
typedef int (*mca_oob_module_register_contact_info_fn_t)(void);
/*
* Register a subscription to receive contact info on other processes
* This function will typically be called from within a GPR compound command
* to register a subscription against a stage gate trigger. When fired, this
* will return the OOB contact info for all processes in the specified job
*/
typedef int (*mca_oob_module_register_subscription_fn_t)(orte_jobid_t job, char *trigger);
/*
* Get contact info for a process or job
* Returns contact info for the specified process. If the vpid in the process name
* is WILDCARD, then it returns the contact info for all processes in the specified
* job. If the jobid is WILDCARD, then it returns the contact info for processes
* of the specified vpid across all jobs. Obviously, combining the two WILDCARD
* values will return contact info for everyone!
*/
typedef int (*mca_oob_module_get_contact_info_fn_t)(orte_process_name_t *name, orte_gpr_notify_data_t **data);
/**
* OOB Module
*/
struct mca_oob_1_0_0_t {
mca_oob_base_module_get_addr_fn_t oob_get_addr;
mca_oob_base_module_set_addr_fn_t oob_set_addr;
mca_oob_base_module_ping_fn_t oob_ping;
mca_oob_base_module_send_fn_t oob_send;
mca_oob_base_module_recv_fn_t oob_recv;
mca_oob_base_module_send_nb_fn_t oob_send_nb;
mca_oob_base_module_recv_nb_fn_t oob_recv_nb;
mca_oob_base_module_recv_cancel_fn_t oob_recv_cancel;
mca_oob_base_module_init_fn_t oob_init;
mca_oob_base_module_fini_fn_t oob_fini;
mca_oob_base_module_xcast_fn_t oob_xcast;
mca_oob_base_module_ft_event_fn_t oob_ft_event;
mca_oob_base_module_get_addr_fn_t oob_get_addr;
mca_oob_base_module_set_addr_fn_t oob_set_addr;
mca_oob_base_module_ping_fn_t oob_ping;
mca_oob_base_module_send_fn_t oob_send;
mca_oob_base_module_recv_fn_t oob_recv;
mca_oob_base_module_send_nb_fn_t oob_send_nb;
mca_oob_base_module_recv_nb_fn_t oob_recv_nb;
mca_oob_base_module_recv_cancel_fn_t oob_recv_cancel;
mca_oob_base_module_init_fn_t oob_init;
mca_oob_base_module_fini_fn_t oob_fini;
mca_oob_base_module_xcast_fn_t oob_xcast;
mca_oob_base_module_xcast_nb_fn_t oob_xcast_nb;
mca_oob_base_module_xcast_gate_fn_t oob_xcast_gate;
mca_oob_base_module_ft_event_fn_t oob_ft_event;
mca_oob_module_register_contact_info_fn_t oob_register_contact_info;
mca_oob_module_register_subscription_fn_t oob_register_subscription;
mca_oob_module_get_contact_info_fn_t oob_get_contact_info;
mca_oob_module_update_contact_info_fn_t oob_update_contact_info;
};
/**

239
orte/mca/oob/tcp/oob_tcp.c
Просмотреть файл

@ -152,7 +152,13 @@ static mca_oob_t mca_oob_tcp = {
mca_oob_tcp_init,
mca_oob_tcp_fini,
mca_oob_xcast,
mca_oob_tcp_ft_event
mca_oob_xcast_nb,
mca_oob_xcast_gate,
mca_oob_tcp_ft_event,
mca_oob_tcp_register_contact_info,
mca_oob_tcp_register_subscription,
mca_oob_tcp_get_contact_info,
mca_oob_tcp_registry_callback
};
/*
@ -1028,7 +1034,8 @@ void mca_oob_tcp_registry_callback(
&mca_oob_tcp_component.tcp_peer_names, &addr->addr_name);
if(NULL != existing) {
/* TSW - need to update existing entry */
opal_output( 0, "WHY ARE WE RECEIVING THE SAME INFORMATION SEVERAL TIMES ?!?!?!?" );
opal_output( 0, "[%ld,%ld,%ld] Received OOB update for [%ld,%ld,%ld]",
ORTE_NAME_ARGS(ORTE_PROC_MY_NAME), ORTE_NAME_ARGS(&addr->addr_name) );
orte_hash_table_set_proc(&mca_oob_tcp_component.tcp_peer_names, &addr->addr_name, addr);
OBJ_RELEASE(addr);
continue;
@ -1053,12 +1060,6 @@ void mca_oob_tcp_registry_callback(
int mca_oob_tcp_resolve(mca_oob_tcp_peer_t* peer)
{
mca_oob_tcp_addr_t* addr;
mca_oob_tcp_subscription_t* subscription;
char *segment, *sub_name, *trig_name;
char *key = ORTE_OOB_TCP_KEY;
orte_gpr_subscription_id_t sub_id;
opal_list_item_t* item;
int rc;
/* if the address is already cached - simply return it */
OPAL_THREAD_LOCK(&mca_oob_tcp_component.tcp_lock);
@ -1070,83 +1071,8 @@ int mca_oob_tcp_resolve(mca_oob_tcp_peer_t* peer)
return ORTE_SUCCESS;
}
/* check to see if we have subscribed to this registry segment */
for( item = opal_list_get_first(&mca_oob_tcp_component.tcp_subscriptions);
item != opal_list_get_end(&mca_oob_tcp_component.tcp_subscriptions);
item = opal_list_get_next(item)) {
subscription = (mca_oob_tcp_subscription_t*)item;
if(subscription->jobid == peer->peer_name.jobid) {
OPAL_THREAD_UNLOCK(&mca_oob_tcp_component.tcp_lock);
return ORTE_SUCCESS;
}
}
if (ORTE_SUCCESS != (rc = orte_schema.get_std_subscription_name(&sub_name,
ORTE_OOB_SUBSCRIPTION, peer->peer_name.jobid))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* attach to the stage-1 standard trigger */
if (ORTE_SUCCESS != (rc = orte_schema.get_std_trigger_name(&trig_name,
ORTE_STG1_TRIGGER, peer->peer_name.jobid))) {
ORTE_ERROR_LOG(rc);
free(sub_name);
return rc;
}
/* define the segment */
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&segment,
peer->peer_name.jobid))) {
ORTE_ERROR_LOG(rc);
free(sub_name);
free(trig_name);
return rc;
}
/* If we do not release the mutex before the subscrition we will deadlock
* as the suscription involve oob_tcp_send who involve again a lookup
* call. Before unlocking the mutex (just to be protected by it) we can
* create the subscription and add it to the list.
*/
subscription = OBJ_NEW(mca_oob_tcp_subscription_t);
subscription->jobid = peer->peer_name.jobid;
opal_list_append(&mca_oob_tcp_component.tcp_subscriptions, &subscription->item);
OPAL_THREAD_UNLOCK(&mca_oob_tcp_component.tcp_lock);
if (ORTE_SUCCESS != (rc = orte_gpr.subscribe_1(&sub_id, NULL, NULL,
ORTE_GPR_NOTIFY_ADD_ENTRY |
ORTE_GPR_NOTIFY_VALUE_CHG |
ORTE_GPR_NOTIFY_PRE_EXISTING,
ORTE_GPR_KEYS_OR | ORTE_GPR_TOKENS_OR | ORTE_GPR_STRIPPED,
segment,
NULL, /* look at all containers on this segment */
key,
mca_oob_tcp_registry_callback, NULL))) {
ORTE_ERROR_LOG(rc);
free(sub_name);
free(trig_name);
free(segment);
/* Subscription registration failed, we should activate the cleaning logic:
* remove the subscription from the list (protected by the mutex).
*/
OPAL_THREAD_LOCK(&mca_oob_tcp_component.tcp_lock);
opal_list_remove_item( &mca_oob_tcp_component.tcp_subscriptions,
&subscription->item );
OPAL_THREAD_UNLOCK(&mca_oob_tcp_component.tcp_lock);
return rc;
}
/* the id of each subscription is recorded
* here so we can (if desired) cancel that subscription later
*/
subscription->subid = sub_id;
/* done with these, so release any memory */
free(trig_name);
free(sub_name);
free(segment);
return rc;
/* if we don't know it, then report unknown - don't try to go get it */
return ORTE_ERR_ADDRESSEE_UNKNOWN;
}
@ -1156,17 +1082,7 @@ int mca_oob_tcp_resolve(mca_oob_tcp_peer_t* peer)
int mca_oob_tcp_init(void)
{
orte_jobid_t jobid;
orte_buffer_t *buffer;
orte_gpr_subscription_id_t sub_id;
char *sub_name, *segment, *trig_name, **tokens;
char *keys[] = { ORTE_OOB_TCP_KEY, ORTE_PROC_RML_IP_ADDRESS_KEY};
orte_data_value_t *values[2];
orte_byte_object_t bo;
mca_oob_tcp_subscription_t *subscription;
int rc;
opal_list_item_t* item;
char *tmp, *tmp2, *tmp3;
orte_std_cntr_t i, num_tokens;
int randval = orte_process_info.num_procs;
if (0 == randval) randval = 10;
@ -1234,19 +1150,17 @@ int mca_oob_tcp_init(void)
}
}
/* iterate through the open connections and send an ident message to all peers -
* note that we initially come up w/out knowing our process name - and are assigned
* a temporary name by our peer. once we have determined our real name - we send it
* to the peer.
*/
OPAL_THREAD_LOCK(&mca_oob_tcp_component.tcp_lock);
for(item = opal_list_get_first(&mca_oob_tcp_component.tcp_peer_list);
item != opal_list_get_end(&mca_oob_tcp_component.tcp_peer_list);
item = opal_list_get_next(item)) {
mca_oob_tcp_peer_t* peer = (mca_oob_tcp_peer_t*)item;
mca_oob_tcp_peer_send_ident(peer);
}
return ORTE_SUCCESS;
}
int mca_oob_tcp_register_subscription(orte_jobid_t jobid, char *trigger)
{
char *sub_name, *segment, *trig_name;
mca_oob_tcp_subscription_t *subscription;
orte_gpr_subscription_id_t sub_id;
int rc;
/* register subscribe callback to receive notification when all processes have registered */
subscription = OBJ_NEW(mca_oob_tcp_subscription_t);
subscription->jobid = jobid;
@ -1264,9 +1178,9 @@ int mca_oob_tcp_init(void)
return rc;
}
/* attach to the stage-1 standard trigger */
/* attach to the specified trigger */
if (ORTE_SUCCESS != (rc = orte_schema.get_std_trigger_name(&trig_name,
ORTE_STG1_TRIGGER, jobid))) {
trigger, jobid))) {
ORTE_ERROR_LOG(rc);
free(sub_name);
return rc;
@ -1281,13 +1195,11 @@ int mca_oob_tcp_init(void)
}
if (ORTE_SUCCESS != (rc = orte_gpr.subscribe_1(&sub_id, trig_name, sub_name,
ORTE_GPR_NOTIFY_ADD_ENTRY |
ORTE_GPR_NOTIFY_VALUE_CHG |
ORTE_GPR_NOTIFY_STARTS_AFTER_TRIG,
ORTE_GPR_NOTIFY_DELETE_AFTER_TRIG,
ORTE_GPR_KEYS_OR | ORTE_GPR_TOKENS_OR | ORTE_GPR_STRIPPED,
segment,
NULL, /* look at all containers on this segment */
keys[0],
ORTE_OOB_TCP_KEY,
mca_oob_tcp_registry_callback, NULL))) {
ORTE_ERROR_LOG(rc);
free(sub_name);
@ -1305,8 +1217,21 @@ int mca_oob_tcp_init(void)
free(trig_name);
free(sub_name);
return ORTE_SUCCESS;
}
/* now setup to put our contact info on registry */
int mca_oob_tcp_register_contact_info(void)
{
orte_std_cntr_t i, num_tokens;
orte_buffer_t *buffer;
orte_data_value_t *values[2];
orte_byte_object_t bo;
char *tmp, *tmp2, *tmp3;
char *segment, **tokens;
char *keys[] = { ORTE_OOB_TCP_KEY, ORTE_PROC_RML_IP_ADDRESS_KEY};
int rc;
/* setup to put our contact info on registry */
buffer = OBJ_NEW(orte_buffer_t);
if(buffer == NULL) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
@ -1362,6 +1287,14 @@ int mca_oob_tcp_init(void)
values[1]->data = strdup(tmp2);
free(tmp);
/* define the segment */
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&segment, ORTE_PROC_MY_NAME->jobid))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(values[0]);
OBJ_RELEASE(values[1]);
return rc;
}
/* get the process tokens */
if (ORTE_SUCCESS != (rc = orte_schema.get_proc_tokens(&tokens, &num_tokens,
orte_process_info.my_name))) {
@ -1390,6 +1323,84 @@ int mca_oob_tcp_init(void)
return rc;
}
static int get_contact_info(orte_jobid_t job, char **tokens, orte_gpr_notify_data_t **data)
{
char *segment;
char *keys[] = { ORTE_OOB_TCP_KEY, ORTE_PROC_RML_IP_ADDRESS_KEY};
orte_gpr_value_t **values;
orte_std_cntr_t cnt, i, idx;
int rc;
/* define the segment */
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&segment, job))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* get the data */
if (ORTE_SUCCESS != (rc = orte_gpr.get(ORTE_GPR_TOKENS_AND | ORTE_GPR_KEYS_OR,
segment, tokens, keys, &cnt, &values))) {
ORTE_ERROR_LOG(rc);
free(segment);
return rc;
}
/* see if we got data back */
if (0 < cnt) {
/* build the data into the notify_data object. If the data
* pointer is NULL, then we are the first values, so initialize
* it. Otherwise, just add the data to it
*/
if (NULL == *data) {
*data = OBJ_NEW(orte_gpr_notify_data_t);
}
for (i=0; i < cnt; i++) {
if (ORTE_SUCCESS != (rc = orte_pointer_array_add(&idx, (*data)->values, (void*)values[i]))) {
ORTE_ERROR_LOG(rc);
return rc;
}
++(*data)->cnt;
}
}
return ORTE_SUCCESS;
}
int mca_oob_tcp_get_contact_info(orte_process_name_t *name, orte_gpr_notify_data_t **data)
{
char **tokens=NULL;
orte_std_cntr_t num_tokens;
int rc;
/* if the vpid is WILDCARD, then we want the info from all procs in the specified job. This
* is the default condition, so do nothing for this case. If the vpid is not WILDCARD,
* then go get the process tokens
*/
if (ORTE_VPID_WILDCARD != name->vpid) {
if (ORTE_SUCCESS != (rc = orte_schema.get_proc_tokens(&tokens, &num_tokens, name))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
/* If the jobid is not WILDCARD, then we only want the info from the specified job -
* this is the most common case, so treat it first
*/
if (ORTE_JOBID_WILDCARD != name->jobid) {
if (ORTE_SUCCESS != (rc = get_contact_info(name->jobid, tokens, data))) {
ORTE_ERROR_LOG(rc);
}
return rc;
}
/* if the jobid is WILDCARD, then we want the info from all jobs. */
return ORTE_SUCCESS;
}
/*
* Module cleanup.
*/

25
orte/mca/oob/tcp/oob_tcp.h
Просмотреть файл

@ -72,6 +72,31 @@ int mca_oob_tcp_init(void);
*/
int mca_oob_tcp_fini(void);
/*
* Register my contact info with the General Purpose Registry
* This function causes the component to "put" its contact info
* on the registry.
*/
int mca_oob_tcp_register_contact_info(void);
/*
* Register a subscription to receive contact info on other processes
* This function will typically be called from within a GPR compound command
* to register a subscription against a stage gate trigger. When fired, this
* will return the OOB contact info for all processes in the specified job
*/
int mca_oob_tcp_register_subscription(orte_jobid_t job, char *trigger);
/*
* Get contact info for a process or job
* Returns contact info for the specified process. If the vpid in the process name
* is WILDCARD, then it returns the contact info for all processes in the specified
* job. If the jobid is WILDCARD, then it returns the contact info for processes
* of the specified vpid across all jobs. Obviously, combining the two WILDCARD
* values will return contact info for everyone!
*/
ORTE_DECLSPEC int mca_oob_tcp_get_contact_info(orte_process_name_t *name, orte_gpr_notify_data_t **data);
/**
* Compare two process names for equality.
*

8
orte/mca/oob/tcp/oob_tcp_send.c
Просмотреть файл

@ -156,7 +156,9 @@ int mca_oob_tcp_send(
MCA_OOB_TCP_HDR_HTON(&msg->msg_hdr);
rc = mca_oob_tcp_peer_send(peer, msg);
if(rc != ORTE_SUCCESS) {
MCA_OOB_TCP_MSG_RETURN(msg);
if (rc != ORTE_ERR_ADDRESSEE_UNKNOWN) {
MCA_OOB_TCP_MSG_RETURN(msg);
}
return rc;
}
@ -255,7 +257,9 @@ int mca_oob_tcp_send_nb(
MCA_OOB_TCP_HDR_HTON(&msg->msg_hdr);
rc = mca_oob_tcp_peer_send(peer, msg);
if(rc != ORTE_SUCCESS) {
MCA_OOB_TCP_MSG_RETURN(msg);
if (rc != ORTE_ERR_ADDRESSEE_UNKNOWN) {
MCA_OOB_TCP_MSG_RETURN(msg);
}
return rc;
}

1
orte/mca/rmgr/base/Makefile.am
Просмотреть файл

@ -34,6 +34,7 @@ libmca_rmgr_la_SOURCES += \
base/rmgr_base_stage_gate.c \
base/rmgr_base_stubs.c \
base/rmgr_base_vpid_support_fns.c \
base/rmgr_base_xconnect.c \
base/data_type_support/rmgr_data_type_compare_fns.c \
base/data_type_support/rmgr_data_type_copy_fns.c \
base/data_type_support/rmgr_data_type_print_fns.c \

23
orte/mca/rmgr/base/rmgr_base_receive.c
Просмотреть файл

@ -94,7 +94,7 @@ void orte_rmgr_base_recv(int status, orte_process_name_t* sender,
orte_buffer_t answer;
orte_rmgr_cmd_t command;
orte_std_cntr_t i, count, num_context;
orte_jobid_t job;
orte_jobid_t job, parent;
orte_app_context_t **context;
opal_list_item_t *item;
opal_list_t attrs;
@ -241,6 +241,27 @@ CLEANUP_SPAWN:
}
break;
case ORTE_RMGR_XCONNECT_CMD:
/* get the child jobid */
count = 1;
if(ORTE_SUCCESS != (rc = orte_dss.unpack(buffer, &job, &count, ORTE_JOBID))) {
ORTE_ERROR_LOG(rc);
goto SEND_ANSWER;
}
/* get the parent jobid */
count = 1;
if(ORTE_SUCCESS != (rc = orte_dss.unpack(buffer, &parent, &count, ORTE_JOBID))) {
ORTE_ERROR_LOG(rc);
goto SEND_ANSWER;
}
/* execute the xchg */
if (ORTE_SUCCESS != (rc = orte_rmgr_base_xconnect(job, parent))) {
ORTE_ERROR_LOG(rc);
goto SEND_ANSWER;
}
break;
default:
ORTE_ERROR_LOG(ORTE_ERR_VALUE_OUT_OF_BOUNDS);

30
orte/mca/rmgr/base/rmgr_base_stage_gate.c
Просмотреть файл

@ -31,16 +31,17 @@
#include "opal/util/output.h"
#include "opal/util/trace.h"
#include "orte/class/orte_pointer_array.h"
#include "orte/dss/dss.h"
#include "orte/mca/gpr/gpr.h"
#include "orte/mca/ns/ns.h"
#include "orte/mca/errmgr/errmgr.h"
#include "orte/mca/rml/rml.h"
#include "orte/mca/smr/smr.h"
#include "orte/runtime/runtime.h"
#include "orte/mca/rmgr/base/rmgr_private.h"
int orte_rmgr_base_proc_stage_gate_init(orte_jobid_t job)
{
int rc;
@ -59,15 +60,18 @@ int orte_rmgr_base_proc_stage_gate_mgr(orte_gpr_notify_message_t *msg)
{
int rc;
orte_jobid_t job;
orte_buffer_t *buffer;
OPAL_TRACE(1);
/* check to see if this came from a trigger that we ignore because
* that stage gate does NOT set an xcast barrier - processes simply
* record their state and continue processing. The only triggers that
* involve a xcast barrier are the STGx and FINALIZED ones - ignore the rest.
*/
if (!orte_schema.check_std_trigger_name(msg->target, ORTE_STG1_TRIGGER) &&
* involve a xcast barrier are the ORTE_STARTUP_TRIGGER,
* STGx, and FINALIZED ones - ignore the rest.
*/
if (!orte_schema.check_std_trigger_name(msg->target, ORTE_STARTUP_TRIGGER) &&
!orte_schema.check_std_trigger_name(msg->target, ORTE_STG1_TRIGGER) &&
!orte_schema.check_std_trigger_name(msg->target, ORTE_STG2_TRIGGER) &&
!orte_schema.check_std_trigger_name(msg->target, ORTE_STG3_TRIGGER) &&
!orte_schema.check_std_trigger_name(msg->target, ORTE_NUM_FINALIZED_TRIGGER)) {
@ -85,7 +89,12 @@ int orte_rmgr_base_proc_stage_gate_mgr(orte_gpr_notify_message_t *msg)
OPAL_TRACE_ARG1(1, job);
/* set the job state to the appropriate level */
if (orte_schema.check_std_trigger_name(msg->target, ORTE_ALL_LAUNCHED_TRIGGER)) {
if (orte_schema.check_std_trigger_name(msg->target, ORTE_STARTUP_TRIGGER)) {
if (ORTE_SUCCESS != (rc = orte_smr.set_job_state(job, ORTE_JOB_ORTE_STARTUP_COMPLETE))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
} else if (orte_schema.check_std_trigger_name(msg->target, ORTE_ALL_LAUNCHED_TRIGGER)) {
if (ORTE_SUCCESS != (rc = orte_smr.set_job_state(job, ORTE_JOB_STATE_LAUNCHED))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
@ -118,10 +127,19 @@ int orte_rmgr_base_proc_stage_gate_mgr(orte_gpr_notify_message_t *msg)
msg->msg_type = ORTE_GPR_SUBSCRIPTION_MSG;
msg->id = ORTE_GPR_TRIGGER_ID_MAX;
/* setup the buffer */
buffer = OBJ_NEW(orte_buffer_t);
if (ORTE_SUCCESS != (rc = orte_dss.pack(buffer, &msg, 1, ORTE_GPR_NOTIFY_MSG))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(buffer);
return rc;
}
/* send the message */
if (ORTE_SUCCESS != (rc = orte_rml.xcast(job, msg, NULL))) {
if (ORTE_SUCCESS != (rc = orte_rml.xcast(job, buffer, ORTE_RML_TAG_XCAST_BARRIER))) {
ORTE_ERROR_LOG(rc);
}
OBJ_RELEASE(buffer);
CLEANUP:

122
orte/mca/rmgr/base/rmgr_base_xconnect.c Обычный файл
Просмотреть файл

@ -0,0 +1,122 @@
/*
* Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2005 The University of Tennessee and The University
* of Tennessee Research Foundation. All rights
* reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
/** @file:
*/
/*
* includes
*/
#include "orte_config.h"
#include <string.h>
#include "orte/orte_constants.h"
#include "orte/orte_types.h"
#include "opal/util/output.h"
#include "opal/util/trace.h"
#include "orte/dss/dss.h"
#include "orte/mca/gpr/gpr_types.h"
#include "orte/mca/errmgr/errmgr.h"
#include "orte/mca/rml/rml.h"
#include "orte/mca/rmgr/base/rmgr_private.h"
int orte_rmgr_base_xconnect(orte_jobid_t child, orte_jobid_t parent)
{
orte_rml_cmd_flag_t command=ORTE_RML_UPDATE_CMD;
orte_gpr_notify_data_t *data=NULL;
orte_process_name_t name;
orte_buffer_t *buf;
int rc;
/* init the name fields */
name.cellid = ORTE_PROC_MY_NAME->cellid;
name.vpid = ORTE_VPID_WILDCARD; /* we want data from everyone in the job */
/* get the child's contact info */
name.jobid = child;
if (ORTE_SUCCESS != (rc = orte_rml.get_contact_info(&name, &data))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* send that info to everyone in the parent */
if (NULL != data) {
buf = OBJ_NEW(orte_buffer_t);
/* pack the update command */
if (ORTE_SUCCESS != (rc = orte_dss.pack(buf, &command, 1, ORTE_RML_CMD))) {
ORTE_ERROR_LOG(rc);
}
/* pack the data for xmission */
if (ORTE_SUCCESS != (rc = orte_dss.pack(buf, &data, 1, ORTE_GPR_NOTIFY_DATA))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(buf);
OBJ_RELEASE(data);
return rc;
}
/* now send it */
if (ORTE_SUCCESS != (rc = orte_rml.xcast(parent, buf, ORTE_RML_TAG_RML))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(buf);
OBJ_RELEASE(data);
return rc;
}
/* done with the buffer */
OBJ_RELEASE(buf);
/* cleanup the data */
OBJ_RELEASE(data);
}
/* get the parent's contact info */
name.jobid = parent;
if (ORTE_SUCCESS != (rc = orte_rml.get_contact_info(&name, &data))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* send that info to everyone in the child */
if (NULL != data) {
buf = OBJ_NEW(orte_buffer_t);
/* pack the update command */
if (ORTE_SUCCESS != (rc = orte_dss.pack(buf, &command, 1, ORTE_RML_CMD))) {
ORTE_ERROR_LOG(rc);
}
/* pack the data for xmission */
if (ORTE_SUCCESS != (rc = orte_dss.pack(buf, &data, 1, ORTE_GPR_NOTIFY_DATA))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(buf);
OBJ_RELEASE(data);
return rc;
}
/* now send it */
if (ORTE_SUCCESS != (rc = orte_rml.xcast(child, buf, ORTE_RML_TAG_RML))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(buf);
OBJ_RELEASE(data);
return rc;
}
/* done with the buffer */
OBJ_RELEASE(buf);
/* cleanup the data */
OBJ_RELEASE(data);
}
return ORTE_SUCCESS;
}

11
orte/mca/rmgr/base/rmgr_private.h
Просмотреть файл

@ -47,10 +47,11 @@ extern "C" {
/*
* Constants for command values
*/
#define ORTE_RMGR_SETUP_JOB_CMD 1
#define ORTE_RMGR_SPAWN_JOB_CMD 2
#define ORTE_RMGR_SETUP_GATES_CMD 3
#define ORTE_RMGR_SETUP_JOB_CMD 1
#define ORTE_RMGR_SPAWN_JOB_CMD 2
#define ORTE_RMGR_SETUP_GATES_CMD 3
#define ORTE_RMGR_XCONNECT_CMD 4
#define ORTE_RMGR_CMD ORTE_UINT8
typedef uint8_t orte_rmgr_cmd_t;
@ -129,6 +130,8 @@ ORTE_DECLSPEC int orte_rmgr_base_proc_stage_gate_init(orte_jobid_t job);
ORTE_DECLSPEC int orte_rmgr_base_proc_stage_gate_mgr(orte_gpr_notify_message_t *msg);
ORTE_DECLSPEC int orte_rmgr_base_xconnect(orte_jobid_t child, orte_jobid_t parent);
ORTE_DECLSPEC int orte_rmgr_base_comm_start(void);
ORTE_DECLSPEC int orte_rmgr_base_comm_stop(void);

135
orte/mca/rmgr/proxy/rmgr_proxy.c
Просмотреть файл

@ -232,6 +232,98 @@ static int orte_rmgr_proxy_setup_stage_gates(orte_jobid_t jobid)
}
static void orte_rmgr_proxy_xconnect_callback(orte_gpr_notify_data_t *data, void *cbdata)
{
orte_buffer_t cmd;
orte_buffer_t rsp;
orte_std_cntr_t count;
orte_rmgr_cmd_t command=ORTE_RMGR_XCONNECT_CMD;
orte_gpr_value_t **values;
orte_jobid_t child;
int rc;
OPAL_TRACE(1);
/* we made sure in the subscriptions that at least one
* value is always returned
* get the jobid from the segment name in the first value
*/
values = (orte_gpr_value_t**)(data->values)->addr;
if (ORTE_SUCCESS != (rc = orte_schema.extract_jobid_from_segment_name(&child,
values[0]->segment))) {
ORTE_ERROR_LOG(rc);
return;
}
/* construct command */
OBJ_CONSTRUCT(&cmd, orte_buffer_t);
/* pack the command */
if (ORTE_SUCCESS != (rc = orte_dss.pack(&cmd, &command, 1, ORTE_RMGR_CMD))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&cmd);
return;
}
/* pack the child */
if(ORTE_SUCCESS != (rc = orte_dss.pack(&cmd, &child, 1, ORTE_JOBID))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&cmd);
return;
}
/* pack the parent jobid (which is mine!) */
if(ORTE_SUCCESS != (rc = orte_dss.pack(&cmd, &(ORTE_PROC_MY_NAME->jobid), 1, ORTE_JOBID))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&cmd);
return;
}
/* send the command */
if(0 > (rc = orte_rml.send_buffer(ORTE_PROC_MY_HNP, &cmd, ORTE_RML_TAG_RMGR, 0))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&cmd);
return;
}
OBJ_DESTRUCT(&cmd);
/* wait for response */
OBJ_CONSTRUCT(&rsp, orte_buffer_t);
if(0 > (rc = orte_rml.recv_buffer(ORTE_PROC_MY_HNP, &rsp, ORTE_RML_TAG_RMGR))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&rsp);
return;
}
/* get the returned command */
count = 1;
if (ORTE_SUCCESS != (rc = orte_dss.unpack(&rsp, &command, &count, ORTE_RMGR_CMD))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&rsp);
return;
}
/* and check it to ensure valid comm */
if (ORTE_RMGR_XCONNECT_CMD != command) {
OBJ_DESTRUCT(&rsp);
ORTE_ERROR_LOG(ORTE_ERR_COMM_FAILURE);
return;
}
OBJ_DESTRUCT(&rsp);
/* signal that the application has completed xconnect */
OPAL_THREAD_LOCK(&mca_rmgr_proxy_component.lock);
mca_rmgr_proxy_component.xconnect = true;
/* if the launch is also done, then spawn complete */
if (mca_rmgr_proxy_component.launched) {
mca_rmgr_proxy_component.done = true;
mca_rmgr_proxy_component.rc = ORTE_SUCCESS;
opal_condition_signal(&mca_rmgr_proxy_component.cond);
}
OPAL_THREAD_UNLOCK(&mca_rmgr_proxy_component.lock);
}
static void orte_rmgr_proxy_wireup_stdin(orte_jobid_t jobid)
{
int rc;
@ -352,9 +444,13 @@ static void orte_rmgr_proxy_wireup_callback(orte_gpr_notify_data_t *data, void *
/* signal that the application has indeed launched */
OPAL_THREAD_LOCK(&mca_rmgr_proxy_component.lock);
mca_rmgr_proxy_component.done = true;
mca_rmgr_proxy_component.rc = ORTE_SUCCESS;
opal_condition_signal(&mca_rmgr_proxy_component.cond);
mca_rmgr_proxy_component.launched = true;
/* if the xconnect is also done, then spawn complete */
if (mca_rmgr_proxy_component.xconnect) {
mca_rmgr_proxy_component.done = true;
mca_rmgr_proxy_component.rc = ORTE_SUCCESS;
opal_condition_signal(&mca_rmgr_proxy_component.cond);
}
OPAL_THREAD_UNLOCK(&mca_rmgr_proxy_component.lock);
}
@ -385,21 +481,24 @@ static int orte_rmgr_proxy_spawn_job(
{
int rc;
orte_process_name_t name = {0, ORTE_JOBID_INVALID, 0};
orte_attribute_t *flow;
orte_attribute_t *attr;
uint8_t flags, *fptr;
orte_proc_state_t *gate;
OPAL_TRACE(1);
/* mark that the spawn is not done */
OPAL_THREAD_LOCK(&mca_rmgr_proxy_component.lock);
mca_rmgr_proxy_component.done = false;
mca_rmgr_proxy_component.launched = false;
mca_rmgr_proxy_component.xconnect = false;
mca_rmgr_proxy_component.rc = ORTE_ERR_FAILED_TO_START;
OPAL_THREAD_UNLOCK(&mca_rmgr_proxy_component.lock);
/* check for any flow directives to control what we do */
if (NULL != (flow = orte_rmgr.find_attribute(attributes, ORTE_RMGR_SPAWN_FLOW))) {
if (NULL != (attr = orte_rmgr.find_attribute(attributes, ORTE_RMGR_SPAWN_FLOW))) {
/* something was specified - get the value */
if (ORTE_SUCCESS != (rc = orte_dss.get((void**)&fptr, flow->value, ORTE_UINT8))) {
if (ORTE_SUCCESS != (rc = orte_dss.get((void**)&fptr, attr->value, ORTE_UINT8))) {
ORTE_ERROR_LOG(rc);
return rc;
}
@ -469,6 +568,26 @@ static int orte_rmgr_proxy_spawn_job(
return rc;
}
/* see if we need to setup a cross-connect of ORTE information with the new job */
if (NULL != (attr = orte_rmgr.find_attribute(attributes, ORTE_RMGR_XCONNECT_AT_SPAWN))) {
/* cross-connect was requested - get the stage gate name where this is to occur */
if (ORTE_SUCCESS != (rc = orte_dss.get((void**)&gate, attr->value, ORTE_PROC_STATE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* setup the xconnect subscription on the new job so we can complete the procedure */
if (ORTE_SUCCESS != (rc = orte_smr.job_stage_gate_subscribe(*jobid,
orte_rmgr_proxy_xconnect_callback, NULL, *gate))) {
ORTE_ERROR_LOG(rc);
return rc;
}
} else {
/* indicate that we don't need to wait for xconnect */
OPAL_THREAD_LOCK(&mca_rmgr_proxy_component.lock);
mca_rmgr_proxy_component.xconnect = true;
OPAL_THREAD_UNLOCK(&mca_rmgr_proxy_component.lock);
}
/* setup the subscription so we will know if things fail to launch */
rc = orte_smr.job_stage_gate_subscribe(*jobid, app_terminated, NULL, ORTE_PROC_STATE_TERMINATED);
if(ORTE_SUCCESS != rc) {
@ -485,7 +604,7 @@ static int orte_rmgr_proxy_spawn_job(
}
/*
* setup callback
* setup any user-provided callback
*/
if(NULL != cbfunc) {
@ -509,7 +628,7 @@ static int orte_rmgr_proxy_spawn_job(
}
}
/* if we don't want to launch, then just return here */
if (!(flags & ORTE_RMGR_LAUNCH)) {
return ORTE_SUCCESS;

4
orte/mca/rmgr/proxy/rmgr_proxy.h
Просмотреть файл

@ -41,6 +41,10 @@ struct orte_rmgr_proxy_component_t {
/* conditioned wait variable */
opal_condition_t cond;
/* flag for tracking completion of app launch */
bool launched;
/* flag indicating that an xconnect is underway */
bool xconnect;
/* flag for tracking completion of spawn */
bool done;
/* return status code */
int rc;

5
orte/mca/rmgr/rmgr_types.h
Просмотреть файл

@ -74,9 +74,10 @@ ORTE_DECLSPEC OBJ_CLASS_DECLARATION(orte_attribute_t);
/* direct the RMGR spawn procedure to cross-connect ORTE information
* between the parent job and the newly spawned child.
* Takes parent's jobid as value.
* Takes process state corresponding to the stage gate where
* the cross-connect is to be done
*/
#define ORTE_RMGR_XCONNECT_AT_SPAWN "orte-rmgr-xconnect"
#define ORTE_RMGR_XCONNECT_AT_SPAWN "orte-rmgr-xconnect-job"
/* RESOURCE MANAGER DATA TYPES */

10
orte/mca/rml/base/Makefile.am
Просмотреть файл

@ -22,4 +22,12 @@ headers += \
libmca_rml_la_SOURCES += \
base/rml_base_open.c \
base/rml_base_close.c \
base/rml_base_select.c
base/rml_base_select.c \
base/rml_base_receive.c \
base/data_type_support/rml_data_type_compare_fns.c \
base/data_type_support/rml_data_type_copy_fns.c \
base/data_type_support/rml_data_type_packing_fns.c \
base/data_type_support/rml_data_type_print_fns.c \
base/data_type_support/rml_data_type_release_fns.c \
base/data_type_support/rml_data_type_size_fns.c \
base/data_type_support/rml_data_type_unpacking_fns.c

23
orte/mca/rml/base/base.h
Просмотреть файл

@ -35,6 +35,29 @@ ORTE_DECLSPEC int orte_rml_base_open(void);
ORTE_DECLSPEC int orte_rml_base_select(void);
ORTE_DECLSPEC int orte_rml_base_close(void);
/*
* Data type support
*/
ORTE_DECLSPEC int orte_rml_base_compare_tags(orte_rml_tag_t *value1, orte_rml_tag_t *value2, orte_data_type_t type);
ORTE_DECLSPEC int orte_rml_base_copy_tag(orte_rml_tag_t **dest, orte_rml_tag_t *src, orte_data_type_t type);
ORTE_DECLSPEC int orte_rml_base_pack_tag(orte_buffer_t *buffer, void *src,
orte_std_cntr_t num_vals, orte_data_type_t type);
ORTE_DECLSPEC int orte_rml_base_print_tag(char **output, char *prefix, orte_rml_tag_t *src, orte_data_type_t type);
ORTE_DECLSPEC void orte_rml_base_std_obj_release(orte_data_value_t *value);
ORTE_DECLSPEC int orte_rml_base_size_tag(size_t *size, orte_rml_tag_t *src, orte_data_type_t type);
ORTE_DECLSPEC int orte_rml_base_unpack_tag(orte_buffer_t *buffer, void *dest,
orte_std_cntr_t *num_vals, orte_data_type_t type);
/*
* Internal functions
*/
int orte_rml_base_comm_start(void);
int orte_rml_base_comm_stop(void);
void orte_rml_base_recv(int status, orte_process_name_t* sender,
orte_buffer_t* buffer, orte_rml_tag_t tag,
void* cbdata);
/*
* Global struct holding the base parameters.
*/

33
orte/mca/rml/base/data_type_support/rml_data_type_compare_fns.c Обычный файл
Просмотреть файл

@ -0,0 +1,33 @@
/*
* Copyright (c) 2004-2005 The Trustees of Indiana University.
* All rights reserved.
* Copyright (c) 2004-2005 The Trustees of the University of Tennessee.
* All rights reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#include "orte_config.h"
#include "orte/mca/rml/base/base.h"
/*
* RML tags
*/
int orte_rml_base_compare_tags(orte_rml_tag_t *value1, orte_rml_tag_t *value2, orte_data_type_t type)
{
if (*value1 > *value2) {
return ORTE_VALUE1_GREATER;
} else if (*value1 < *value2) {
return ORTE_VALUE2_GREATER;
} else {
return ORTE_EQUAL;
}
}

58
orte/mca/rml/base/data_type_support/rml_data_type_copy_fns.c Обычный файл
Просмотреть файл

@ -0,0 +1,58 @@
/*
* Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2005 The University of Tennessee and The University
* of Tennessee Research Foundation. All rights
* reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#include "orte_config.h"
#include <sys/types.h>
#if HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#include "opal/util/argv.h"
#include "opal/class/opal_list.h"
#include "orte/mca/errmgr/errmgr.h"
#include "orte/dss/dss.h"
#include "orte/mca/rml/base/base.h"
/*
* RML tag
*/
int orte_rml_base_copy_tag(orte_rml_tag_t **dest, orte_rml_tag_t *src, orte_data_type_t type)
{
orte_rml_tag_t *tag;
if (NULL == src) {
*dest = NULL;
return ORTE_SUCCESS;
}
/* create the new space */
tag = (orte_rml_tag_t*)malloc(sizeof(orte_rml_tag_t));
if (NULL == tag) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* copy data into it */
*tag = *src;
*dest = tag;
return ORTE_SUCCESS;
}

40
orte/mca/rml/base/data_type_support/rml_data_type_packing_fns.c Обычный файл
Просмотреть файл

@ -0,0 +1,40 @@
/*
* Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2005 The University of Tennessee and The University
* of Tennessee Research Foundation. All rights
* reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#include "orte_config.h"
#include "orte/mca/errmgr/errmgr.h"
#include "orte/dss/dss_internal.h"
#include "orte/mca/rml/base/base.h"
/*
* RML TAG
*/
int orte_rml_base_pack_tag(orte_buffer_t *buffer, void *src,
orte_std_cntr_t num_vals, orte_data_type_t type)
{
int rc;
/* Turn around and pack the real type */
if (ORTE_SUCCESS != (rc = orte_dss_pack_buffer(buffer, src, num_vals, ORTE_RML_TAG_T))) {
ORTE_ERROR_LOG(rc);
}
return rc;
}

44
orte/mca/rml/base/data_type_support/rml_data_type_print_fns.c Обычный файл
Просмотреть файл

@ -0,0 +1,44 @@
/*
* Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2005 The University of Tennessee and The University
* of Tennessee Research Foundation. All rights
* reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#include "orte_config.h"
#include "orte/mca/rml/base/base.h"
/*
* RML TAG
*/
int orte_rml_base_print_tag(char **output, char *prefix, orte_rml_tag_t *src, orte_data_type_t type)
{
char *pfx2;
/* set default result */
*output = NULL;
/* protect against NULL prefix */
if (NULL == prefix) {
asprintf(&pfx2, " ");
} else {
asprintf(&pfx2, "%s", prefix);
}
asprintf(output, "%sRML tag value %ld", pfx2, (long)*src);
free(pfx2);
return ORTE_SUCCESS;
}

28
orte/mca/rml/base/data_type_support/rml_data_type_release_fns.c Обычный файл
Просмотреть файл

@ -0,0 +1,28 @@
/*
* Copyright (c) 2004-2005 The Trustees of Indiana University.
* All rights reserved.
* Copyright (c) 2004-2005 The Trustees of the University of Tennessee.
* All rights reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#include "orte_config.h"
#include "orte/mca/rml/base/base.h"
/*
* STANDARD OBJECT RELEASE
*/
void orte_rml_base_std_obj_release(orte_data_value_t *value)
{
OBJ_RELEASE(value->data);
}

41
orte/mca/rml/base/data_type_support/rml_data_type_size_fns.c Обычный файл
Просмотреть файл

@ -0,0 +1,41 @@
/*
* Copyright (c) 2004-2005 The Trustees of Indiana University.
* All rights reserved.
* Copyright (c) 2004-2005 The Trustees of the University of Tennessee.
* All rights reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#include "orte_config.h"
#include <sys/types.h>
#if HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#include "opal/util/argv.h"
#include "opal/class/opal_list.h"
#include "orte/mca/errmgr/errmgr.h"
#include "orte/dss/dss.h"
#include "orte/mca/rml/base/base.h"
/*
* RML TAG
*/
int orte_rml_base_size_tag(size_t *size, orte_rml_tag_t *src, orte_data_type_t type)
{
/* account for the object itself */
*size = sizeof(orte_rml_tag_t);
return ORTE_SUCCESS;
}

43
orte/mca/rml/base/data_type_support/rml_data_type_unpacking_fns.c Обычный файл
Просмотреть файл

@ -0,0 +1,43 @@
/*
* Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2005 The University of Tennessee and The University
* of Tennessee Research Foundation. All rights
* reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#include "orte_config.h"
#include "orte/orte_constants.h"
#include "orte/orte_types.h"
#include "orte/mca/errmgr/errmgr.h"
#include "orte/dss/dss_internal.h"
#include "orte/mca/rml/base/base.h"
/*
* JOB_MAP
*/
int orte_rml_base_unpack_tag(orte_buffer_t *buffer, void *dest,
orte_std_cntr_t *num_vals, orte_data_type_t type)
{
int ret;
/* Turn around and unpack the real type */
if (ORTE_SUCCESS != (ret = orte_dss_unpack_buffer(buffer, dest, num_vals, ORTE_RML_TAG_T))) {
ORTE_ERROR_LOG(ret);
}
return ret;
}

19
orte/mca/rml/base/rml_base_open.c
Просмотреть файл

@ -24,8 +24,12 @@
#include "opal/mca/base/base.h"
#include "opal/mca/base/mca_base_param.h"
#include "opal/util/output.h"
#include "orte/dss/dss.h"
#include "orte/mca/errmgr/errmgr.h"
#include "orte/mca/oob/oob.h"
#include "orte/mca/oob/base/base.h"
#include "orte/mca/rml/base/base.h"
/*
@ -55,6 +59,7 @@ int orte_rml_base_open(void)
int int_value;
int rc;
char *rml_wrapper = NULL;
orte_data_type_t tmp;
/* Initialize globals */
OBJ_CONSTRUCT(&orte_rml_base.rml_components, opal_list_t);
@ -71,6 +76,20 @@ int orte_rml_base_open(void)
orte_rml_base.rml_debug = int_value;
opal_output_set_verbosity(orte_rml_base.rml_output, int_value);
/* register the base system types with the DPS */
tmp = ORTE_RML_TAG;
if (ORTE_SUCCESS != (rc = orte_dss.register_type(orte_rml_base_pack_tag,
orte_rml_base_unpack_tag,
(orte_dss_copy_fn_t)orte_rml_base_copy_tag,
(orte_dss_compare_fn_t)orte_rml_base_compare_tags,
(orte_dss_size_fn_t)orte_rml_base_size_tag,
(orte_dss_print_fn_t)orte_rml_base_print_tag,
(orte_dss_release_fn_t)orte_rml_base_std_obj_release,
ORTE_DSS_UNSTRUCTURED,
"ORTE_RML_TAG", &tmp))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/*
* Which RML Wrapper component to use, if any
* - NULL or "" = No wrapper

118
orte/mca/rml/base/rml_base_receive.c Обычный файл
Просмотреть файл

@ -0,0 +1,118 @@
/* -*- C -*-
*
* Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2005 The University of Tennessee and The University
* of Tennessee Research Foundation. All rights
* reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
/** @file:
*
*/
/*
* includes
*/
#include "orte_config.h"
#include "orte/orte_constants.h"
#include "orte/orte_types.h"
#include "opal/util/output.h"
#include "opal/mca/mca.h"
#include "opal/mca/base/mca_base_param.h"
#include "orte/dss/dss.h"
#include "orte/util/proc_info.h"
#include "orte/mca/errmgr/errmgr.h"
#include "orte/mca/rml/rml.h"
#include "orte/mca/rml/base/base.h"
static bool recv_issued=false;
int orte_rml_base_comm_start(void)
{
int rc;
if (recv_issued) {
return ORTE_SUCCESS;
}
if (ORTE_SUCCESS != (rc = orte_rml.recv_buffer_nb(ORTE_NAME_WILDCARD,
ORTE_RML_TAG_RML,
ORTE_RML_PERSISTENT,
orte_rml_base_recv,
NULL))) {
ORTE_ERROR_LOG(rc);
}
recv_issued = true;
return rc;
}
int orte_rml_base_comm_stop(void)
{
int rc;
if (!recv_issued) {
return ORTE_SUCCESS;
}
if (ORTE_SUCCESS != (rc = orte_rml.recv_cancel(ORTE_NAME_WILDCARD, ORTE_RML_TAG_RML))) {
ORTE_ERROR_LOG(rc);
}
recv_issued = false;
return rc;
}
/*
* handle message from proxies
* NOTE: The incoming buffer "buffer" is OBJ_RELEASED by the calling program.
* DO NOT RELEASE THIS BUFFER IN THIS CODE
*/
void orte_rml_base_recv(int status, orte_process_name_t* sender,
orte_buffer_t* buffer, orte_rml_tag_t tag,
void* cbdata)
{
orte_rml_cmd_flag_t command;
orte_std_cntr_t count;
orte_gpr_notify_data_t *data;
int rc;
count = 1;
if (ORTE_SUCCESS != (rc = orte_dss.unpack(buffer, &command, &count, ORTE_RML_CMD))) {
ORTE_ERROR_LOG(rc);
return;
}
switch (command) {
case ORTE_RML_UPDATE_CMD:
count = 1;
if (ORTE_SUCCESS != (rc = orte_dss.unpack(buffer, &data, &count, ORTE_GPR_NOTIFY_DATA))) {
ORTE_ERROR_LOG(rc);
return;
}
orte_rml.update_contact_info(data, NULL);
break;
default:
ORTE_ERROR_LOG(ORTE_ERR_VALUE_OUT_OF_BOUNDS);
}
}

52
orte/mca/rml/cnos/rml_cnos.c
Просмотреть файл

@ -72,7 +72,13 @@ orte_rml_module_t orte_rml_cnos_module = {
orte_rml_cnos_recv_buffer_nb,
orte_rml_cnos_recv_cancel,
orte_rml_cnos_barrier,
orte_rml_cnos_xcast
orte_rml_cnos_xcast,
orte_rml_cnos_xcast_nb,
orte_rml_cnos_xcast_gate,
orte_rml_cnos_register_contact_info,
orte_rml_cnos_register_subscription,
orte_rml_cnos_get_contact_info,
orte_rml_cnos_update_contact_info
};
@ -223,14 +229,24 @@ orte_rml_cnos_barrier(void)
}
int
orte_rml_cnos_xcast(orte_process_name_t * root,
orte_gpr_notify_message_t *msg2,
orte_gpr_trigger_cb_fn_t cbfunc)
orte_rml_cnos_xcast(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag)
{
if (NULL != root || NULL != msg2) {
return ORTE_ERR_NOT_SUPPORTED;
}
return ORTE_SUCCESS;
}
int
orte_rml_cnos_xcast_nb(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag)
{
return ORTE_SUCCESS;
}
int
orte_rml_cnos_xcast_gate(orte_gpr_trigger_cb_fn_t cbfunc)
{
orte_rml_cnos_barrier();
if (NULL != cbfunc) {
orte_gpr_notify_message_t *msg;
@ -245,3 +261,25 @@ orte_rml_cnos_xcast(orte_process_name_t * root,
return ORTE_SUCCESS;
}
int orte_rml_cnos_register_contact_info(void)
{
return ORTE_SUCCESS;
}
int orte_rml_cnos_register_subscription(orte_jobid_t job, char *trigger)
{
return ORTE_SUCCESS;
}
int orte_rml_cnos_get_contact_info(orte_process_name_t *name, orte_gpr_notify_data_t **data)
{
return ORTE_SUCCESS;
}
void orte_rml_cnos_update_contact_info(orte_gpr_notify_data_t* data,
void* cbdata)
{
return;
}

21
orte/mca/rml/cnos/rml_cnos.h
Просмотреть файл

@ -90,11 +90,26 @@ extern "C"
orte_rml_tag_t tag);
int orte_rml_cnos_xcast(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag);
int orte_rml_cnos_xcast_nb(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag);
int orte_rml_cnos_xcast_gate(orte_gpr_trigger_cb_fn_t cbfunc);
int orte_rml_cnos_barrier(void);
int orte_rml_cnos_xcast(orte_process_name_t * root,
orte_gpr_notify_message_t *msg,
orte_gpr_trigger_cb_fn_t cbfunc);
int orte_rml_cnos_register_contact_info(void);
int orte_rml_cnos_register_subscription(orte_jobid_t job, char *trigger);
int orte_rml_cnos_get_contact_info(orte_process_name_t *name, orte_gpr_notify_data_t **data);
void orte_rml_cnos_update_contact_info(orte_gpr_notify_data_t* data,
void* cbdata);
#if defined(c_plusplus) || defined(__cplusplus)
}

20
orte/mca/rml/ftrm/rml_ftrm.h
Просмотреть файл

@ -157,9 +157,25 @@ extern "C" {
* Xcast
*/
int orte_rml_ftrm_xcast(orte_jobid_t job,
orte_gpr_notify_message_t *msg,
orte_gpr_trigger_cb_fn_t cbfunc);
orte_buffer_t *buffer,
orte_rml_tag_t tag);
int orte_rml_ftrm_xcast_nb(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag);
int orte_rml_ftrm_xcast_gate(orte_gpr_trigger_cb_fn_t cbfunc);
int orte_rml_ftrm_register_contact_info(void);
int orte_rml_ftrm_register_subscription(orte_jobid_t job, char *trigger);
int orte_rml_ftrm_get_contact_info(orte_process_name_t *name, orte_gpr_notify_data_t **data);
void orte_rml_ftrm_update_contact_info(orte_gpr_notify_data_t* data,
void* cbdata);
/*
* Register a callback on loss of connection
*/

2
orte/mca/rml/ftrm/rml_ftrm_component.c
Просмотреть файл

@ -84,6 +84,8 @@ orte_rml_module_t orte_rml_ftrm_module = {
orte_rml_ftrm_recv_cancel,
orte_rml_ftrm_xcast,
orte_rml_ftrm_xcast_nb,
orte_rml_ftrm_xcast_gate,
orte_rml_ftrm_add_exception_handler,
orte_rml_ftrm_del_exception_handler,

103
orte/mca/rml/ftrm/rml_ftrm_module.c
Просмотреть файл

@ -392,16 +392,50 @@ int orte_rml_ftrm_recv_cancel(orte_process_name_t* peer, orte_rml_tag_t tag)
* Xcast
*/
int orte_rml_ftrm_xcast(orte_jobid_t job,
orte_gpr_notify_message_t *msg,
orte_gpr_trigger_cb_fn_t cbfunc)
orte_buffer_t *buffer,
orte_rml_tag_t tag)
{
int ret;
opal_output_verbose(20, rml_ftrm_output_handle,
"orte_rml_ftrm: xcast()");
if( NULL != wrapped_module.xcast ) {
if( ORTE_SUCCESS != (ret = wrapped_module.xcast(job, buffer, tag) ) ) {
return ret;
}
}
return ORTE_SUCCESS;
}
int orte_rml_ftrm_xcast_nb(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag)
{
int ret;
opal_output_verbose(20, rml_ftrm_output_handle,
"orte_rml_ftrm: xcast_nb()");
if( NULL != wrapped_module.xcast_gate ) {
if( ORTE_SUCCESS != (ret = wrapped_module.xcast_nb(job, buffer, tag) ) ) {
return ret;
}
}
return ORTE_SUCCESS;
}
int orte_rml_ftrm_xcast_gate(orte_gpr_trigger_cb_fn_t cbfunc)
{
int ret;
opal_output_verbose(20, rml_ftrm_output_handle,
"orte_rml_ftrm: xcast()");
"orte_rml_ftrm: xcast_gate()");
if( NULL != wrapped_module.xcast ) {
if( ORTE_SUCCESS != (ret = wrapped_module.xcast(job, msg, cbfunc) ) ) {
if( NULL != wrapped_module.xcast_gate ) {
if( ORTE_SUCCESS != (ret = wrapped_module.xcast_gate(cbfunc) ) ) {
return ret;
}
}
@ -410,6 +444,65 @@ int orte_rml_ftrm_xcast(orte_jobid_t job,
}
int orte_rml_ftrm_register_contact_info(void)
{
int ret;
opal_output_verbose(20, rml_ftrm_output_handle,
"orte_rml_ftrm: register_contact_info()");
if( NULL != wrapped_module.register_contact_info ) {
if( ORTE_SUCCESS != (ret = wrapped_module.register_contact_info() ) ) {
return ret;
}
}
return ORTE_SUCCESS;
}
int orte_rml_ftrm_register_subscription(orte_jobid_t job, char *trigger)
{
int ret;
opal_output_verbose(20, rml_ftrm_output_handle,
"orte_rml_ftrm: register_subscription()");
if( NULL != wrapped_module.register_subscription ) {
if( ORTE_SUCCESS != (ret = wrapped_module.register_subscription(job, trigger) ) ) {
return ret;
}
}
return ORTE_SUCCESS;
}
int orte_rml_ftrm_get_contact_info(orte_process_name_t *name, orte_gpr_notify_data_t **data)
{
int ret;
opal_output_verbose(20, rml_ftrm_output_handle,
"orte_rml_ftrm: get_contact_info()");
if( NULL != wrapped_module.get_contact_info ) {
if( ORTE_SUCCESS != (ret = wrapped_module.get_contact_info(name, data) ) ) {
return ret;
}
}
return ORTE_SUCCESS;
}
void orte_rml_ftrm_update_contact_info(orte_gpr_notify_data_t* data,
void* cbdata)
{
opal_output_verbose(20, rml_ftrm_output_handle,
"orte_rml_ftrm: update_contact_info()");
if( NULL != wrapped_module.update_contact_info ) {
wrapped_module.update_contact_info(data, cbdata);
}
}
/*
* Register a callback on loss of connection
*/

11
orte/mca/rml/oob/rml_oob_component.c
Просмотреть файл

@ -64,7 +64,7 @@ orte_rml_component_t mca_rml_oob_component = {
orte_rml_module_t orte_rml_oob_module = {
mca_oob_base_module_init,
NULL,
(orte_rml_module_get_uri_fn_t)mca_oob_get_contact_info,
(orte_rml_module_get_uri_fn_t)mca_oob_get_my_contact_info,
(orte_rml_module_set_uri_fn_t)mca_oob_set_contact_info,
(orte_rml_module_parse_uris_fn_t)mca_oob_parse_contact_info,
(orte_rml_module_ping_fn_t)mca_oob_ping,
@ -78,9 +78,15 @@ orte_rml_module_t orte_rml_oob_module = {
(orte_rml_module_recv_buffer_nb_fn_t)mca_oob_recv_packed_nb,
(orte_rml_module_recv_cancel_fn_t)mca_oob_recv_cancel,
(orte_rml_module_xcast_fn_t)mca_oob_xcast,
(orte_rml_module_xcast_nb_fn_t)mca_oob_xcast_nb,
(orte_rml_module_xcast_gate_fn_t)mca_oob_xcast_gate,
(orte_rml_module_exception_fn_t)mca_oob_add_exception_handler,
(orte_rml_module_exception_fn_t)mca_oob_del_exception_handler,
(orte_rml_module_ft_event_fn_t)orte_rml_oob_ft_event
(orte_rml_module_ft_event_fn_t)orte_rml_oob_ft_event,
(orte_rml_module_register_contact_info_fn_t) mca_oob_register_contact_info,
(orte_rml_module_register_subscription_fn_t) mca_oob_register_subscription,
(orte_rml_module_get_contact_info_fn_t) mca_oob_get_contact_info,
(orte_rml_module_update_contact_info_fn_t) mca_oob_update_contact_info
};
@ -89,6 +95,7 @@ static orte_rml_module_t* orte_rml_oob_init(int* priority)
if(mca_oob_base_init() != ORTE_SUCCESS)
return NULL;
*priority = 1;
return &orte_rml_oob_module;
}

87
orte/mca/rml/rml.h
Просмотреть файл

@ -71,6 +71,13 @@ typedef char* (*orte_rml_module_get_uri_fn_t)(void);
typedef int (*orte_rml_module_set_uri_fn_t)(const char*);
/**
* Update the RML contact tables
*/
typedef void (*orte_rml_module_update_contact_info_fn_t)(orte_gpr_notify_data_t* data,
void* cbdata);
/**
* orte_rml.rml_parse_uris()
*
@ -331,8 +338,40 @@ typedef int (*orte_rml_module_recv_cancel_fn_t)(orte_process_name_t* peer, orte_
*/
typedef int (*orte_rml_module_xcast_fn_t)(orte_jobid_t job,
orte_gpr_notify_message_t *msg,
orte_gpr_trigger_cb_fn_t cbfunc);
orte_buffer_t *buffer,
orte_rml_tag_t tag);
typedef int (*orte_rml_module_xcast_nb_fn_t)(orte_jobid_t job,
orte_buffer_t *buffer,
orte_rml_tag_t tag);
typedef int (*orte_rml_module_xcast_gate_fn_t)(orte_gpr_trigger_cb_fn_t cbfunc);
/*
* Register my contact info with the General Purpose Registry
* This function is called while within the GPR's compound command. In turn,
* it calls the open OOB components and has each "put" its contact info
* on the registry.
*/
typedef int (*orte_rml_module_register_contact_info_fn_t)(void);
/*
* Register a subscription to receive contact info on other processes
* This function will typically be called from within a GPR compound command
* to register a subscription against a stage gate trigger. When fired, this
* will return the RML contact info for all processes in the specified job
*/
typedef int (*orte_rml_module_register_subscription_fn_t)(orte_jobid_t job, char *trigger);
/*
* Get contact info for a process or job
* Returns contact info for the specified process. If the vpid in the process name
* is WILDCARD, then it returns the contact info for all processes in the specified
* job. If the jobid is WILDCARD, then it returns the contact info for processes
* of the specified vpid across all jobs. Obviously, combining the two WILDCARD
* values will return contact info for everyone!
*/
typedef int (*orte_rml_module_get_contact_info_fn_t)(orte_process_name_t *name, orte_gpr_notify_data_t **data);
/*
* Callback on exception condition.
@ -379,25 +418,31 @@ typedef int (*orte_rml_module_ft_event_fn_t)(int state);
* RML Module
*/
struct orte_rml_module_t {
orte_rml_module_init_fn_t init;
orte_rml_module_fini_fn_t fini;
orte_rml_module_get_uri_fn_t get_uri;
orte_rml_module_set_uri_fn_t set_uri;
orte_rml_module_parse_uris_fn_t parse_uris;
orte_rml_module_ping_fn_t ping;
orte_rml_module_send_fn_t send;
orte_rml_module_send_nb_fn_t send_nb;
orte_rml_module_send_buffer_fn_t send_buffer;
orte_rml_module_send_buffer_nb_fn_t send_buffer_nb;
orte_rml_module_recv_fn_t recv;
orte_rml_module_recv_nb_fn_t recv_nb;
orte_rml_module_recv_buffer_fn_t recv_buffer;
orte_rml_module_recv_buffer_nb_fn_t recv_buffer_nb;
orte_rml_module_recv_cancel_fn_t recv_cancel;
orte_rml_module_xcast_fn_t xcast;
orte_rml_module_exception_fn_t add_exception_handler;
orte_rml_module_exception_fn_t del_exception_handler;
orte_rml_module_ft_event_fn_t ft_event;
orte_rml_module_init_fn_t init;
orte_rml_module_fini_fn_t fini;
orte_rml_module_get_uri_fn_t get_uri;
orte_rml_module_set_uri_fn_t set_uri;
orte_rml_module_parse_uris_fn_t parse_uris;
orte_rml_module_ping_fn_t ping;
orte_rml_module_send_fn_t send;
orte_rml_module_send_nb_fn_t send_nb;
orte_rml_module_send_buffer_fn_t send_buffer;
orte_rml_module_send_buffer_nb_fn_t send_buffer_nb;
orte_rml_module_recv_fn_t recv;
orte_rml_module_recv_nb_fn_t recv_nb;
orte_rml_module_recv_buffer_fn_t recv_buffer;
orte_rml_module_recv_buffer_nb_fn_t recv_buffer_nb;
orte_rml_module_recv_cancel_fn_t recv_cancel;
orte_rml_module_xcast_fn_t xcast;
orte_rml_module_xcast_nb_fn_t xcast_nb;
orte_rml_module_xcast_gate_fn_t xcast_gate;
orte_rml_module_exception_fn_t add_exception_handler;
orte_rml_module_exception_fn_t del_exception_handler;
orte_rml_module_ft_event_fn_t ft_event;
orte_rml_module_register_contact_info_fn_t register_contact_info;
orte_rml_module_register_subscription_fn_t register_subscription;
orte_rml_module_get_contact_info_fn_t get_contact_info;
orte_rml_module_update_contact_info_fn_t update_contact_info;
};
typedef struct orte_rml_module_t orte_rml_module_t;

61
orte/mca/rml/rml_types.h
Просмотреть файл

@ -41,39 +41,48 @@
*/
typedef uint32_t orte_rml_tag_t;
#define ORTE_RML_TAG ORTE_UINT32
#define ORTE_RML_TAG_T ORTE_UINT32
#define ORTE_RML_TAG_MAX UINT32_MAX
#define ORTE_RML_TAG_NS 1
#define ORTE_RML_TAG_GPR 2
#define ORTE_RML_TAG_GPR_NOTIFY 3
#define ORTE_RML_TAG_DAEMON 4
#define ORTE_RML_TAG_IOF_SVC 5
#define ORTE_RML_TAG_IOF_CLNT 6
#define ORTE_RML_TAG_XCAST 7
#define ORTE_RML_TAG_RMGR 8
#define ORTE_RML_TAG_PROBE 9
#define ORTE_RML_TAG_RDS 10
#define ORTE_RML_TAG_RAS 11
#define ORTE_RML_TAG_RMAPS 12
#define ORTE_RML_TAG_PLS 13
#define ORTE_RML_TAG_PLS_ORTED 14
#define ORTE_RML_TAG_PLS_ORTED_ACK 15
#define ORTE_RML_TAG_ERRMGR 16
#define ORTE_RML_TAG_BPROC 17
#define ORTE_RML_TAG_BPROC_ABORT 18
#define ORTE_RML_TAG_SM_BACK_FILE_CREATED 19
#define ORTE_RML_TAG_WIREUP 20
#define ORTE_RML_TAG_FILEM 21
#define ORTE_RML_TAG_CKPT 22
#define ORTE_RML_TAG_NS 1
#define ORTE_RML_TAG_GPR 2
#define ORTE_RML_TAG_GPR_NOTIFY 3
#define ORTE_RML_TAG_DAEMON 4
#define ORTE_RML_TAG_IOF_SVC 5
#define ORTE_RML_TAG_IOF_CLNT 6
#define ORTE_RML_TAG_XCAST_BARRIER 7
#define ORTE_RML_TAG_XCAST_NB 8
#define ORTE_RML_TAG_RMGR 9
#define ORTE_RML_TAG_PROBE 10
#define ORTE_RML_TAG_RDS 11
#define ORTE_RML_TAG_RAS 12
#define ORTE_RML_TAG_RMAPS 13
#define ORTE_RML_TAG_PLS 14
#define ORTE_RML_TAG_PLS_ORTED 15
#define ORTE_RML_TAG_PLS_ORTED_ACK 16
#define ORTE_RML_TAG_ERRMGR 17
#define ORTE_RML_TAG_BPROC 18
#define ORTE_RML_TAG_BPROC_ABORT 19
#define ORTE_RML_TAG_SM_BACK_FILE_CREATED 20
#define ORTE_RML_TAG_WIREUP 21
#define ORTE_RML_TAG_RML 22
#define ORTE_RML_TAG_FILEM 23
#define ORTE_RML_TAG_CKPT 24
/* For CRCP Coord Component */
#define OMPI_CRCP_COORD_BOOKMARK_TAG 4242
#define OMPI_CRCP_COORD_BOOKMARK_TAG 4242
#define ORTE_RML_TAG_DYNAMIC 2000
#define ORTE_RML_TAG_MAX UINT32_MAX
/*
* RML proxy commands
*/
typedef uint8_t orte_rml_cmd_flag_t;
#define ORTE_RML_CMD ORTE_UINT8
#define ORTE_RML_UPDATE_CMD 1
/**
* Flags to send/recv
*/

14
orte/mca/schema/schema_types.h
Просмотреть файл

@ -88,6 +88,7 @@
#define ORTE_JOB_IOF_KEY "orte-job-iof"
#define ORTE_JOB_STATE_KEY "orte-job-state"
#define ORTE_JOB_MAPPING_MODE_KEY "orte-job-mapping-mode"
#define ORTE_JOB_PARENT_JOBID_KEY "orte-job-parent-jobid"
/* PROCESS specific keys */
#define ORTE_PROC_NAME_KEY "orte-proc-name"
@ -101,6 +102,7 @@
#define ORTE_PROC_NUM_ALIVE "orte-proc-num-alive"
#define ORTE_PROC_NUM_ABORTED "orte-proc-num-aborted"
#define ORTE_PROC_NUM_FAILED_START "orte-proc-num-failed-start"
#define ORTE_PROC_NUM_AT_ORTE_STARTUP "orte-proc-num-orte-startup"
#define ORTE_PROC_NUM_AT_INIT "orte-proc-num-init"
#define ORTE_PROC_NUM_LAUNCHED "orte-proc-num-launched"
#define ORTE_PROC_NUM_RUNNING "orte-proc-num-running"
@ -122,6 +124,15 @@
/*
* ORTE-wide names for specific system triggers and subscriptions
*/
/* trigger during orte_init to allow exchange of ORTE info within a job */
#define ORTE_STARTUP_TRIGGER "orte-startup-trig"
/* subscription to allow exchange of ORTE info between jobs */
#define ORTE_XCONNECT_SUB "orte-xconnect-sub"
/* standard subscription required for xconnect */
#define ORTE_PARENT_JOBID_SUBSCRIPTION "orte-parent-jobid"
/* process state triggers - fire when all procs reach corresponding point */
#define ORTE_ALL_INIT_TRIGGER "orte-init-trig"
#define ORTE_ALL_LAUNCHED_TRIGGER "orte-launch-trig"
#define ORTE_ALL_RUNNING_TRIGGER "orte-running-trig"
@ -129,12 +140,13 @@
#define ORTE_STG2_TRIGGER "orte-stage2"
#define ORTE_STG3_TRIGGER "orte-stage3"
#define ORTE_NUM_FINALIZED_TRIGGER "orte-num-finalized"
#define ORTE_NUM_ABORTED_TRIGGER "orte-num-aborted"
#define ORTE_NUM_TERMINATED_TRIGGER "orte-num-terminated"
#define ORTE_JOB_CKPT_STATE_TRIGGER "orte-job-ckpt-trig"
#define ORTE_PROC_CKPT_STATE_TRIGGER "orte-proc-ckpt-trig"
/* exception triggers - fired when one process meets condition */
#define ORTE_NUM_ABORTED_TRIGGER "orte-num-aborted"
#define ORTE_FAILED_TO_START_TRIGGER "orte-failed-start-trig"
/*

10
orte/mca/smr/base/smr_base_set_proc_state.c
Просмотреть файл

@ -90,7 +90,8 @@ int orte_smr_base_set_proc_state(orte_process_name_t *proc,
OBJ_RELEASE(value);
/* check to see if we need to increment orte-standard counters */
if (ORTE_PROC_STATE_LAUNCHED == state ||
if (ORTE_PROC_ORTE_STARTUP_COMPLETE == state ||
ORTE_PROC_STATE_LAUNCHED == state ||
ORTE_PROC_STATE_AT_STG1 == state ||
ORTE_PROC_STATE_AT_STG2 == state ||
ORTE_PROC_STATE_AT_STG3 == state ||
@ -123,6 +124,13 @@ int orte_smr_base_set_proc_state(orte_process_name_t *proc,
/* see which state we are in - let that determine the counter */
switch (state) {
case ORTE_PROC_ORTE_STARTUP_COMPLETE:
if (ORTE_SUCCESS != (rc = orte_gpr.create_keyval(&(value->keyvals[0]), ORTE_PROC_NUM_AT_ORTE_STARTUP, ORTE_UNDEF, NULL))) {
ORTE_ERROR_LOG(rc);
goto cleanup;
}
break;
case ORTE_PROC_STATE_LAUNCHED:
if (ORTE_SUCCESS != (rc = orte_gpr.create_keyval(&(value->keyvals[0]), ORTE_PROC_NUM_LAUNCHED, ORTE_UNDEF, NULL))) {
ORTE_ERROR_LOG(rc);

29
orte/mca/smr/base/smr_base_trig_init_fns.c
Просмотреть файл

@ -37,7 +37,6 @@
#include "orte/mca/smr/base/smr_private.h"
int orte_smr_base_init_job_stage_gates(orte_jobid_t job,
orte_gpr_trigger_cb_fn_t cbfunc,
void *user_tag)
@ -46,40 +45,45 @@ int orte_smr_base_init_job_stage_gates(orte_jobid_t job,
orte_std_cntr_t zero=0;
int rc, num_start_routing;
orte_gpr_value_t *value;
char *segment, *trig_name, *tokens[2], *trig_keys[2];
orte_gpr_trigger_id_t id;
orte_gpr_trigger_action_t trig_mode, trig_mode_routed;
char* keys[] = {
/* changes to this ordering need to be reflected in code below */
/* We need to set up counters for all the defined ORTE process states, even though
* the launch system doesn't actually use them all. This must be done so that
* user-defined callbacks can be generated - otherwise, they won't happen!
*/
* a given launch system may not actually use them all. This must be done so that
* user-defined callbacks can be generated - otherwise, they won't happen!
*/
ORTE_PROC_NUM_AT_INIT,
ORTE_PROC_NUM_LAUNCHED,
ORTE_PROC_NUM_RUNNING,
ORTE_PROC_NUM_TERMINATED,
/* the following stage gates need data routed through them */
ORTE_PROC_NUM_AT_ORTE_STARTUP,
ORTE_PROC_NUM_AT_STG1,
ORTE_PROC_NUM_AT_STG2,
ORTE_PROC_NUM_AT_STG3,
ORTE_PROC_NUM_FINALIZED
};
char* trig_names[] = {
/* changes to this ordering need to be reflected in code below */
/* this ordering needs to be identical to that in the array above! */
ORTE_ALL_INIT_TRIGGER,
ORTE_ALL_LAUNCHED_TRIGGER,
ORTE_ALL_RUNNING_TRIGGER,
ORTE_NUM_TERMINATED_TRIGGER,
/* the following triggers need data routed through them */
ORTE_STARTUP_TRIGGER,
ORTE_STG1_TRIGGER,
ORTE_STG2_TRIGGER,
ORTE_STG3_TRIGGER,
ORTE_NUM_FINALIZED_TRIGGER,
};
char *segment, *trig_name, *tokens[2], *trig_keys[2];
orte_gpr_trigger_id_t id;
orte_gpr_trigger_action_t trig_mode, trig_mode_routed;
num_counters = sizeof(keys)/sizeof(keys[0]);
num_named_trigs= sizeof(trig_names)/sizeof(trig_names[0]);
/* the index where the triggers that need data routed through them begin */
num_start_routing = 4;
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&segment, job))) {
@ -87,7 +91,7 @@ int orte_smr_base_init_job_stage_gates(orte_jobid_t job,
return rc;
}
/* setup the counters */
/* setup the counters - set initial values to 0 */
if (ORTE_SUCCESS != (rc = orte_gpr.create_value(&value,
ORTE_GPR_OVERWRITE | ORTE_GPR_TOKENS_XAND | ORTE_GPR_KEYS_OR,
segment, num_counters, 1))) {
@ -113,7 +117,7 @@ int orte_smr_base_init_job_stage_gates(orte_jobid_t job,
return rc;
}
OBJ_RELEASE(value);
/*** DEFINE STAGE GATE STANDARD TRIGGERS ***/
/* The standard triggers will return the trigger counters so that we
* can get required information for notifying processes. Other
@ -373,6 +377,7 @@ int orte_smr_base_job_stage_gate_subscribe(orte_jobid_t job,
orte_gpr_subscription_id_t id;
/** the order of the next three definitions MUST match */
orte_proc_state_t state[] = {
ORTE_PROC_ORTE_STARTUP_COMPLETE,
ORTE_PROC_STATE_INIT,
ORTE_PROC_STATE_LAUNCHED,
ORTE_PROC_STATE_RUNNING,
@ -383,6 +388,7 @@ int orte_smr_base_job_stage_gate_subscribe(orte_jobid_t job,
ORTE_PROC_STATE_TERMINATED
};
char* keys[] = {
ORTE_PROC_NUM_AT_ORTE_STARTUP,
ORTE_PROC_NUM_AT_INIT,
ORTE_PROC_NUM_LAUNCHED,
ORTE_PROC_NUM_RUNNING,
@ -393,6 +399,7 @@ int orte_smr_base_job_stage_gate_subscribe(orte_jobid_t job,
ORTE_PROC_NUM_TERMINATED
};
char* trig_names[] = {
ORTE_STARTUP_TRIGGER,
ORTE_ALL_INIT_TRIGGER,
ORTE_ALL_LAUNCHED_TRIGGER,
ORTE_ALL_RUNNING_TRIGGER,

8
orte/mca/smr/smr_types.h
Просмотреть файл

@ -51,8 +51,10 @@ typedef uint16_t orte_proc_state_t;
#define ORTE_PROC_STATE_TERMINATED 0x0080 /* process has terminated and is no longer running */
#define ORTE_PROC_STATE_ABORTED 0x0100 /* process aborted */
#define ORTE_PROC_STATE_FAILED_TO_START 0x0200 /* process failed to start */
#define ORTE_PROC_ORTE_STARTUP_COMPLETE 0x0400 /* process has completed orte_init */
/* this process has been ordered to "die", but may not have completed it yet. Don't tell it again */
#define ORTE_PROC_STATE_ABORT_ORDERED 0x0400
#define ORTE_PROC_STATE_ABORT_ORDERED 0x0800
/** define some common shorthands for when we want to be alerted */
#define ORTE_PROC_STATE_ALL 0xffff /* alert on ALL triggers */
@ -76,8 +78,10 @@ typedef uint16_t orte_job_state_t;
#define ORTE_JOB_STATE_TERMINATED 0x0080 /* all processes have terminated and is no longer running */
#define ORTE_JOB_STATE_ABORTED 0x0100 /* at least one process aborted, causing job to abort */
#define ORTE_JOB_STATE_FAILED_TO_START 0x0200 /* at least one process failed to start */
#define ORTE_JOB_ORTE_STARTUP_COMPLETE 0x0400 /* all processes have completed orte_init */
/* the processes in this job have been ordered to "die", but may not have completed it yet. Don't order it again */
#define ORTE_JOB_STATE_ABORT_ORDERED 0x0400
#define ORTE_JOB_STATE_ABORT_ORDERED 0x0800
/**
* Node State, corresponding to the ORTE_NODE_STATE_* #defines,

4
orte/runtime/orte_init.c
Просмотреть файл

@ -35,7 +35,7 @@
* @retval ORTE_ERROR Upon failure.
*/
int orte_init(bool infrastructure)
int orte_init(bool infrastructure, bool barrier)
{
int rc;
@ -54,7 +54,7 @@ int orte_init(bool infrastructure)
return rc;
}
if (ORTE_SUCCESS != (rc = orte_system_init(infrastructure))) {
if (ORTE_SUCCESS != (rc = orte_system_init(infrastructure, barrier))) {
ORTE_ERROR_LOG(rc);
return rc;
}

4
orte/runtime/orte_init_stage1.c
Просмотреть файл

@ -579,7 +579,9 @@ int orte_init_stage1(bool infrastructure)
/* initialize the rml module so it can open its interfaces - this
* is needed so that we can get a uri for ourselves if we are an
* HNP
* HNP. Note that this function creates listeners to the HNP
* (for non-HNP procs) - if we are an HNP, it sets up the listener
* for incoming connections from daemons and application procs.
*/
if (ORTE_SUCCESS != (ret = orte_rml.init())) {
ORTE_ERROR_LOG(ret);

35
orte/runtime/orte_init_stage2.c
Просмотреть файл

@ -27,6 +27,7 @@
#include "orte/mca/errmgr/errmgr.h"
#include "orte/runtime/params.h"
#include "orte/mca/rml/rml.h"
#include "orte/mca/rml/base/base.h"
#include "orte/mca/ns/ns.h"
#include "orte/mca/gpr/gpr.h"
#include "orte/mca/iof/base/base.h"
@ -35,7 +36,7 @@
#include "orte/runtime/runtime.h"
int orte_init_stage2()
int orte_init_stage2(char *trigger)
{
int ret;
char *error_str = NULL;
@ -74,6 +75,27 @@ int orte_init_stage2()
goto return_error;
}
/* register our contact info with the HNP.
* NOTE: it is critical that this be done in stage2 so that
* the embedded GPR actions can be "trapped" in a compound
* command for later transmission to the HNP
*/
if (ORTE_SUCCESS != (ret = orte_rml.register_contact_info())) {
ORTE_ERROR_LOG(ret);
error_str = "orte_rml.register_contact_info";
goto return_error;
}
/* register a subscription to share RML contact info
* between all processes in this job when the provided
* trigger fires
*/
if (ORTE_SUCCESS != (ret = orte_rml.register_subscription(ORTE_PROC_MY_NAME->jobid, trigger))) {
ORTE_ERROR_LOG(ret);
error_str = "orte_rml.register_subscription";
goto return_error;
}
/*
* Initalize the CR setup
* Note: Always do this, even in non-FT builds.
@ -88,7 +110,16 @@ int orte_init_stage2()
/* Since we are now finished with init, change the state to running */
orte_universe_info.state = ORTE_UNIVERSE_STATE_RUNNING;
/* All done */
/* startup the receive if we are not the HNP */
if (!orte_process_info.seed) {
if (ORTE_SUCCESS != (ret = orte_rml_base_comm_start())) {
ORTE_ERROR_LOG(ret);
error_str = "orte_rml_base_comm_start";
goto return_error;
}
}
/* All done */
orte_initialized = true;
return ORTE_SUCCESS;

35
orte/runtime/orte_system_init.c
Просмотреть файл

@ -24,7 +24,11 @@
#include "opal/runtime/opal.h"
#include "orte/mca/gpr/gpr.h"
#include "orte/mca/smr/smr.h"
#include "orte/mca/errmgr/errmgr.h"
#include "orte/mca/rml/rml.h"
#include "orte/runtime/runtime.h"
/**
@ -34,7 +38,7 @@
* @retval ORTE_ERROR Upon failure.
*/
int orte_system_init(bool infrastructure)
int orte_system_init(bool infrastructure, bool barrier)
{
int rc;
@ -43,10 +47,37 @@ int orte_system_init(bool infrastructure)
return rc;
}
if (ORTE_SUCCESS != (rc = orte_init_stage2())) {
/* begin recording registry actions */
if (ORTE_SUCCESS != (rc = orte_gpr.begin_compound_cmd())) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (ORTE_SUCCESS != (rc = orte_init_stage2(ORTE_STARTUP_TRIGGER))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* indicate we are at the ORTE_STARTUP_COMPLETE state */
if (ORTE_SUCCESS != (rc = orte_smr.set_proc_state(ORTE_PROC_MY_NAME,
ORTE_PROC_ORTE_STARTUP_COMPLETE, 0))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* send the information */
if (ORTE_SUCCESS != (rc = orte_gpr.exec_compound_cmd())) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* if we want to wait for receipt of info and release, do so here */
if (barrier) {
if (ORTE_SUCCESS != (rc = orte_rml.xcast_gate(orte_gpr.deliver_notify_msg))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
return ORTE_SUCCESS;
}

50
orte/runtime/runtime.h
Просмотреть файл

@ -38,33 +38,12 @@
#include "orte/util/univ_info.h"
#include "orte/mca/ns/ns.h"
/* constants for spawn constraints */
/* some convenience definitions for code clarity */
#define ORTE_INFRASTRUCTURE true
#define ORTE_NON_INFRASTRUCTURE false
/** Spawn constraint - require multi-cell support. The selected spawn
system must be capable of starting across multiple cells. This
allows multiple pcms to be used to satisfy a single resource
allocation request */
#define OMPI_RTE_SPAWN_MULTI_CELL 0x0001
/** Spawn constraint - require ability to launch daemons. The
selected spawn system must be capable of starting daemon process.
Setting this flag will result in a spawn service that does not
neccessarily provide process monitoring or standard I/O
forwarding. The calling process may exit before all children have
exited. */
#define OMPI_RTE_SPAWN_DAEMON 0x0002
/** Spawn constraint - require quality of service support. The
selected spawn system must provide I/O forwarding, quick process
shutdown, and process status monitoring. */
#define OMPI_RTE_SPAWN_HIGH_QOS 0x0004
/** Spawn constraint - caller is an MPI process. The caller is an MPI
application (has called MPI_Init). This should be used only for
MPI_COMM_SPAWN and MPI_COMM_SPAWN_MULTIPLE. The calling process
will follow the semantics of the MPI_COMM_SPAWN_* functions. */
#define OMPI_RTE_SPAWN_FROM_MPI 0x0008
/** Spawn constraint - require ability to launch either MPMD (hence
the name) applications or applications with specific placement of
processes. */
#define OMPI_RTE_SPAWN_MPMD 0x0010
#define ORTE_USE_BARRIER true
#define ORTE_NON_BARRIER false
#if defined(c_plusplus) || defined(__cplusplus)
extern "C" {
@ -96,10 +75,10 @@ ORTE_DECLSPEC int orte_abort(int status, bool report);
* @param infrastructure Whether we are ORTE infrastructure or an ORTE
* application
*/
ORTE_DECLSPEC int orte_init(bool infrastructure);
ORTE_DECLSPEC int orte_system_init(bool infrastructure);
ORTE_DECLSPEC int orte_init(bool infrastructure, bool barrier);
ORTE_DECLSPEC int orte_system_init(bool infrastructure, bool barrier);
ORTE_DECLSPEC int orte_init_stage1(bool infrastructure);
ORTE_DECLSPEC int orte_init_stage2(void);
ORTE_DECLSPEC int orte_init_stage2(char *trigger);
/**
* Initialize parameters for ORTE.
@ -160,21 +139,14 @@ ORTE_DECLSPEC int orte_monitor_procs_unregistered(void);
* is to be stored
*
* @retval ORTE_SUCCESS Universe found and connection accepted
* @retval OMPI_NO_CONNECTION_ALLOWED Universe found, but not persistent or
* @retval ORTE_ERR_NO_CONNECTION_ALLOWED Universe found, but not persistent or
* restricted to local scope
* @retval OMPI_CONNECTION_FAILED Universe found, but connection attempt
* @retval ORTE_ERR_CONNECTION_FAILED Universe found, but connection attempt
* failed. Probably caused by unclean termination of the universe seed
* daemon.
* @retval OMPI_CONNECTION_REFUSED Universe found and contact made, but
* universe refused to allow connection.
*/
ORTE_DECLSPEC int orte_universe_exists(orte_universe_t *univ);
/**
* Setup I/O forwarding.
*/
ORTE_DECLSPEC int ompi_rte_init_io(void);
/**
* Establish a Head Node Process on a cluster's front end
*/
@ -192,4 +164,4 @@ ORTE_DECLSPEC void orte_universe_clean_directories(char *my_universe, int verb
}
#endif
#endif /* OMPI_RUNTIME_H */
#endif /* RUNTIME_H */

2
orte/test/system/Makefile
Просмотреть файл

@ -1,4 +1,4 @@
PROGS = no_op sigusr_trap spin orte_nodename orte_proc_subscribe orte_stage_gate orte_spawn orte_loop_spawn orte_loop_child orte_abort get_limits
PROGS = no_op sigusr_trap spin orte_nodename orte_proc_subscribe orte_stage_gate orte_spawn orte_loop_spawn orte_loop_child orte_abort get_limits orte_ring spawn_child
all: $(PROGS)

2
orte/test/system/orte_loop_child.c
Просмотреть файл

@ -7,7 +7,7 @@ int main( int argc, char **argv )
{
int rc;
if (ORTE_SUCCESS != (rc = orte_init(false))) {
if (ORTE_SUCCESS != (rc = orte_init(ORTE_NON_INFRASTRUCTURE, ORTE_NON_BARRIER))) {
fprintf(stderr, "couldn't init orte - error code %d\n", rc);
return rc;
}

3
orte/test/system/orte_loop_spawn.c
Просмотреть файл

@ -8,6 +8,7 @@
#include "orte/mca/errmgr/errmgr.h"
#include "orte/mca/ras/ras_types.h"
#include "orte/mca/rmaps/rmaps_types.h"
#include "orte/runtime/runtime.h"
bool waitexit;
opal_mutex_t lock;
@ -31,7 +32,7 @@ int main(int argc, char* argv[])
OBJ_CONSTRUCT(&cond, opal_condition_t);
waitexit = false;
if (0 > (rc = orte_init(false))) {
if (0 > (rc = orte_init(ORTE_NON_INFRASTRUCTURE, ORTE_NON_BARRIER))) {
fprintf(stderr, "couldn't init orte - error code %d\n", rc);
return rc;
}

3
orte/test/system/orte_nodename.c
Просмотреть файл

@ -8,6 +8,7 @@
#include <stdio.h>
#include "orte/util/proc_info.h"
#include "orte/runtime/runtime.h"
int main(int argc, char* argv[])
{
@ -15,7 +16,7 @@ int main(int argc, char* argv[])
char hostname[512];
pid_t pid;
if (0 > (rc = orte_init())) {
if (0 > (rc = orte_init(ORTE_NON_INFRASTRUCTURE, ORTE_USE_BARRIER))) {
fprintf(stderr, "orte_nodename: couldn't init orte - error code %d\n", rc);
return rc;
}

132
orte/test/system/orte_ring.c Обычный файл
Просмотреть файл

@ -0,0 +1,132 @@
#include <stdio.h>
#include <signal.h>
#include "orte/orte_types.h"
#include "orte/mca/ns/ns.h"
#include "orte/mca/rml/rml.h"
#include "orte/mca/oob/base/base.h"
#include "orte/runtime/runtime.h"
#define MY_TAG 12345
#define MAX_COUNT 20
# define false 0
# define true 1
int
main(int argc, char *argv[]){
int counter = 0;
char * my_name = NULL;
char * my_right_peer = NULL;
char * my_left_peer = NULL;
orte_process_name_t right_peer_orte_name;
orte_process_name_t left_peer_orte_name;
int num_peers = 0;
struct iovec msg;
int ret;
/*
* Init
*/
orte_init(ORTE_NON_INFRASTRUCTURE, ORTE_USE_BARRIER);
num_peers = orte_process_info.num_procs;
/*
* Construct Peer name in a ring
*/
right_peer_orte_name.cellid = orte_process_info.my_name->cellid;
right_peer_orte_name.jobid = orte_process_info.my_name->jobid;
right_peer_orte_name.vpid = orte_process_info.my_name->vpid + 1;
if( right_peer_orte_name.vpid >= num_peers ) {
right_peer_orte_name.vpid = 0;
}
left_peer_orte_name.cellid = orte_process_info.my_name->cellid;
left_peer_orte_name.jobid = orte_process_info.my_name->jobid;
left_peer_orte_name.vpid = orte_process_info.my_name->vpid - 1;
if( orte_process_info.my_name->vpid == 0 ) {
left_peer_orte_name.vpid = num_peers - 1;
}
/*
* Get the string version
*/
orte_ns.get_proc_name_string(&my_name, orte_process_info.my_name);
orte_ns.get_proc_name_string(&my_right_peer, &right_peer_orte_name);
orte_ns.get_proc_name_string(&my_left_peer, &left_peer_orte_name);
printf("My name is: %s -- PID %d\tMy Left Peer is %s\tMy Right Peer is %s\n", my_name, getpid(), my_left_peer, my_right_peer);
/*
* Rank 0 starts the ring...
*/
if( orte_process_info.my_name->vpid == 0) {
/* update value */
counter = 1;
/* Send to right */
msg.iov_base = (void *) &counter;
msg.iov_len = sizeof(counter);
printf("%s) Send Counter (%d) to peer (%s)\n", my_name, counter, my_right_peer);
if( 0 > orte_rml.send(&right_peer_orte_name,
&msg,
1,
MY_TAG,
0) ) {
printf("error... %d\n", __LINE__);;
}
}
while (counter <= MAX_COUNT ) {
int *cnt;
/* Receive from left */
printf("%s) Waiting to Recv Counter from peer (%s)\n", my_name, my_left_peer);
msg.iov_base = NULL;
msg.iov_len = 0;
if( 0 > orte_rml.recv(&left_peer_orte_name,
&msg,
1,
MY_TAG,
MCA_OOB_ALLOC) ) {
printf("error A... %d\n", __LINE__);
}
cnt = (int *) msg.iov_base;
counter = *cnt;
if(counter > MAX_COUNT)
break;
/* Update */
printf("%s) Recv %d ... Send %d\n", my_name, counter, counter + 1);
if( orte_process_info.my_name->vpid == 0 ) {
sleep(2);
}
counter++;
/* Send to right */
msg.iov_base = (void *) &counter;
msg.iov_len = sizeof(counter);
printf("%s) Send Counter (%d) to peer (%s)\n", my_name, counter, my_right_peer);
if( 0 > orte_rml.send(&right_peer_orte_name,
&msg,
1,
MY_TAG,
0) ) {
printf("error B... %d\n", __LINE__);;
}
}
cleanup:
orte_finalize();
return 0;
}

41
orte/test/system/orte_spawn.c
Просмотреть файл

@ -11,9 +11,14 @@
#include "orte/util/proc_info.h"
#include "orte/mca/rmgr/rmgr.h"
#include "orte/mca/ns/ns.h"
#include "orte/mca/rml/rml.h"
#include "orte/mca/errmgr/errmgr.h"
#include "orte/mca/ras/ras_types.h"
#include "orte/mca/rmaps/rmaps_types.h"
#include "orte/runtime/runtime.h"
#define MY_TAG 12345
bool waitexit;
opal_mutex_t lock;
@ -31,20 +36,24 @@ int main(int argc, char* argv[])
opal_list_item_t *item;
char cwd[1024];
bool spawned;
orte_proc_state_t state;
orte_vpid_t i, range;
orte_process_name_t name;
struct iovec msg;
OBJ_CONSTRUCT(&lock, opal_mutex_t);
OBJ_CONSTRUCT(&cond, opal_condition_t);
waitexit = false;
if (0 > (rc = orte_init(false))) {
if (0 > (rc = orte_init(ORTE_NON_INFRASTRUCTURE, ORTE_NON_BARRIER))) {
fprintf(stderr, "couldn't init orte - error code %d\n", rc);
return rc;
}
/* create an app_context that defines the app to be run */
app = OBJ_NEW(orte_app_context_t);
app->app = strdup("orte_nodename");
opal_argv_append_nosize(&app->argv, "orte_nodename");
app->app = strdup("spawn_child");
opal_argv_append_nosize(&app->argv, "spawn_child");
app->num_procs = 3;
getcwd(cwd, sizeof(cwd));
@ -83,6 +92,18 @@ int main(int argc, char* argv[])
return rc;
}
/* tell the RTE that we want to be cross-connected to the children so we receive
* their ORTE-level information - e.g., OOB contact info - when they
* reach the STG1 stage gate
*/
state = ORTE_PROC_ORTE_STARTUP_COMPLETE;
if (ORTE_SUCCESS != (rc = orte_rmgr.add_attribute(&attributes, ORTE_RMGR_XCONNECT_AT_SPAWN,
ORTE_PROC_STATE, &state,
ORTE_RMGR_ATTR_OVERRIDE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* launch the job, specifing a callback function so we get notified
* when it completes
*/
@ -104,6 +125,20 @@ int main(int argc, char* argv[])
/* done with the application */
OBJ_RELEASE(app);
/* send messages to all children - this will verify that we know their contact info */
orte_ns.get_vpid_range(job, &range);
name.cellid = ORTE_PROC_MY_NAME->cellid;
name.jobid = job;
i = 1;
msg.iov_base = (void *) &i;
msg.iov_len = sizeof(i);
for (i=0; i < range; i++) {
name.vpid = i;
if (0 > orte_rml.send(&name, &msg, 1, MY_TAG, 0)) {
printf("error %d\n", __LINE__);
}
}
/* Wait for the app to complete */
if (spawned) {
OPAL_THREAD_LOCK(&lock);

64
orte/test/system/orte_stage_gate.c
Просмотреть файл

@ -45,25 +45,39 @@ int main(int argc, char* argv[])
}
/* Setup ORTE stage 1, note that we are not infrastructre */
if (ORTE_SUCCESS != (rc = orte_init_stage1(false))) {
if (ORTE_SUCCESS != (rc = orte_init_stage1(ORTE_NON_INFRASTRUCTURE))) {
error = "orte_init_stage1 failed";
goto error;
}
/* setup a compound command to capture info to be rcurned in the xcast */
/* begin recording registry actions */
if (ORTE_SUCCESS != (rc = orte_gpr.begin_compound_cmd())) {
ORTE_ERROR_LOG(rc);
error = "orte_gpr.begin_compound_cmd failed";
error = "begin compound cmd failed";
goto error;
}
/* Now do the things that hit the registry */
if (ORTE_SUCCESS != (rc = orte_init_stage2())) {
if (ORTE_SUCCESS != (rc = orte_init_stage2(ORTE_STARTUP_TRIGGER))) {
ORTE_ERROR_LOG(rc);
error = "orte_init_stage2 failed";
goto error;
}
/* indicate we are at the ORTE_STARTUP_COMPLETE state */
if (ORTE_SUCCESS != (rc = orte_smr.set_proc_state(ORTE_PROC_MY_NAME,
ORTE_PROC_ORTE_STARTUP_COMPLETE, 0))) {
ORTE_ERROR_LOG(rc);
error = "set proc state failed";
goto error;
}
/* send the information */
if (ORTE_SUCCESS != (rc = orte_gpr.exec_compound_cmd())) {
ORTE_ERROR_LOG(rc);
error = "exec compound cmd failed";
goto error;
}
/* check for timing request - get stop time and report elapsed time if so */
if (timing) {
gettimeofday(&ortestop, NULL);
@ -74,56 +88,20 @@ int main(int argc, char* argv[])
gettimeofday(&ortestart, NULL);
}
/* Let system know we are at STG1 Barrier */
if (ORTE_SUCCESS != (rc = orte_smr.set_proc_state(orte_process_info.my_name,
ORTE_PROC_STATE_AT_STG1, 0))) {
ORTE_ERROR_LOG(rc);
error = "set process state failed";
goto error;
}
/* check for timing request - get stop time and report elapsed time if so */
if (timing) {
gettimeofday(&ortestop, NULL);
opal_output(0, "[%ld]: time from completion of orte_init to exec_compound_cmd %ld usec",
(long)ORTE_PROC_MY_NAME->vpid,
(long int)((ortestop.tv_sec - ortestart.tv_sec)*1000000 +
(ortestop.tv_usec - ortestart.tv_usec)));
gettimeofday(&ortestart, NULL);
}
if (ORTE_SUCCESS != (rc = orte_gpr.exec_compound_cmd())) {
ORTE_ERROR_LOG(rc);
error = "orte_gpr.exec_compound_cmd failed";
goto error;
}
/* check for timing request - get stop time and report elapsed time if so */
if (timing) {
gettimeofday(&ortestop, NULL);
opal_output(0, "[%ld]: time to execute compound command %ld usec",
(long)ORTE_PROC_MY_NAME->vpid,
(long int)((ortestop.tv_sec - ortestart.tv_sec)*1000000 +
(ortestop.tv_usec - ortestart.tv_usec)));
gettimeofday(&ortestart, NULL);
}
/* FIRST BARRIER - WAIT FOR MSG FROM RMGR_PROC_STAGE_GATE_MGR TO ARRIVE */
if (ORTE_SUCCESS != (rc = orte_rml.xcast(ORTE_PROC_MY_NAME->jobid,
NULL, orte_gpr.deliver_notify_msg))) {
if (ORTE_SUCCESS != (rc = orte_rml.xcast_gate(orte_gpr.deliver_notify_msg))) {
ORTE_ERROR_LOG(rc);
error = "failed to see all procs register\n";
goto error;
}
/* check for timing request - get start time */
/* check for timing request - report time */
if (timing) {
gettimeofday(&ortestop, NULL);
opal_output(0, "[%ld]: time to execute xcast %ld usec",
(long)ORTE_PROC_MY_NAME->vpid,
(long int)((ortestop.tv_sec - ortestart.tv_sec)*1000000 +
(ortestop.tv_usec - ortestart.tv_usec)));
gettimeofday(&ortestart, NULL);
}
gethostname(hostname, 512);

2
orte/test/system/sigusr_trap.c
Просмотреть файл

@ -71,7 +71,7 @@ int main(int argc, char* argv[])
exit(1);
}
if (ORTE_SUCCESS != (rc = orte_init(true))) {
if (ORTE_SUCCESS != (rc = orte_init(ORTE_NON_INFRASTRUCTURE, ORTE_NON_BARRIER))) {
fprintf(stderr, "couldn't complete init - error code %d\n", rc);
exit(1);
}

41
orte/test/system/spawn_child.c Обычный файл
Просмотреть файл

@ -0,0 +1,41 @@
/* -*- C -*-
*
* $HEADER$
*
* The most basic of MPI applications
*/
#include <stdio.h>
#include "orte/util/proc_info.h"
#include "orte/runtime/runtime.h"
#include "orte/mca/rml/rml.h"
#include "orte/mca/oob/base/base.h"
#define MY_TAG 12345
int main(int argc, char* argv[])
{
int rc;
char hostname[512];
pid_t pid;
struct iovec msg;
if (0 > (rc = orte_init(ORTE_NON_INFRASTRUCTURE, ORTE_USE_BARRIER))) {
fprintf(stderr, "orte_nodename: couldn't init orte - error code %d\n", rc);
return rc;
}
gethostname(hostname, 512);
pid = getpid();
/* wait for message from our parent */
if (0 > orte_rml.recv(ORTE_NAME_WILDCARD, &msg, 1, MY_TAG, MCA_OOB_ALLOC)) {
printf("error at line %d\n", __LINE__);
}
printf("CHILD [%lu,%lu,%lu] Node %s Pid %ld\n", ORTE_NAME_ARGS(orte_process_info.my_name), hostname, (long)pid);
orte_finalize();
return 0;
}

2
orte/test/unit/dss/Makefile
Просмотреть файл

@ -1,4 +1,4 @@
PROGS = dss_buffer dss_cmp dss_copy dss_inc_dec dss_print dss_release dss_set_get dss_size
PROGS = dss_buffer dss_payload dss_cmp dss_copy dss_inc_dec dss_print dss_release dss_set_get dss_size
all: $(PROGS)

3
orte/test/unit/dss/dss_buffer.c
Просмотреть файл

@ -34,6 +34,7 @@
#include "opal/runtime/opal.h"
#include "orte/util/proc_info.h"
#include "orte/mca/errmgr/errmgr.h"
#include "orte/runtime/runtime.h"
#include "orte/dss/dss.h"
@ -60,7 +61,7 @@ int main (int argc, char* argv[])
{
int ret;
orte_init(true);
orte_init(ORTE_INFRASTRUCTURE, ORTE_NON_BARRIER);
test_out = stderr;

321
orte/test/unit/dss/dss_payload.c Обычный файл
Просмотреть файл

@ -0,0 +1,321 @@
/*
* Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2005 The University of Tennessee and The University
* of Tennessee Research Foundation. All rights
* reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
#include "orte_config.h"
#include "orte/orte_constants.h"
#include "orte/orte_types.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#include "opal/runtime/opal.h"
#include "orte/util/proc_info.h"
#include "orte/mca/errmgr/errmgr.h"
#include "orte/runtime/runtime.h"
#include "orte/dss/dss.h"
#define NUM_ITERS 100
#define NUM_ELEMS 1024
static bool test1(void); /* verify dss_copy_payload */
static bool test2(void); /* verify dss_xfer_payload */
FILE *test_out;
int main (int argc, char* argv[])
{
int ret;
orte_init(ORTE_INFRASTRUCTURE, ORTE_NON_BARRIER);
test_out = stderr;
/* run the tests */
fprintf(test_out, "executing test1\n");
if (test1()) {
fprintf(test_out, "Test1 succeeded\n");
}
else {
fprintf(test_out, "Test1 failed\n");
}
fprintf(test_out, "executing test2\n");
if (test2()) {
fprintf(test_out, "Test2 succeeded\n");
}
else {
fprintf(test_out, "Test2 failed\n");
}
orte_dss_close();
opal_finalize();
return(0);
}
static bool test1(void) /* verify dss_copy_payload */
{
orte_buffer_t *bufA, *bufB;
int rc;
int32_t i;
int16_t src[NUM_ELEMS];
int16_t dst[NUM_ELEMS];
int32_t src32[NUM_ELEMS];
int32_t dst32[NUM_ELEMS];
/* init src arrays */
for (i=0; i < NUM_ELEMS; i++) {
src[i] = i;
src32[i] = 132 * i;
}
/* init A */
bufA = OBJ_NEW(orte_buffer_t);
if (NULL == bufA) {
fprintf(test_out, "orte_buffer failed init in OBJ_NEW\n");
return false;
}
orte_dss.set_buffer_type(bufA, ORTE_DSS_BUFFER_NON_DESC);
/* pack something in A */
for (i=0;i<NUM_ITERS;i++) {
rc = orte_dss.pack(bufA, src, NUM_ELEMS, ORTE_INT16);
if (ORTE_SUCCESS != rc) {
fprintf(test_out, "orte_dss.pack failed with return code %d\n", rc);
return(false);
}
}
/* setup bufB */
bufB = OBJ_NEW(orte_buffer_t);
if (NULL == bufB) {
fprintf(test_out, "orte_buffer failed init in OBJ_NEW\n");
return false;
}
orte_dss.set_buffer_type(bufB, ORTE_DSS_BUFFER_NON_DESC);
/* pack something in B */
for (i=0;i<NUM_ITERS;i++) {
rc = orte_dss.pack(bufB, src32, NUM_ELEMS, ORTE_INT32);
if (ORTE_SUCCESS != rc) {
fprintf(test_out, "orte_dss.pack failed with return code %d\n", rc);
return(false);
}
}
/* copy payload to bufB */
if (ORTE_SUCCESS != (rc = orte_dss.copy_payload(bufB, bufA))) {
fprintf(test_out, "orte_dss.copy_payload failed with return code %d\n", rc);
return(false);
}
/* pack some more stuff in B */
for (i=0;i<NUM_ITERS;i++) {
rc = orte_dss.pack(bufB, src32, NUM_ELEMS, ORTE_INT32);
if (ORTE_SUCCESS != rc) {
fprintf(test_out, "orte_dss.pack failed with return code %d\n", rc);
return(false);
}
}
/* validate the results */
for (i=0; i<NUM_ITERS; i++) {
int j;
orte_std_cntr_t count;
for(j=0; j<NUM_ELEMS; j++)
dst32[j] = -1;
count = NUM_ELEMS;
rc = orte_dss.unpack(bufB, dst32, &count, ORTE_INT32);
if (ORTE_SUCCESS != rc || count != NUM_ELEMS) {
fprintf(test_out, "orte_dss.unpack of dest buffer failed with return code %d\n", rc);
return(false);
}
for(j=0; j<NUM_ELEMS; j++) {
if(src32[j] != dst32[j]) {
fprintf(test_out, "test2: invalid results from unpack of dest buffer\n");
return(false);
}
}
}
for (i=0; i<NUM_ITERS; i++) {
int j;
orte_std_cntr_t count;
for(j=0; j<NUM_ELEMS; j++)
dst[j] = -1;
count = NUM_ELEMS;
rc = orte_dss.unpack(bufB, dst, &count, ORTE_INT16);
if (ORTE_SUCCESS != rc || count != NUM_ELEMS) {
fprintf(test_out, "orte_dss.unpack of dest buffer failed with return code %d\n", rc);
return(false);
}
for(j=0; j<NUM_ELEMS; j++) {
if(src[j] != dst[j]) {
fprintf(test_out, "test2: invalid results from unpack of dest buffer\n");
return(false);
}
}
}
for (i=0; i<NUM_ITERS; i++) {
int j;
orte_std_cntr_t count;
for(j=0; j<NUM_ELEMS; j++)
dst32[j] = -1;
count = NUM_ELEMS;
rc = orte_dss.unpack(bufB, dst32, &count, ORTE_INT32);
if (ORTE_SUCCESS != rc || count != NUM_ELEMS) {
fprintf(test_out, "orte_dss.unpack of dest buffer failed with return code %d\n", rc);
return(false);
}
for(j=0; j<NUM_ELEMS; j++) {
if(src32[j] != dst32[j]) {
fprintf(test_out, "test2: invalid results from unpack of dest buffer\n");
return(false);
}
}
}
/* check that A is still okay */
for (i=0; i<NUM_ITERS; i++) {
int j;
orte_std_cntr_t count;
for(j=0; j<NUM_ELEMS; j++)
dst[j] = -1;
count = NUM_ELEMS;
rc = orte_dss.unpack(bufA, dst, &count, ORTE_INT16);
if (ORTE_SUCCESS != rc || count != NUM_ELEMS) {
fprintf(test_out, "orte_dss.unpack of src buffer failed with return code %d\n", rc);
return(false);
}
for(j=0; j<NUM_ELEMS; j++) {
if(src[j] != dst[j]) {
fprintf(test_out, "test2: invalid results from unpack of src buffer\n");
return(false);
}
}
}
OBJ_RELEASE(bufA);
OBJ_RELEASE(bufB);
if (NULL != bufA || NULL != bufB) {
fprintf(test_out, "OBJ_RELEASE did not NULL the buffer pointer\n");
return false;
}
return (true);
}
static bool test2(void) /* verify dss_xfer_payload */
{
orte_buffer_t *bufA, *bufB;
int rc;
int32_t i;
int16_t src[NUM_ELEMS];
int16_t dst[NUM_ELEMS];
bufA = OBJ_NEW(orte_buffer_t);
if (NULL == bufA) {
fprintf(test_out, "orte_buffer failed init in OBJ_NEW\n");
return false;
}
orte_dss.set_buffer_type(bufA, ORTE_DSS_BUFFER_NON_DESC);
for (i=0;i<NUM_ITERS;i++) {
rc = orte_dss.pack(bufA, src, NUM_ELEMS, ORTE_INT16);
if (ORTE_SUCCESS != rc) {
fprintf(test_out, "orte_dss.pack failed with return code %d\n", rc);
return(false);
}
}
/* setup bufB */
bufB = OBJ_NEW(orte_buffer_t);
if (NULL == bufB) {
fprintf(test_out, "orte_buffer failed init in OBJ_NEW\n");
return false;
}
orte_dss.set_buffer_type(bufB, ORTE_DSS_BUFFER_NON_DESC);
/* xfer payload to bufB */
if (ORTE_SUCCESS != (rc = orte_dss.xfer_payload(bufB, bufA))) {
fprintf(test_out, "orte_dss.xfer_payload failed with return code %d\n", rc);
return(false);
}
/* validate the results */
for (i=0; i<NUM_ITERS; i++) {
int j;
orte_std_cntr_t count;
for(j=0; j<NUM_ELEMS; j++)
dst[j] = -1;
count = NUM_ELEMS;
rc = orte_dss.unpack(bufB, dst, &count, ORTE_INT16);
if (ORTE_SUCCESS != rc || count != NUM_ELEMS) {
fprintf(test_out, "orte_dss.unpack of dest buffer failed with return code %d\n", rc);
return(false);
}
for(j=0; j<NUM_ELEMS; j++) {
if(src[j] != dst[j]) {
fprintf(test_out, "test2: invalid results from unpack of dest buffer\n");
return(false);
}
}
}
OBJ_RELEASE(bufA);
OBJ_RELEASE(bufB);
if (NULL != bufA || NULL != bufB) {
fprintf(test_out, "OBJ_RELEASE did not NULL the buffer pointer\n");
return false;
}
return (true);
}

2
orte/tools/console/orteconsole.c
Просмотреть файл

@ -312,7 +312,7 @@ int main(int argc, char *argv[])
* require
*/
daemon_is_active = true;
if (ORTE_SUCCESS != (ret = orte_init(true)) ) {
if (ORTE_SUCCESS != (ret = orte_init(ORTE_INFRASTRUCTURE, ORTE_NON_BARRIER)) ) {
if (ORTE_ERR_UNREACH == ret) {
opal_output(0, "Specified universe could not be reached - please ensure it has been started\n");
return ret;

2
orte/tools/orte-clean/orte-clean.c
Просмотреть файл

@ -246,7 +246,7 @@ static int orte_clean_init(void) {
goto cleanup;
}
if (ORTE_SUCCESS != (ret = orte_system_init(true))) {
if (ORTE_SUCCESS != (ret = orte_system_init(ORTE_INFRASTRUCTURE, ORTE_NON_BARRIER))) {
exit_status = ret;
goto cleanup;
}

2
orte/tools/orte-ps/orte-ps.c
Просмотреть файл

@ -1054,7 +1054,7 @@ static int connect_to_universe(orte_universe_t universe_info) {
* Restart ORTE in the requested universe
*/
if(!orte_ps_globals.attached) {
if (ORTE_SUCCESS != (ret = orte_system_init(true)) ) {
if (ORTE_SUCCESS != (ret = orte_system_init(ORTE_INFRASTRUCTURE, ORTE_NON_BARRIER)) ) {
exit_status = ret;
goto cleanup;
}

7
orte/tools/orted/orted.c
Просмотреть файл

@ -391,12 +391,11 @@ int main(int argc, char *argv[])
* up incorrect infrastructure that only a singleton would
* require
*/
if (ORTE_SUCCESS != (ret = orte_init(true))) {
opal_show_help("help-orted.txt", "orted:init-failure", false,
"orte_init()", ret);
if (ORTE_SUCCESS != (ret = orte_init(ORTE_INFRASTRUCTURE, ORTE_NON_BARRIER))) {
ORTE_ERROR_LOG(ret);
return ret;
}
/* Set signal handlers to catch kill signals so we can properly clean up
* after ourselves.
*/

10
orte/tools/orted/orted_comm.c
Просмотреть файл

@ -74,6 +74,7 @@ void orte_daemon_recv_pls(int status, orte_process_name_t* sender,
orte_std_cntr_t daemon_start, num_daemons;
int i, bitmap, peer, size, rank, hibit, mask;
orte_process_name_t target;
orte_rml_tag_t target_tag;
OPAL_TRACE(1);
@ -214,6 +215,13 @@ void orte_daemon_recv_pls(int status, orte_process_name_t* sender,
goto CLEANUP;
}
/* unpack the tag where we are to deliver the message */
n = 1;
if (ORTE_SUCCESS != (ret = orte_dss.unpack(buffer, &target_tag, &n, ORTE_RML_TAG))) {
ORTE_ERROR_LOG(ret);
goto CLEANUP;
}
/* unpack the message */
msg = OBJ_NEW(orte_gpr_notify_message_t);
if (NULL == msg) {
@ -301,7 +309,7 @@ void orte_daemon_recv_pls(int status, orte_process_name_t* sender,
}
/* deliver the message to the children */
if (ORTE_SUCCESS != (ret = orte_odls.deliver_message(job, &relay, ORTE_RML_TAG_XCAST))) {
if (ORTE_SUCCESS != (ret = orte_odls.deliver_message(job, &relay, target_tag))) {
ORTE_ERROR_LOG(ret);
goto CLEANUP;
}

2
orte/tools/ortehalt/ortehalt.c
Просмотреть файл

@ -149,7 +149,7 @@ int main(int argc, char *argv[])
* up incorrect infrastructure that only a singleton would
* require
*/
if (ORTE_SUCCESS != (rc = orte_init(true))) {
if (ORTE_SUCCESS != (rc = orte_init(ORTE_INFRASTRUCTURE, ORTE_NON_BARRIER))) {
opal_show_help("help-ortehalt.txt", "ortehalt:init-failure", true,
"orte_init()", rc);
return rc;

2
orte/tools/ortekill/ortekill.c
Просмотреть файл

@ -270,7 +270,7 @@ int main(int argc, char *argv[])
* up incorrect infrastructure that only a singleton would
* require
*/
if (ORTE_SUCCESS != (rc = orte_init(true))) {
if (ORTE_SUCCESS != (rc = orte_init(ORTE_INFRASTRUCTURE, ORTE_NON_BARRIER))) {
opal_show_help("help-orterun.txt", "orterun:init-failure", true,
"orte_init()", rc);
return rc;

8
orte/tools/orterun/orterun.c
Просмотреть файл

@ -430,12 +430,12 @@ int orterun(int argc, char *argv[])
* up incorrect infrastructure that only a singleton would
* require
*/
if (ORTE_SUCCESS != (rc = orte_init(true))) {
opal_show_help("help-orterun.txt", "orterun:init-failure", true,
"orte_init()", rc);
if (ORTE_SUCCESS != (rc = orte_init(ORTE_INFRASTRUCTURE, ORTE_NON_BARRIER))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* pre-condition any network transports that require it */
if (ORTE_SUCCESS != (rc = orte_pre_condition_transports(apps, num_apps))) {
ORTE_ERROR_LOG(rc);