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

Okay, here is the massive checkin that restructures the registry trigger system for scalability. Actually, it isn't "quite" as large as it looks - it just touches a bunch of files.

Просмотр исходного кода 
Also included is a fix to the attribute problem for singletons.

Short explanation:
The prior system placed triggers and subscriptions on the registry for each process - approximately eight/process. Each of these had to be checked every time there was a registry operation such as a "put" or "increment-value". For large numbers of processes, this repetitive checking consumed some significant time.

The new system allows processes to "attach" to existing triggers and subscriptions, without creating a new one. Thus, there are now only eight triggers and five subscriptions on a job - *regardless of how many processes are being run*. This means that the registry now takes the same amount of time (which is pretty darn short) to process an operation regardless of how many processes are in a job.

I'll provide some startup times from scalability tests shortly - need to complete the commit so I can move the system to an appropriate cluster.

This commit was SVN r6164.
Этот коммит содержится в:
Ralph Castain 2005-06-24 16:59:37 +00:00
родитель 35375f0653
Коммит 8271d3f30e
76 изменённых файлов: 4666 добавлений и 3496 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

151
src/attribute/attribute_predefined.c
Просмотреть файл

@ -26,6 +26,7 @@
#include "mca/ns/ns.h"
#include "mca/gpr/gpr.h"
#include "mca/errmgr/errmgr.h"
#include "mca/schema/schema.h"
/*
@ -65,37 +66,71 @@ static int attr_impi_host_color = 0;
int ompi_attr_create_predefined(void)
{
orte_gpr_notify_id_t rc;
int ret;
orte_gpr_value_t trig, *trig1;
int rc;
orte_gpr_trigger_t trig, *trig1;
orte_gpr_value_t value, *values;
orte_gpr_subscription_t sub, *sub1;
orte_jobid_t job;
if (ORTE_SUCCESS != (ret = orte_ns.get_jobid(&job, orte_process_info.my_name))) {
ORTE_ERROR_LOG(ret);
return ret;
if (ORTE_SUCCESS != (rc = orte_ns.get_jobid(&job, orte_process_info.my_name))) {
ORTE_ERROR_LOG(rc);
return rc;
}
OBJ_CONSTRUCT(&sub, orte_gpr_subscription_t);
sub.addr_mode = ORTE_GPR_TOKENS_OR | ORTE_GPR_KEYS_OR;
sub.segment = strdup(ORTE_NODE_SEGMENT);
if (NULL == sub.segment) {
/* indicate that this is a standard subscription. This indicates that the
* subscription will be common to all processes. Thus, the resulting data
* can be consolidated into a process-independent message and broadcast
* to all processes
*/
if (ORTE_SUCCESS != (rc = orte_schema.get_std_subscription_name(&(sub.name),
OMPI_ATTRIBUTE_SUBSCRIPTION, job))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* send data when trigger fires, then delete -
* no need for further notifications
*/
sub.action = ORTE_GPR_NOTIFY_DELETE_AFTER_TRIG;
OBJ_CONSTRUCT(&value, orte_gpr_value_t);
values = &value;
sub.values = &values;
sub.cnt = 1;
value.addr_mode = ORTE_GPR_TOKENS_OR | ORTE_GPR_KEYS_OR;
value.segment = strdup(ORTE_NODE_SEGMENT);
if (NULL == value.segment) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.tokens = NULL; /* wildcard - look at all containers */
sub.num_tokens = 0;
sub.num_keys = 1;
sub.keys = (char**)malloc(sizeof(char*));
if (NULL == sub.keys) {
value.tokens = NULL; /* wildcard - look at all containers */
value.num_tokens = 0;
value.cnt = 1;
value.keyvals = (orte_gpr_keyval_t**)malloc(sizeof(orte_gpr_keyval_t*));
if (NULL == value.keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.keys[0] = strdup(ORTE_NODE_SLOTS_KEY);
if (NULL == sub.keys[0]) {
value.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == value.keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
value.keyvals[0]->key = strdup(ORTE_NODE_SLOTS_KEY);
if (NULL == value.keyvals[0]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
@ -103,70 +138,38 @@ int ompi_attr_create_predefined(void)
sub.user_tag = NULL;
/* setup the trigger information */
OBJ_CONSTRUCT(&trig, orte_gpr_value_t);
trig.addr_mode = ORTE_GPR_TOKENS_XAND;
if (ORTE_SUCCESS != (ret = orte_schema.get_job_segment_name(&(trig.segment), job))) {
ORTE_ERROR_LOG(ret);
OBJ_CONSTRUCT(&trig, orte_gpr_trigger_t);
if (ORTE_SUCCESS != (rc = orte_schema.get_std_trigger_name(&(trig.name),
ORTE_STG1_TRIGGER, job))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ret;
return rc;
}
trig.tokens = (char**)malloc(sizeof(char*));
if (NULL == trig.tokens) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.tokens[0] = strdup(ORTE_JOB_GLOBALS);
trig.num_tokens = 1;
trig.cnt = 2;
trig.keyvals = (orte_gpr_keyval_t**)malloc(2*sizeof(orte_gpr_keyval_t*));
if (NULL == trig.keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trig.keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[0]->key = strdup(ORTE_JOB_SLOTS_KEY);
trig.keyvals[0]->type = ORTE_NULL;
trig.keyvals[1] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trig.keyvals[1]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[1]->key = strdup(ORTE_PROC_NUM_AT_STG1);
trig.keyvals[1]->type = ORTE_NULL;
/* this is an ORTE-standard trigger that is defined by the ORTE resource manager
* when the job was launched - therefore, we don't need to provide any additional
* info
*/
/* do the subscription */
sub1 = ⊂
trig1 = &trig;
ret = orte_gpr.subscribe(
ORTE_GPR_TRIG_CMP_LEVELS | ORTE_GPR_TRIG_MONITOR_ONLY |
ORTE_GPR_TRIG_ONE_SHOT,
1, &sub1,
1, &trig1,
&rc);
if(ORTE_SUCCESS != ret) {
ompi_output(0, "ompi_attr_create_predefined: subscribe failed");
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return OMPI_ERROR;
}
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return OMPI_SUCCESS;
rc = orte_gpr.subscribe(1, &sub1, 1, &trig1);
if(ORTE_SUCCESS != rc) {
ompi_output(0, "ompi_attr_create_predefined: subscribe failed");
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return OMPI_ERROR;
}
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return OMPI_SUCCESS;
}

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

@ -74,5 +74,13 @@ enum {
#define OMPI_NAMESPACE_SEGMENT "ompi-namespace"
/*
* OMPI-specific names for triggers and subscriptions used across processes
*/
#define OMPI_ATTRIBUTE_SUBSCRIPTION "ompi-attribute-sub"
#define OMPI_OOB_SUBSCRIPTION "ompi-oob-sub"
#define OMPI_MODEX_SUBSCRIPTION "ompi-modex-sub"
#endif /* OMPI_CONSTANTS_H */

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

@ -72,16 +72,19 @@ typedef uint8_t orte_data_type_t ;
#define ORTE_EXIT_CODE (orte_data_type_t) 32 /**< process exit code */
/* GPR types */
#define ORTE_KEYVAL (orte_data_type_t) 33 /**< registry key-value pair */
#define ORTE_NOTIFY_ACTION (orte_data_type_t) 34 /**< registry notify action */
#define ORTE_GPR_CMD (orte_data_type_t) 35 /**< registry command */
#define ORTE_GPR_NOTIFY_ID (orte_data_type_t) 36 /**< registry notify id tag */
#define ORTE_GPR_VALUE (orte_data_type_t) 37 /**< registry return value */
#define ORTE_GPR_ADDR_MODE (orte_data_type_t) 38 /**< Addressing mode for registry cmds */
#define ORTE_GPR_SUBSCRIPTION (orte_data_type_t) 39 /**< describes data returned by subscription */
#define ORTE_GPR_NOTIFY_DATA (orte_data_type_t) 40 /**< data returned from a subscription */
#define ORTE_GPR_NOTIFY_ACTION (orte_data_type_t) 34 /**< registry notify action */
#define ORTE_GPR_TRIGGER_ACTION (orte_data_type_t) 35 /**< registry trigger action */
#define ORTE_GPR_CMD (orte_data_type_t) 36 /**< registry command */
#define ORTE_GPR_SUBSCRIPTION_ID (orte_data_type_t) 37 /**< registry notify id tag */
#define ORTE_GPR_TRIGGER_ID (orte_data_type_t) 38 /**< registry notify id tag */
#define ORTE_GPR_VALUE (orte_data_type_t) 39 /**< registry return value */
#define ORTE_GPR_ADDR_MODE (orte_data_type_t) 40 /**< Addressing mode for registry cmds */
#define ORTE_GPR_SUBSCRIPTION (orte_data_type_t) 41 /**< describes data returned by subscription */
#define ORTE_GPR_TRIGGER (orte_data_type_t) 42 /**< describes trigger conditions */
#define ORTE_GPR_NOTIFY_DATA (orte_data_type_t) 43 /**< data returned from a subscription */
/* Resource Manager types */
#define ORTE_APP_CONTEXT (orte_data_type_t) 41 /**< argv and enviro arrays */
#define ORTE_APP_CONTEXT_MAP (orte_data_type_t) 42 /**< application context mapping array */
#define ORTE_APP_CONTEXT (orte_data_type_t) 44 /**< argv and enviro arrays */
#define ORTE_APP_CONTEXT_MAP (orte_data_type_t) 45 /**< application context mapping array */
/* define the starting point for dynamically assigning data types */
#define ORTE_DPS_ID_DYNAMIC 50

128
src/mca/base/mca_base_module_exchange.c
Просмотреть файл

@ -26,6 +26,7 @@
#include "mca/base/base.h"
#include "mca/errmgr/errmgr.h"
#include "mca/rml/rml.h"
#include "mca/schema/schema.h"
#include "mca/gpr/gpr.h"
#include "mca/gpr/base/base.h"
#include "mca/ns/ns.h"
@ -373,8 +374,7 @@ ompi_output(0, "[%lu,%lu,%lu] mca_base_modex_registry_callback: %s-%s-%d-%d rece
static int mca_base_modex_subscribe(orte_process_name_t* name)
{
orte_gpr_notify_id_t rctag;
orte_gpr_value_t trig, *trigs;
orte_gpr_trigger_t trig, *trigs;
orte_gpr_subscription_t sub, *subs;
orte_jobid_t jobid;
ompi_list_item_t* item;
@ -404,90 +404,96 @@ static int mca_base_modex_subscribe(orte_process_name_t* name)
/* setup the subscription definition */
OBJ_CONSTRUCT(&sub, orte_gpr_subscription_t);
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(sub.segment), jobid))) {
/* indicate that this is a standard subscription. This indicates that the
* subscription will be common to all processes. Thus, the resulting data
* can be consolidated into a process-independent message and broadcast
* to all processes
*/
if (ORTE_SUCCESS != (rc = orte_schema.get_std_subscription_name(&(sub.name),
OMPI_MODEX_SUBSCRIPTION, jobid))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* send data when trigger fires, continue to monitor. The default
* action for any subscription that includes a trigger condition is
* to send the specified data when the trigger fires. This set of flags
* indicates that - AFTER the trigger fires - the subscription should
* continue to send data any time an entry is added or changed.
*/
sub.action = ORTE_GPR_NOTIFY_ADD_ENTRY |
ORTE_GPR_NOTIFY_VALUE_CHG |
ORTE_GPR_NOTIFY_STARTS_AFTER_TRIG;
/* setup the value structures that describe the data to
* be monitored and returned by this subscription
*/
sub.cnt = 1;
sub.values = (orte_gpr_value_t**)malloc(sizeof(orte_gpr_value_t*));
if (NULL == sub.values) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.values[0] = OBJ_NEW(orte_gpr_value_t);
if (NULL == sub.values[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.cnt = 1;
/* define the segment */
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(
&(sub.values[0]->segment), jobid))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&sub);
return rc;
}
sub.addr_mode = ORTE_GPR_KEYS_OR | ORTE_GPR_TOKENS_OR;
sub.tokens = NULL;
sub.num_tokens = 0;
sub.num_keys = 1;
sub.keys = (char**)malloc(sizeof(char*));
if (NULL == sub.keys) {
sub.values[0]->addr_mode = ORTE_GPR_KEYS_OR | ORTE_GPR_TOKENS_OR;
/* look at all containers on this segment */
sub.values[0]->tokens = NULL;
sub.values[0]->num_tokens = 0;
/* look for any keyval with "modex" key */
sub.values[0]->cnt = 1;
sub.values[0]->keyvals = (orte_gpr_keyval_t**)malloc(sizeof(orte_gpr_keyval_t*));
if (NULL == sub.values[0]->keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.keys[0] = strdup("modex");
if (NULL == sub.keys[0]) {
sub.values[0]->keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == sub.values[0]->keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.values[0]->keyvals[0]->key = strdup("modex");
if (NULL == sub.values[0]->keyvals[0]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* define the callback function */
sub.cbfunc = mca_base_modex_registry_callback;
sub.user_tag = NULL;
/* setup the trigger definition */
OBJ_CONSTRUCT(&trig, orte_gpr_value_t);
trig.addr_mode = ORTE_GPR_TOKENS_XAND;
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(trig.segment), jobid))) {
OBJ_CONSTRUCT(&trig, orte_gpr_trigger_t);
if (ORTE_SUCCESS != (rc = orte_schema.get_std_trigger_name(&(trig.name),
ORTE_STG1_TRIGGER, jobid))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return rc;
}
trig.tokens = (char**)malloc(sizeof(char*));
if (NULL == trig.tokens) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.tokens[0] = strdup(ORTE_JOB_GLOBALS);
trig.num_tokens = 1;
trig.cnt = 2;
trig.keyvals = (orte_gpr_keyval_t**)malloc(2*sizeof(orte_gpr_keyval_t*));
if (NULL == trig.keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trig.keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[0]->key = strdup(ORTE_JOB_SLOTS_KEY);
trig.keyvals[0]->type = ORTE_NULL;
trig.keyvals[1] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trig.keyvals[1]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[1]->key = strdup(ORTE_PROC_NUM_AT_STG1);
trig.keyvals[1]->type = ORTE_NULL;
/* this is an ORTE-standard trigger that is defined by the ORTE resource manager
* when the job was launched - therefore, we don't need to provide any additional
* info
*/
/* register the subscription */
subs = &sub;
trigs = &trig;
rc = orte_gpr.subscribe(
ORTE_GPR_NOTIFY_ADD_ENTRY | ORTE_GPR_NOTIFY_VALUE_CHG |
ORTE_GPR_TRIG_CMP_LEVELS | ORTE_GPR_TRIG_ONE_SHOT |
ORTE_GPR_NOTIFY_STARTS_AFTER_TRIG,
1, &subs,
1, &trigs,
&rctag);
rc = orte_gpr.subscribe(1, &subs, 1, &trigs);
if(ORTE_SUCCESS != rc) {
ompi_output(0, "mca_base_modex_exchange: "
"ompi_gpr.subscribe failed with return code %d\n", rc);
"orte_gpr.subscribe failed with return code %d\n", rc);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return OMPI_ERROR;

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

@ -52,7 +52,7 @@
*/
#ifndef ORTE_GPR_BASE_H_
#define ORTE_GRP_BASE_H_
#define ORTE_GPR_BASE_H_
/*
* includes
@ -83,16 +83,32 @@ extern "C" {
#endif
/*
* packing type definitions for GPR-specific types
* Define flag values for remote commands
*/
/* CAUTION - any changes here must also change corresponding
* typedefs in gpr_types.h
*/
#define ORTE_GPR_PACK_CMD ORTE_GPR_CMD
#define ORTE_GPR_PACK_ACTION ORTE_NOTIFY_ACTION
#define ORTE_GPR_PACK_ADDR_MODE ORTE_UINT16
#define ORTE_GPR_PACK_SYNCHRO_MODE ORTE_SYNCHRO_MODE
#define ORTE_GPR_PACK_NOTIFY_ID ORTE_UINT32
#define ORTE_GPR_DELETE_SEGMENT_CMD (uint8_t) 1
#define ORTE_GPR_PUT_CMD (uint8_t) 2
#define ORTE_GPR_DELETE_ENTRIES_CMD (uint8_t) 3
#define ORTE_GPR_INDEX_CMD (uint8_t) 4
#define ORTE_GPR_SUBSCRIBE_CMD (uint8_t) 5
#define ORTE_GPR_UNSUBSCRIBE_CMD (uint8_t) 6
#define ORTE_GPR_CANCEL_TRIGGER_CMD (uint8_t) 7
#define ORTE_GPR_GET_CMD (uint8_t) 8
#define ORTE_GPR_TEST_INTERNALS_CMD (uint8_t) 9
#define ORTE_GPR_NOTIFY_CMD (uint8_t) 10
#define ORTE_GPR_DUMP_ALL_CMD (uint8_t) 11
#define ORTE_GPR_DUMP_SEGMENTS_CMD (uint8_t) 12
#define ORTE_GPR_DUMP_TRIGGERS_CMD (uint8_t) 13
#define ORTE_GPR_DUMP_SUBSCRIPTIONS_CMD (uint8_t) 14
#define ORTE_GPR_DUMP_CALLBACKS_CMD (uint8_t) 15
#define ORTE_GPR_INCREMENT_VALUE_CMD (uint8_t) 16
#define ORTE_GPR_DECREMENT_VALUE_CMD (uint8_t) 17
#define ORTE_GPR_COMPOUND_CMD (uint8_t) 18
#define ORTE_GPR_CLEANUP_JOB_CMD (uint8_t) 19
#define ORTE_GPR_CLEANUP_PROC_CMD (uint8_t) 20
#define ORTE_GPR_ERROR (uint8_t)0xff
typedef uint8_t orte_gpr_cmd_flag_t;
#define ORTE_GPR_CMD_T ORTE_UINT8
OMPI_DECLSPEC int orte_gpr_base_open(void);
OMPI_DECLSPEC int orte_gpr_base_select(void);
@ -113,16 +129,19 @@ extern "C" {
char **index);
OMPI_DECLSPEC int orte_gpr_base_pack_subscribe(orte_buffer_t *cmd,
orte_gpr_notify_action_t action, size_t num_subs,
size_t num_subs,
orte_gpr_subscription_t **subscriptions,
size_t num_trigs, orte_gpr_value_t **trig);
OMPI_DECLSPEC int orte_gpr_base_unpack_subscribe(orte_buffer_t *buffer, int *ret,
orte_gpr_notify_id_t *remote_idtag);
size_t num_trigs, orte_gpr_trigger_t **trig);
OMPI_DECLSPEC int orte_gpr_base_unpack_subscribe(orte_buffer_t *buffer, int *ret);
OMPI_DECLSPEC int orte_gpr_base_pack_unsubscribe(orte_buffer_t *cmd,
orte_gpr_notify_id_t remote_idtag);
orte_gpr_subscription_id_t id);
OMPI_DECLSPEC int orte_gpr_base_unpack_unsubscribe(orte_buffer_t *buffer, int *ret);
OMPI_DECLSPEC int orte_gpr_base_pack_cancel_trigger(orte_buffer_t *cmd,
orte_gpr_trigger_id_t id);
OMPI_DECLSPEC int orte_gpr_base_unpack_cancel_trigger(orte_buffer_t *buffer, int *ret);
OMPI_DECLSPEC int orte_gpr_base_pack_put(orte_buffer_t *cmd,
size_t cnt, orte_gpr_value_t **values);
OMPI_DECLSPEC int orte_gpr_base_unpack_put(orte_buffer_t *buffer, int *ret);
@ -136,6 +155,7 @@ extern "C" {
OMPI_DECLSPEC int orte_gpr_base_pack_dump_all(orte_buffer_t *cmd);
OMPI_DECLSPEC int orte_gpr_base_pack_dump_segments(orte_buffer_t *cmd);
OMPI_DECLSPEC int orte_gpr_base_pack_dump_triggers(orte_buffer_t *cmd);
OMPI_DECLSPEC int orte_gpr_base_pack_dump_subscriptions(orte_buffer_t *cmd);
OMPI_DECLSPEC int orte_gpr_base_pack_dump_callbacks(orte_buffer_t *cmd);
OMPI_DECLSPEC int orte_gpr_base_print_dump(orte_buffer_t *buffer, int output_id);
OMPI_DECLSPEC void orte_gpr_base_dump_keyval_value(orte_buffer_t *buffer,
@ -166,12 +186,18 @@ extern "C" {
int orte_gpr_base_pack_cmd(orte_buffer_t *buffer, void *src,
size_t num_vals, orte_data_type_t type);
int orte_gpr_base_pack_notify_id(orte_buffer_t *buffer, void *src,
int orte_gpr_base_pack_subscription_id(orte_buffer_t *buffer, void *src,
size_t num_vals, orte_data_type_t type);
int orte_gpr_base_pack_trigger_id(orte_buffer_t *buffer, void *src,
size_t num_vals, orte_data_type_t type);
int orte_gpr_base_pack_notify_action(orte_buffer_t *buffer, void *src,
size_t num_vals, orte_data_type_t type);
int orte_gpr_base_pack_trigger_action(orte_buffer_t *buffer, void *src,
size_t num_vals, orte_data_type_t type);
int orte_gpr_base_pack_addr_mode(orte_buffer_t *buffer, void *src,
size_t num_vals, orte_data_type_t type);
@ -184,6 +210,9 @@ int orte_gpr_base_pack_value(orte_buffer_t *buffer, void *src,
int orte_gpr_base_pack_subscription(orte_buffer_t *buffer, void *src,
size_t num_vals, orte_data_type_t type);
int orte_gpr_base_pack_trigger(orte_buffer_t *buffer, void *src,
size_t num_vals, orte_data_type_t type);
int orte_gpr_base_pack_notify_data(orte_buffer_t *buffer, void *src,
size_t num_vals, orte_data_type_t type);
@ -191,12 +220,18 @@ int orte_gpr_base_pack_notify_data(orte_buffer_t *buffer, void *src,
int orte_gpr_base_unpack_cmd(orte_buffer_t *buffer, void *dest,
size_t *num_vals, orte_data_type_t type);
int orte_gpr_base_unpack_notify_id(orte_buffer_t *buffer, void *dest,
int orte_gpr_base_unpack_subscription_id(orte_buffer_t *buffer, void *dest,
size_t *num_vals, orte_data_type_t type);
int orte_gpr_base_unpack_trigger_id(orte_buffer_t *buffer, void *dest,
size_t *num_vals, orte_data_type_t type);
int orte_gpr_base_unpack_notify_action(orte_buffer_t *buffer, void *dest,
size_t *num_vals, orte_data_type_t type);
int orte_gpr_base_unpack_trigger_action(orte_buffer_t *buffer, void *dest,
size_t *num_vals, orte_data_type_t type);
int orte_gpr_base_unpack_addr_mode(orte_buffer_t *buffer, void *dest,
size_t *num_vals, orte_data_type_t type);
@ -209,6 +244,9 @@ int orte_gpr_base_unpack_value(orte_buffer_t *buffer, void *dest,
int orte_gpr_base_unpack_subscription(orte_buffer_t *buffer, void *dest,
size_t *num_vals, orte_data_type_t type);
int orte_gpr_base_unpack_trigger(orte_buffer_t *buffer, void *dest,
size_t *num_vals, orte_data_type_t type);
int orte_gpr_base_unpack_notify_data(orte_buffer_t *buffer, void *dest,
size_t *num_vals, orte_data_type_t type);

159
src/mca/gpr/base/data_type_support/gpr_data_type_packing_fns.c
Просмотреть файл

@ -42,14 +42,29 @@ int orte_gpr_base_pack_cmd(orte_buffer_t *buffer, void *src,
}
/*
* NOTIFY ID
* SUBSCRIPTION ID
*/
int orte_gpr_base_pack_notify_id(orte_buffer_t *buffer, void *src,
int orte_gpr_base_pack_subscription_id(orte_buffer_t *buffer, void *src,
size_t num_vals, orte_data_type_t type)
{
int rc;
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer, src, num_vals, ORTE_GPR_NOTIFY_ID_T))) {
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer, src, num_vals, ORTE_GPR_SUBSCRIPTION_ID_T))) {
ORTE_ERROR_LOG(rc);
}
return rc;
}
/*
* TRIGGER ID
*/
int orte_gpr_base_pack_trigger_id(orte_buffer_t *buffer, void *src,
size_t num_vals, orte_data_type_t type)
{
int rc;
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer, src, num_vals, ORTE_GPR_TRIGGER_ID_T))) {
ORTE_ERROR_LOG(rc);
}
@ -71,6 +86,21 @@ int orte_gpr_base_pack_notify_action(orte_buffer_t *buffer, void *src,
return rc;
}
/*
* TRIGGER ACTION
*/
int orte_gpr_base_pack_trigger_action(orte_buffer_t *buffer, void *src,
size_t num_vals, orte_data_type_t type)
{
int rc;
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer, src, num_vals, ORTE_GPR_TRIGGER_ACTION_T))) {
ORTE_ERROR_LOG(rc);
}
return rc;
}
/*
* ADDR MODE
*/
@ -202,58 +232,103 @@ int orte_gpr_base_pack_subscription(orte_buffer_t *buffer, void *src,
/* array of pointers to subscription objects - need to pack the objects */
subs = (orte_gpr_subscription_t**) src;
for (i=0; i<num_vals; i++) {
/* pack the address mode */
/* pack the subscription name */
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)(&(subs[i]->addr_mode)), 1, ORTE_GPR_ADDR_MODE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* pack the segment name */
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)(&(subs[i]->segment)), 1, ORTE_STRING))) {
(void*)(&(subs[i]->name)), 1, ORTE_STRING))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* pack the number of tokens so we can read it for unpacking */
/* pack the subscription id */
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)(&(subs[i]->num_tokens)), 1, DPS_TYPE_SIZE_T))) {
(void*)(&(subs[i]->id)), 1, ORTE_GPR_SUBSCRIPTION_ID))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* if there are tokens, pack them */
if (0 < subs[i]->num_tokens) {
/* pack the notify action */
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)(&(subs[i]->action)), 1, ORTE_GPR_NOTIFY_ACTION))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* pack the number of values so we can read it for unpacking */
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)(&(subs[i]->cnt)), 1, DPS_TYPE_SIZE_T))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* if there are values, pack them */
if (0 < subs[i]->cnt) {
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)((subs[i]->tokens)), subs[i]->num_tokens, ORTE_STRING))) {
(void*)((subs[i]->values)), subs[i]->cnt, ORTE_GPR_VALUE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
/* pack the number of keys so we can read it for unpacking */
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)(&(subs[i]->num_keys)), 1, DPS_TYPE_SIZE_T))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* if there are keys, pack them */
if (0 < subs[i]->num_keys) {
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)((subs[i]->keys)), subs[i]->num_keys, ORTE_STRING))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
/* skip the pointers for cb_func and user_tag */
}
return ORTE_SUCCESS;
}
/*
* TRIGGER
*/
int orte_gpr_base_pack_trigger(orte_buffer_t *buffer, void *src,
size_t num_vals, orte_data_type_t type)
{
int rc;
orte_gpr_trigger_t **trigs;
size_t i;
/* array of pointers to trigger objects - need to pack the objects */
trigs = (orte_gpr_trigger_t**) src;
for (i=0; i<num_vals; i++) {
/* pack the trigger name */
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)(&(trigs[i]->name)), 1, ORTE_STRING))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* pack the trigger id */
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)(&(trigs[i]->id)), 1, ORTE_GPR_TRIGGER_ID))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* pack the trigger action */
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)(&(trigs[i]->action)), 1, ORTE_GPR_TRIGGER_ACTION))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* pack the number of values so we can read it for unpacking */
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)(&(trigs[i]->cnt)), 1, DPS_TYPE_SIZE_T))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* if there are values, pack the values */
if (0 < trigs[i]->cnt) {
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)((trigs[i]->values)), trigs[i]->cnt, ORTE_GPR_VALUE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
}
return ORTE_SUCCESS;
}
/*
* NOTIFY DATA
*/
@ -269,23 +344,9 @@ int orte_gpr_base_pack_notify_data(orte_buffer_t *buffer, void *src,
for (i=0; i<num_vals; i++) {
/* pack the callback number */
/* pack the subscription number */
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)(&(data[i]->cb_num)), 1, DPS_TYPE_SIZE_T))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* pack the address mode */
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)(&(data[i]->addr_mode)), 1, ORTE_GPR_ADDR_MODE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* pack the segment name */
if (ORTE_SUCCESS != (rc = orte_dps_pack_buffer(buffer,
(void*)(&(data[i]->segment)), 1, ORTE_STRING))) {
(void*)(&(data[i]->id)), 1, ORTE_GPR_SUBSCRIPTION_ID))) {
ORTE_ERROR_LOG(rc);
return rc;
}

188
src/mca/gpr/base/data_type_support/gpr_data_type_unpacking_fns.c
Просмотреть файл

@ -42,14 +42,29 @@ int orte_gpr_base_unpack_cmd(orte_buffer_t *buffer, void *dest,
}
/*
* NOTIFY ID
* SUBSCRIPTION ID
*/
int orte_gpr_base_unpack_notify_id(orte_buffer_t *buffer, void *dest,
int orte_gpr_base_unpack_subscription_id(orte_buffer_t *buffer, void *dest,
size_t *num_vals, orte_data_type_t type)
{
int rc;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, dest, num_vals, ORTE_GPR_NOTIFY_ID_T))) {
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, dest, num_vals, ORTE_GPR_SUBSCRIPTION_ID_T))) {
ORTE_ERROR_LOG(rc);
}
return rc;
}
/*
* TRIGGER ID
*/
int orte_gpr_base_unpack_trigger_id(orte_buffer_t *buffer, void *dest,
size_t *num_vals, orte_data_type_t type)
{
int rc;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, dest, num_vals, ORTE_GPR_TRIGGER_ID_T))) {
ORTE_ERROR_LOG(rc);
}
@ -71,6 +86,21 @@ int orte_gpr_base_unpack_notify_action(orte_buffer_t *buffer, void *dest,
return rc;
}
/*
* TRIGGER ACTION
*/
int orte_gpr_base_unpack_trigger_action(orte_buffer_t *buffer, void *dest,
size_t *num_vals, orte_data_type_t type)
{
int rc;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, dest, num_vals, ORTE_GPR_TRIGGER_ACTION_T))) {
ORTE_ERROR_LOG(rc);
}
return rc;
}
/*
* ADDR MODE
*/
@ -235,61 +265,45 @@ int orte_gpr_base_unpack_subscription(orte_buffer_t *buffer, void *dest,
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* unpack the address mode */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(subs[i]->addr_mode),
&max_n, ORTE_GPR_ADDR_MODE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* unpack the segment name */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(subs[i]->segment),
/* unpack the subscription name */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(subs[i]->name),
&max_n, ORTE_STRING))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* get the number of tokens */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(subs[i]->num_tokens),
/* unpack the subscription id */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(subs[i]->id),
&max_n, ORTE_GPR_SUBSCRIPTION_ID))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* unpack the subscription action */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(subs[i]->action),
&max_n, ORTE_GPR_NOTIFY_ACTION))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* get the number of values */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(subs[i]->cnt),
&max_n, DPS_TYPE_SIZE_T))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* if there are tokens, allocate the required space for the char * pointers */
if (0 < subs[i]->num_tokens) {
subs[i]->tokens = (char **)malloc(subs[i]->num_tokens * sizeof(char*));
if (NULL == subs[i]->tokens) {
/* if there are values, allocate the required space for the value pointers */
if (0 < subs[i]->cnt) {
subs[i]->values = (orte_gpr_value_t**)malloc(subs[i]->cnt * sizeof(orte_gpr_value_t*));
if (NULL == subs[i]->values) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* and unpack them */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, subs[i]->tokens,
&(subs[i]->num_tokens), ORTE_STRING))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
/* get the number of keys */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(subs[i]->num_keys),
&max_n, DPS_TYPE_SIZE_T))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* if there are keys, allocate the required space for the char * pointers */
if (0 < subs[i]->num_keys) {
subs[i]->keys = (char **)malloc(subs[i]->num_keys * sizeof(char*));
if (NULL == subs[i]->keys) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* and unpack them */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, subs[i]->keys,
&(subs[i]->num_keys), ORTE_STRING))) {
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, subs[i]->values,
&(subs[i]->cnt), ORTE_GPR_VALUE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
@ -303,6 +317,74 @@ int orte_gpr_base_unpack_subscription(orte_buffer_t *buffer, void *dest,
return ORTE_SUCCESS;
}
/*
* TRIGGER
*/
int orte_gpr_base_unpack_trigger(orte_buffer_t *buffer, void *dest,
size_t *num_vals, orte_data_type_t type)
{
int rc;
orte_gpr_trigger_t **trigs;
size_t i, max_n=1;
/* unpack into array of trigger objects */
trigs = (orte_gpr_trigger_t**) dest;
for (i=0; i < *num_vals; i++) {
/* create the trigger object */
trigs[i] = OBJ_NEW(orte_gpr_trigger_t);
if (NULL == trigs[i]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* unpack the trigger name */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(trigs[i]->name),
&max_n, ORTE_STRING))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* unpack the trigger id */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(trigs[i]->id),
&max_n, ORTE_GPR_TRIGGER_ID))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* unpack the trigger action */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(trigs[i]->action),
&max_n, ORTE_GPR_TRIGGER_ACTION))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* get the number of values */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(trigs[i]->cnt),
&max_n, DPS_TYPE_SIZE_T))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* if there are values, allocate the required space for the value pointers */
if (0 < trigs[i]->cnt) {
trigs[i]->values = (orte_gpr_value_t**)malloc(trigs[i]->cnt * sizeof(orte_gpr_value_t*));
if (NULL == trigs[i]->values) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* and unpack them */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, trigs[i]->values,
&(trigs[i]->cnt), ORTE_GPR_VALUE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
}
return ORTE_SUCCESS;
}
/*
* NOTIFY DATA
*/
@ -324,23 +406,9 @@ int orte_gpr_base_unpack_notify_data(orte_buffer_t *buffer, void *dest,
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* unpack the callback number */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(data[i]->cb_num),
&max_n, DPS_TYPE_SIZE_T))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* unpack the address mode */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(data[i]->addr_mode),
&max_n, ORTE_GPR_ADDR_MODE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* unpack the segment name */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(data[i]->segment),
&max_n, ORTE_STRING))) {
/* unpack the subscription number */
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, &(data[i]->id),
&max_n, ORTE_GPR_SUBSCRIPTION_ID))) {
ORTE_ERROR_LOG(rc);
return rc;
}

114
src/mca/gpr/base/gpr_base_open.c
Просмотреть файл

@ -44,7 +44,7 @@
static void orte_gpr_keyval_construct(orte_gpr_keyval_t* keyval)
{
keyval->key = NULL;
keyval->type = 0;
keyval->type = ORTE_NULL;
keyval->value.i32 = 0;
}
@ -88,7 +88,7 @@ static void orte_gpr_value_construct(orte_gpr_value_t* reg_val)
reg_val->cnt = 0;
reg_val->keyvals = NULL;
reg_val->num_tokens = 0;
reg_val->tokens = 0;
reg_val->tokens = NULL;
}
/* destructor - used to free any resources held by instance */
@ -129,9 +129,7 @@ OBJ_CLASS_INSTANCE(
/* constructor - used to initialize state of registry value instance */
static void orte_gpr_notify_data_construct(orte_gpr_notify_data_t* ptr)
{
ptr->cb_num = 0;
ptr->addr_mode = 0;
ptr->segment = NULL;
ptr->id = ORTE_GPR_SUBSCRIPTION_ID_MAX;
ptr->cnt = 0;
ptr->values = NULL;
}
@ -141,8 +139,6 @@ static void orte_gpr_notify_data_destructor(orte_gpr_notify_data_t* ptr)
{
size_t i;
if (NULL != ptr->segment) free(ptr->segment);
if (0 < ptr->cnt && NULL != ptr->values) {
for (i=0; i < ptr->cnt; i++) {
if (NULL != ptr->values[i])
@ -164,12 +160,11 @@ OBJ_CLASS_INSTANCE(
/* constructor - used to initialize state of registry subscription instance */
static void orte_gpr_subscription_construct(orte_gpr_subscription_t* sub)
{
sub->addr_mode = 0;
sub->segment = NULL;
sub->num_tokens = 0;
sub->tokens = NULL;
sub->num_keys = 0;
sub->keys = NULL;
sub->name = NULL;
sub->id = ORTE_GPR_SUBSCRIPTION_ID_MAX;
sub->action = 0;
sub->cnt = 0;
sub->values = NULL;
sub->cbfunc = NULL;
sub->user_tag = NULL;
}
@ -177,29 +172,16 @@ static void orte_gpr_subscription_construct(orte_gpr_subscription_t* sub)
/* destructor - used to free any resources held by instance */
static void orte_gpr_subscription_destructor(orte_gpr_subscription_t* sub)
{
char **tokens;
size_t i;
if (NULL != sub->segment) free(sub->segment);
if (NULL != sub->name) free(sub->name);
if (0 < sub->num_tokens && NULL != sub->tokens) {
tokens = sub->tokens;
for (i=0; i < sub->num_tokens; i++) {
if(NULL != tokens[i])
free(tokens[i]);
if (0 < sub->cnt && NULL != sub->values) {
for (i=0; i < sub->cnt; i++) {
OBJ_RELEASE(sub->values[i]);
}
free(sub->tokens);
free(sub->values);
}
if (0 < sub->num_keys && NULL != sub->keys) {
tokens = sub->keys;
for (i=0; i < sub->num_keys; i++) {
if(NULL != tokens[i])
free(tokens[i]);
}
free(sub->keys);
}
}
/* define instance of ompi_class_t */
@ -210,11 +192,43 @@ OBJ_CLASS_INSTANCE(
orte_gpr_subscription_destructor); /* destructor */
/** TRIGGER **/
/* constructor - used to initialize state of registry subscription instance */
static void orte_gpr_trigger_construct(orte_gpr_trigger_t* trig)
{
trig->name = NULL;
trig->id = ORTE_GPR_TRIGGER_ID_MAX;
trig->action = 0;
trig->cnt = 0;
trig->values = NULL;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_trigger_destructor(orte_gpr_trigger_t* trig)
{
size_t i;
if (NULL != trig->name) free(trig->name);
if (0 < trig->cnt && NULL != trig->values) {
for (i=0; i < trig->cnt; i++) OBJ_RELEASE(trig->values[i]);
free(trig->values);
}
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_trigger_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_trigger_construct, /* constructor */
orte_gpr_trigger_destructor); /* destructor */
/** NOTIFY MESSAGE */
/* constructor - used to initialize notify message instance */
static void orte_gpr_notify_message_construct(orte_gpr_notify_message_t* msg)
{
msg->idtag = 0;
msg->cnt = 0;
msg->data = NULL;
}
@ -281,18 +295,34 @@ int orte_gpr_base_open(void)
return rc;
}
tmp = ORTE_GPR_NOTIFY_ID;
if (ORTE_SUCCESS != (rc = orte_dps.register_type(orte_gpr_base_pack_notify_id,
orte_gpr_base_unpack_notify_id,
"ORTE_GPR_NOTIFY_ID", &tmp))) {
tmp = ORTE_GPR_SUBSCRIPTION_ID;
if (ORTE_SUCCESS != (rc = orte_dps.register_type(orte_gpr_base_pack_subscription_id,
orte_gpr_base_unpack_subscription_id,
"ORTE_GPR_SUBSCRIPTION_ID", &tmp))) {
ORTE_ERROR_LOG(rc);
return rc;
}
tmp = ORTE_NOTIFY_ACTION;
tmp = ORTE_GPR_TRIGGER_ID;
if (ORTE_SUCCESS != (rc = orte_dps.register_type(orte_gpr_base_pack_trigger_id,
orte_gpr_base_unpack_trigger_id,
"ORTE_GPR_TRIGGER_ID", &tmp))) {
ORTE_ERROR_LOG(rc);
return rc;
}
tmp = ORTE_GPR_NOTIFY_ACTION;
if (ORTE_SUCCESS != (rc = orte_dps.register_type(orte_gpr_base_pack_notify_action,
orte_gpr_base_unpack_notify_action,
"ORTE_NOTIFY_ACTION", &tmp))) {
"ORTE_GPR_NOTIFY_ACTION", &tmp))) {
ORTE_ERROR_LOG(rc);
return rc;
}
tmp = ORTE_GPR_TRIGGER_ACTION;
if (ORTE_SUCCESS != (rc = orte_dps.register_type(orte_gpr_base_pack_trigger_action,
orte_gpr_base_unpack_trigger_action,
"ORTE_GPR_TRIGGER_ACTION", &tmp))) {
ORTE_ERROR_LOG(rc);
return rc;
}
@ -329,6 +359,14 @@ int orte_gpr_base_open(void)
return rc;
}
tmp = ORTE_GPR_TRIGGER;
if (ORTE_SUCCESS != (rc = orte_dps.register_type(orte_gpr_base_pack_trigger,
orte_gpr_base_unpack_trigger,
"ORTE_GPR_TRIGGER", &tmp))) {
ORTE_ERROR_LOG(rc);
return rc;
}
tmp = ORTE_GPR_NOTIFY_DATA;
if (ORTE_SUCCESS != (rc = orte_dps.register_type(orte_gpr_base_pack_notify_data,
orte_gpr_base_unpack_notify_data,

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

@ -39,7 +39,7 @@ int orte_gpr_base_pack_increment_value(orte_buffer_t *cmd, orte_gpr_value_t *val
command = ORTE_GPR_INCREMENT_VALUE_CMD;
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &command, 1, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &command, 1, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
@ -60,7 +60,7 @@ int orte_gpr_base_pack_decrement_value(orte_buffer_t *cmd, orte_gpr_value_t *val
command = ORTE_GPR_DECREMENT_VALUE_CMD;
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &command, 1, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &command, 1, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}

4
src/mca/gpr/base/pack_api_cmd/gpr_base_pack_cleanup.c
Просмотреть файл

@ -36,7 +36,7 @@ int orte_gpr_base_pack_cleanup_job(orte_buffer_t *buffer, orte_jobid_t jobid)
command = ORTE_GPR_CLEANUP_JOB_CMD;
if (ORTE_SUCCESS != (rc = orte_dps.pack(buffer, &command, 1, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.pack(buffer, &command, 1, ORTE_GPR_CMD))) {
return rc;
}
@ -55,7 +55,7 @@ int orte_gpr_base_pack_cleanup_proc(orte_buffer_t *buffer, orte_process_name_t *
command = ORTE_GPR_CLEANUP_PROC_CMD;
if (ORTE_SUCCESS != (rc = orte_dps.pack(buffer, &command, 1, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.pack(buffer, &command, 1, ORTE_GPR_CMD))) {
return rc;
}

2
src/mca/gpr/base/pack_api_cmd/gpr_base_pack_del_index.c
Просмотреть файл

@ -33,7 +33,7 @@ int orte_gpr_base_pack_delete_segment(orte_buffer_t *cmd, char *segment)
command = ORTE_GPR_DELETE_SEGMENT_CMD;
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &command, 1, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &command, 1, ORTE_GPR_CMD))) {
return rc;
}

17
src/mca/gpr/base/pack_api_cmd/gpr_base_pack_dump.c
Просмотреть файл

@ -36,7 +36,7 @@ int orte_gpr_base_pack_dump_all(orte_buffer_t *cmd)
command = ORTE_GPR_DUMP_ALL_CMD;
return orte_dps.pack(cmd, &command, 1, ORTE_GPR_PACK_CMD);
return orte_dps.pack(cmd, &command, 1, ORTE_GPR_CMD);
}
int orte_gpr_base_pack_dump_segments(orte_buffer_t *cmd)
@ -45,7 +45,7 @@ int orte_gpr_base_pack_dump_segments(orte_buffer_t *cmd)
command = ORTE_GPR_DUMP_SEGMENTS_CMD;
return orte_dps.pack(cmd, &command, 1, ORTE_GPR_PACK_CMD);
return orte_dps.pack(cmd, &command, 1, ORTE_GPR_CMD);
}
int orte_gpr_base_pack_dump_triggers(orte_buffer_t *cmd)
@ -54,7 +54,16 @@ int orte_gpr_base_pack_dump_triggers(orte_buffer_t *cmd)
command = ORTE_GPR_DUMP_TRIGGERS_CMD;
return orte_dps.pack(cmd, &command, 1, ORTE_GPR_PACK_CMD);
return orte_dps.pack(cmd, &command, 1, ORTE_GPR_CMD);
}
int orte_gpr_base_pack_dump_subscriptions(orte_buffer_t *cmd)
{
orte_gpr_cmd_flag_t command;
command = ORTE_GPR_DUMP_SUBSCRIPTIONS_CMD;
return orte_dps.pack(cmd, &command, 1, ORTE_GPR_CMD);
}
int orte_gpr_base_pack_dump_callbacks(orte_buffer_t *cmd)
@ -63,5 +72,5 @@ int orte_gpr_base_pack_dump_callbacks(orte_buffer_t *cmd)
command = ORTE_GPR_DUMP_CALLBACKS_CMD;
return orte_dps.pack(cmd, &command, 1, ORTE_GPR_PACK_CMD);
return orte_dps.pack(cmd, &command, 1, ORTE_GPR_CMD);
}

35
src/mca/gpr/base/pack_api_cmd/gpr_base_pack_subscribe.c
Просмотреть файл

@ -33,10 +33,10 @@
#include "mca/gpr/base/base.h"
int orte_gpr_base_pack_subscribe(orte_buffer_t *cmd,
orte_gpr_notify_action_t action, size_t num_subs,
size_t num_subs,
orte_gpr_subscription_t **subscriptions,
size_t num_trigs,
orte_gpr_value_t **trigs)
orte_gpr_trigger_t **trigs)
{
orte_gpr_cmd_flag_t command;
int rc;
@ -48,17 +48,12 @@ int orte_gpr_base_pack_subscribe(orte_buffer_t *cmd,
return rc;
}
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &action, 1, ORTE_NOTIFY_ACTION))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, subscriptions, num_subs, ORTE_GPR_SUBSCRIPTION))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, trigs, num_trigs, ORTE_GPR_VALUE))) {
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, trigs, num_trigs, ORTE_GPR_TRIGGER))) {
ORTE_ERROR_LOG(rc);
return rc;
}
@ -68,20 +63,38 @@ int orte_gpr_base_pack_subscribe(orte_buffer_t *cmd,
int orte_gpr_base_pack_unsubscribe(orte_buffer_t *cmd,
orte_gpr_notify_id_t remote_idtag)
orte_gpr_subscription_id_t id)
{
orte_gpr_cmd_flag_t command;
int rc;
command = ORTE_GPR_UNSUBSCRIBE_CMD;
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &command, 1, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &command, 1, ORTE_GPR_CMD))) {
return rc;
}
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &remote_idtag, 1, ORTE_GPR_PACK_NOTIFY_ID))) {
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &id, 1, ORTE_GPR_SUBSCRIPTION_ID))) {
return rc;
}
return ORTE_SUCCESS;
}
int orte_gpr_base_pack_cancel_trigger(orte_buffer_t *cmd, orte_gpr_trigger_id_t id)
{
orte_gpr_cmd_flag_t command;
int rc;
command = ORTE_GPR_CANCEL_TRIGGER_CMD;
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &command, 1, ORTE_GPR_CMD))) {
return rc;
}
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &id, 1, ORTE_GPR_TRIGGER_ID))) {
return rc;
}
return ORTE_SUCCESS;
}

13
src/mca/gpr/base/unpack_api_response/gpr_base_dump_notify.c
Просмотреть файл

@ -51,13 +51,13 @@ int orte_gpr_base_dump_notify_msg(orte_buffer_t *buffer,
return ORTE_SUCCESS;
}
asprintf(&tmp_out, "%lu Notify data structures in message going to trigger %lu",
(unsigned long) msg->cnt, (unsigned long) msg->idtag);
asprintf(&tmp_out, "%lu Notify data structures in message",
(unsigned long) msg->cnt);
orte_gpr_base_dump_load_string(buffer, &tmp_out);
if (0 < msg->cnt && NULL != msg->data) {
for (i=0; i < msg->cnt; i++) {
asprintf(&tmp_out, "\nDump of data structure %lu",
asprintf(&tmp_out, "\nDump of notify data structure number %lu",
(unsigned long) i);
orte_gpr_base_dump_load_string(buffer, &tmp_out);
orte_gpr_base_dump_data(buffer, msg->data[i]);
@ -92,15 +92,14 @@ static void orte_gpr_base_dump_data(orte_buffer_t *buffer,
orte_gpr_value_t **values;
size_t i;
asprintf(&tmp_out, "%lu Values from segment %s",
(unsigned long) data->cnt, data->segment);
asprintf(&tmp_out, "%lu values going to subscription num %lu",
(unsigned long) data->cnt, (unsigned long) data->id);
orte_gpr_base_dump_load_string(buffer, &tmp_out);
if (0 < data->cnt && NULL != data->values) {
values = data->values;
for (i=0; i < data->cnt; i++) {
asprintf(&tmp_out, "\nData for value %lu going to callback num %lu",
(unsigned long) i, (unsigned long) data->cb_num);
asprintf(&tmp_out, "\nData for value %lu", (unsigned long) i);
orte_gpr_base_dump_load_string(buffer, &tmp_out);
if (NULL == values[i]) {
asprintf(&tmp_out, "\tError encountered: NULL value pointer");

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

@ -39,7 +39,7 @@ int orte_gpr_base_unpack_increment_value(orte_buffer_t *cmd, int *ret)
size_t n;
n=1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(cmd, &command, &n, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(cmd, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
@ -66,7 +66,7 @@ int orte_gpr_base_unpack_decrement_value(orte_buffer_t *cmd, int *ret)
size_t n;
n=1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(cmd, &command, &n, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(cmd, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}

4
src/mca/gpr/base/unpack_api_response/gpr_base_unpack_cleanup.c
Просмотреть файл

@ -39,7 +39,7 @@ int orte_gpr_base_unpack_cleanup_job(orte_buffer_t *cmd, int *ret)
size_t n;
n=1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(cmd, &command, &n, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(cmd, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
@ -65,7 +65,7 @@ int orte_gpr_base_unpack_cleanup_proc(orte_buffer_t *cmd, int *ret)
size_t n;
n=1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(cmd, &command, &n, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(cmd, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}

6
src/mca/gpr/base/unpack_api_response/gpr_base_unpack_del_index.c
Просмотреть файл

@ -34,7 +34,7 @@ int orte_gpr_base_unpack_delete_segment(orte_buffer_t *buffer, int *ret)
size_t n;
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
@ -60,7 +60,7 @@ int orte_gpr_base_unpack_delete_entries(orte_buffer_t *buffer, int *ret)
size_t n;
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
@ -89,7 +89,7 @@ int orte_gpr_base_unpack_index(orte_buffer_t *buffer, int *ret, size_t *cnt, cha
*cnt = 0;
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}

4
src/mca/gpr/base/unpack_api_response/gpr_base_unpack_put_get.c
Просмотреть файл

@ -39,7 +39,7 @@ int orte_gpr_base_unpack_put(orte_buffer_t *buffer, int *ret)
size_t n;
n=1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
@ -67,7 +67,7 @@ int orte_gpr_base_unpack_get(orte_buffer_t *buffer, int *ret, size_t *cnt, orte_
size_t n, num;
n=1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}

39
src/mca/gpr/base/unpack_api_response/gpr_base_unpack_subscribe.c
Просмотреть файл

@ -33,14 +33,14 @@
#include "mca/gpr/base/base.h"
int orte_gpr_base_unpack_subscribe(orte_buffer_t *buffer, int *ret, orte_gpr_notify_id_t *remote_idtag)
int orte_gpr_base_unpack_subscribe(orte_buffer_t *buffer, int *ret)
{
orte_gpr_cmd_flag_t command;
size_t n;
int rc;
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
@ -50,12 +50,6 @@ int orte_gpr_base_unpack_subscribe(orte_buffer_t *buffer, int *ret, orte_gpr_not
return ORTE_ERR_COMM_FAILURE;
}
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, remote_idtag, &n, ORTE_GPR_NOTIFY_ID))) {
ORTE_ERROR_LOG(rc);
return rc;
}
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, ret, &n, ORTE_INT))) {
ORTE_ERROR_LOG(rc);
@ -73,7 +67,7 @@ int orte_gpr_base_unpack_unsubscribe(orte_buffer_t *buffer, int *ret)
int rc;
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_PACK_CMD))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
@ -91,3 +85,30 @@ int orte_gpr_base_unpack_unsubscribe(orte_buffer_t *buffer, int *ret)
return ORTE_SUCCESS;
}
int orte_gpr_base_unpack_cancel_trigger(orte_buffer_t *buffer, int *ret)
{
orte_gpr_cmd_flag_t command;
size_t n;
int rc;
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (ORTE_GPR_CANCEL_TRIGGER_CMD != command) {
ORTE_ERROR_LOG(ORTE_ERR_COMM_FAILURE);
return ORTE_ERR_COMM_FAILURE;
}
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, ret, &n, ORTE_INT))) {
ORTE_ERROR_LOG(rc);
return rc;
}
return ORTE_SUCCESS;
}

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

@ -420,7 +420,7 @@ typedef int (*orte_gpr_base_module_index_nb_fn_t)(char *segment,
*
* @param num_trigs (IN) The number of trigger objects being provided
*
* @param **trig_value (IN) A pointer to an array of orte_gpr_value_t objects that describe the
* @param **triggers (IN) A pointer to an array of orte_gpr_trigger_t objects that describe the
* conditions (as described above) which will generate a trigger message to be sent
* to the callback function. Trigger messages include all data specified in the
* subscription objects, but do NOT include the trigger counters themselves unless
@ -444,19 +444,17 @@ typedef int (*orte_gpr_base_module_index_nb_fn_t)(char *segment,
* @endcode
*/
typedef int (*orte_gpr_base_module_subscribe_fn_t)(
orte_gpr_notify_action_t actions,
size_t num_subs,
orte_gpr_subscription_t **subscriptions,
size_t num_trigs,
orte_gpr_value_t **trig_value,
orte_gpr_notify_id_t *sub_number);
orte_gpr_trigger_t **triggers);
/*
* Cancel a subscription.
* Once a subscription has been entered on the registry, a caller may choose to permanently
* remove it at a later time. This function supports that request.
*
* @param sub_number The orte_gpr_notify_id_t value returned by the original subscribe
* @param sub_number The orte_gpr_subscription_id_t value returned by the original subscribe
* command.
*
* @retval ORTE_SUCCESS The subscription was removed.
@ -467,7 +465,26 @@ typedef int (*orte_gpr_base_module_subscribe_fn_t)(
* status_code = orte_gpr.unsubscribe(sub_number);
* @endcode
*/
typedef int (*orte_gpr_base_module_unsubscribe_fn_t)(orte_gpr_notify_id_t sub_number);
typedef int (*orte_gpr_base_module_unsubscribe_fn_t)(orte_gpr_subscription_id_t sub_number);
/*
* Cancel a trigger.
* Once a trigger has been entered on the registry, a caller may choose to permanently
* remove it at a later time. This function supports that request.
*
* @param trig_number The orte_gpr_trigger_id_t value returned by the original subscribe
* command.
*
* @retval ORTE_SUCCESS The trigger was removed.
* @retval ORTE_ERROR The trigger could not be removed - most likely caused by specifying
* a non-existent (or previously removed) trigger number.
*
* @code
* status_code = orte_gpr.cancel_trigger(trig_number);
* @endcode
*/
typedef int (*orte_gpr_base_module_cancel_trigger_fn_t)(orte_gpr_trigger_id_t trig_number);
/* Output the registry's contents to an output stream
* For debugging purposes, it is helpful to be able to obtain a complete formatted printout
@ -489,6 +506,8 @@ typedef int (*orte_gpr_base_module_dump_segments_fn_t)(int output_id);
typedef int (*orte_gpr_base_module_dump_triggers_fn_t)(int output_id);
typedef int (*orte_gpr_base_module_dump_subscriptions_fn_t)(int output_id);
typedef int (*orte_gpr_base_module_dump_callbacks_fn_t) (int output_id);
typedef int (*orte_gpr_base_module_dump_notify_msg_fn_t)(orte_gpr_notify_message_t *msg, int output_id);
@ -554,6 +573,7 @@ struct orte_gpr_base_module_1_0_0_t {
/* SUBSCRIBE OPERATIONS */
orte_gpr_base_module_subscribe_fn_t subscribe;
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;
@ -562,6 +582,7 @@ struct orte_gpr_base_module_1_0_0_t {
orte_gpr_base_module_dump_all_fn_t dump_all;
orte_gpr_base_module_dump_segments_fn_t dump_segments;
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_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;

120
src/mca/gpr/gpr_types.h
Просмотреть файл

@ -49,59 +49,42 @@ extern "C" {
/** Define the notify actions for the subscription system - can be OR'd
* to create multiple actions
*/
#define ORTE_GPR_NOTIFY_NONE (uint16_t)0x0000 /**< No trigger action */
#define ORTE_GPR_NOTIFY_VALUE_CHG_TO (uint16_t)0x0001 /**< Notifies subscriber when value changes to specified value */
#define ORTE_GPR_NOTIFY_VALUE_CHG_FRM (uint16_t)0x0002 /**< Notifies subscriber when value changes away from specified value */
#define ORTE_GPR_NOTIFY_VALUE_CHG (uint16_t)0x0003 /**< Notifies subscriber when value changes */
#define ORTE_GPR_NOTIFY_ADD_ENTRY (uint16_t)0x0004 /**< Notifies subscriber when entry added */
#define ORTE_GPR_NOTIFY_DEL_ENTRY (uint16_t)0x0008 /**< Notifies subscriber when entry deleted */
#define ORTE_GPR_NOTIFY_ALL (uint16_t)0x000f /**< Notifies subscriber upon any action */
#define ORTE_GPR_NOTIFY_PRE_EXISTING (uint16_t)0x0010 /**< Provide list of all pre-existing data */
#define ORTE_GPR_NOTIFY_ANY (uint16_t)0x00ff /**< Used to test if any action flags set */
#define ORTE_GPR_NOTIFY_NONE (uint8_t)0x00 /**< No trigger action */
#define ORTE_GPR_NOTIFY_VALUE_CHG_TO (uint8_t)0x01 /**< Notifies subscriber when value changes to specified value */
#define ORTE_GPR_NOTIFY_VALUE_CHG_FRM (uint8_t)0x02 /**< Notifies subscriber when value changes away from specified value */
#define ORTE_GPR_NOTIFY_VALUE_CHG (uint8_t)0x03 /**< Notifies subscriber when value changes */
#define ORTE_GPR_NOTIFY_ADD_ENTRY (uint8_t)0x04 /**< Notifies subscriber when entry added */
#define ORTE_GPR_NOTIFY_DEL_ENTRY (uint8_t)0x08 /**< Notifies subscriber when entry deleted */
#define ORTE_GPR_NOTIFY_ALL (uint8_t)0x0f /**< Notifies subscriber upon any action */
#define ORTE_GPR_NOTIFY_PRE_EXISTING (uint8_t)0x10 /**< Provide list of all pre-existing data */
#define ORTE_GPR_NOTIFY_STARTS_AFTER_TRIG (uint8_t)0x20 /**< Notifies are off when subscription entered - turned on when trigger fires */
#define ORTE_GPR_NOTIFY_NO_DATA_WITH_TRIG (uint8_t)0x40 /**< Do not include subscription data when initial trigger fires */
#define ORTE_GPR_NOTIFY_DELETE_AFTER_TRIG (uint8_t)0x80
#define ORTE_GPR_NOTIFY_ANY (uint8_t)0xff /**< Used to test if any action flags set */
#define ORTE_GPR_TRIG_ONE_SHOT (uint16_t)0x0100 /**< Only trigger once - then delete subscription */
#define ORTE_GPR_TRIG_AT_LEVEL (uint16_t)0x0200 /**< Trigger whenever count reaches specified level */
#define ORTE_GPR_TRIG_CMP_LEVELS (uint16_t)0x0400 /**< Trigger when all the specified values are equal */
#define ORTE_GPR_TRIG_MONITOR_ONLY (uint16_t)0x0800 /**< Monitor the provided trigger keyval - counting done by someone else */
#define ORTE_GPR_NOTIFY_STARTS_AFTER_TRIG (uint16_t)0x1000 /**< Notifies are off when subscription entered - turned on when trigger fires */
#define ORTE_GPR_TRIG_INCLUDE_DATA (uint16_t)0x2000 /**< Include the trigger data in the trigger msg */
#define ORTE_GPR_TRIG_ALL_AT (uint16_t)0xdb00 /**< Use all trig defs except include trig data with AT - a typical situation */
#define ORTE_GPR_TRIG_ALL_CMP (uint16_t)0xdd00 /**< Use all trig defs except include trig data with CMP */
#define ORTE_GPR_TRIG_ANY (uint16_t)0xff00 /**< Used to test if any trigs are set */
typedef uint8_t orte_gpr_notify_action_t;
#define ORTE_GPR_NOTIFY_ACTION_T ORTE_UINT8
typedef uint16_t orte_gpr_notify_action_t;
#define ORTE_GPR_NOTIFY_ACTION_T ORTE_UINT16
typedef size_t orte_gpr_subscription_id_t;
#define ORTE_GPR_SUBSCRIPTION_ID_T DPS_TYPE_SIZE_T
#define ORTE_GPR_SUBSCRIPTION_ID_MAX SIZE_MAX
typedef size_t orte_gpr_notify_id_t;
#define ORTE_GPR_NOTIFY_ID_T DPS_TYPE_SIZE_T
#define ORTE_GPR_NOTIFY_ID_MAX SIZE_MAX
/*
* Define flag values for remote commands - normally used internally, but required
* here to allow for decoding of notify messages
*/
#define ORTE_GPR_DELETE_SEGMENT_CMD (uint16_t)0x0001
#define ORTE_GPR_PUT_CMD (uint16_t)0x0002
#define ORTE_GPR_DELETE_ENTRIES_CMD (uint16_t)0x0004
#define ORTE_GPR_INDEX_CMD (uint16_t)0x0008
#define ORTE_GPR_SUBSCRIBE_CMD (uint16_t)0x0010
#define ORTE_GPR_UNSUBSCRIBE_CMD (uint16_t)0x0020
#define ORTE_GPR_GET_CMD (uint16_t)0x0100
#define ORTE_GPR_TEST_INTERNALS_CMD (uint16_t)0x0200
#define ORTE_GPR_NOTIFY_CMD (uint16_t)0x0400
#define ORTE_GPR_DUMP_ALL_CMD (uint16_t)0x0800
#define ORTE_GPR_DUMP_SEGMENTS_CMD (uint16_t)0x0810
#define ORTE_GPR_DUMP_TRIGGERS_CMD (uint16_t)0x0820
#define ORTE_GPR_DUMP_CALLBACKS_CMD (uint16_t)0x0830
#define ORTE_GPR_INCREMENT_VALUE_CMD (uint16_t)0x2000
#define ORTE_GPR_DECREMENT_VALUE_CMD (uint16_t)0x4000
#define ORTE_GPR_COMPOUND_CMD (uint16_t)0x8000
#define ORTE_GPR_CLEANUP_JOB_CMD (uint16_t)0x8200
#define ORTE_GPR_CLEANUP_PROC_CMD (uint16_t)0x8400
#define ORTE_GPR_ERROR (uint16_t)0xffff
#define ORTE_GPR_TRIG_ONE_SHOT (uint8_t)0x01 /**< Only trigger once - then delete subscription */
#define ORTE_GPR_TRIG_INCLUDE_DATA (uint8_t)0x02 /**< Include the trigger data in the notification msg */
#define ORTE_GPR_TRIG_AT_LEVEL (uint8_t)0x08 /**< Trigger whenever count reaches specified level */
#define ORTE_GPR_TRIG_CMP_LEVELS (uint8_t)0x80 /**< Trigger when all the specified values are equal */
#define ORTE_GPR_TRIG_ALL_AT (uint8_t)0x7f /**< Use all trig defs except include trig data with AT - a typical situation */
#define ORTE_GPR_TRIG_ALL_CMP (uint8_t)0xf7 /**< Use all trig defs except include trig data with CMP */
#define ORTE_GPR_TRIG_ANY (uint8_t)0xff /**< Used to test if any trigs are set */
typedef uint8_t orte_gpr_trigger_action_t;
#define ORTE_GPR_TRIGGER_ACTION_T ORTE_UINT8
typedef size_t orte_gpr_trigger_id_t;
#define ORTE_GPR_TRIGGER_ID_T DPS_TYPE_SIZE_T
#define ORTE_GPR_TRIGGER_ID_MAX SIZE_MAX
typedef uint16_t orte_gpr_cmd_flag_t;
#define ORTE_GPR_CMD_T ORTE_UINT16
/** Define the addressing mode bit-masks for registry operations.
*
@ -201,12 +184,10 @@ OMPI_DECLSPEC OBJ_CLASS_DECLARATION(orte_gpr_value_t);
* data from a single segment, one or more containers with one or more keyvals/container.
*/
typedef struct {
ompi_object_t super; /**< Makes this an object */
size_t cb_num; /**< Number of the subscribed data - indicates which callback to use */
orte_gpr_addr_mode_t addr_mode; /**< Address mode that was used for combining keys/tokens */
char *segment; /**< Name of the segment this came from */
size_t cnt; /**< Number of value objects returned, one per container */
orte_gpr_value_t **values; /**< Array of value objects returned */
ompi_object_t super; /**< Makes this an object */
orte_gpr_subscription_id_t id; /**< Number of the associated subscription */
size_t cnt; /**< Number of value objects returned, one per container */
orte_gpr_value_t **values; /**< Array of value objects returned */
} orte_gpr_notify_data_t;
OMPI_DECLSPEC OBJ_CLASS_DECLARATION(orte_gpr_notify_data_t);
@ -215,7 +196,6 @@ OMPI_DECLSPEC OBJ_CLASS_DECLARATION(orte_gpr_notify_data_t);
*/
typedef struct {
ompi_object_t super; /**< Make this an object */
orte_gpr_notify_id_t idtag; /**< Referenced notify request */
size_t cnt; /**< number of data objects */
orte_gpr_notify_data_t **data; /**< Contiguous array of pointers to data objects */
} orte_gpr_notify_message_t;
@ -240,18 +220,36 @@ typedef void (*orte_gpr_notify_cb_fn_t)(orte_gpr_notify_data_t *notify_data, voi
*/
typedef struct {
ompi_object_t super; /**< Makes this an object */
orte_gpr_addr_mode_t addr_mode; /**< Address mode for combining keys/tokens */
char *segment; /**< Name of the segment where the data is located */
size_t num_tokens; /**< Number of tokens used to describe data */
char **tokens; /**< List of tokens that describe the data */
size_t num_keys; /**< Number of keys describing data */
char **keys; /**< Contiguous array of keys */
char *name; /**< A unique name for this subscription - can be NULL */
orte_gpr_subscription_id_t id; /**< id number of this subscription, as assigned by system */
orte_gpr_notify_action_t action; /**< what causes subscription to fire */
size_t cnt; /**< Number of values included */
orte_gpr_value_t **values; /**< Contiguous array of pointers to value objects
describing the data to be returned */
orte_gpr_notify_cb_fn_t cbfunc; /**< Function to be called with this data */
void *user_tag; /**< User-provided tag to be used in cbfunc */
} orte_gpr_subscription_t;
OMPI_DECLSPEC OBJ_CLASS_DECLARATION(orte_gpr_subscription_t);
/** Structure for registering triggers
* A trigger causes the associated subscriptions to be executed at a specified event,
* such as when counters reach specified values. The data provided here specifies
* which objects on the registry are to be monitored, and what conditions must
* exist between those objects for the trigger to be "fired".
*/
typedef struct {
ompi_object_t super; /**< Makes this an object */
char *name; /**< A unique name for this trigger - can be NULL */
orte_gpr_trigger_id_t id; /**< id number of this trigger, as assigned by system */
orte_gpr_trigger_action_t action; /**< trigger characteristics */
size_t cnt; /**< Number of values included */
orte_gpr_value_t **values; /**< Contiguous array of pointers to value objects
describing the objects to be monitored */
} orte_gpr_trigger_t;
OMPI_DECLSPEC OBJ_CLASS_DECLARATION(orte_gpr_trigger_t);
#if defined(c_plusplus) || defined(__cplusplus)
}
#endif

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

@ -53,28 +53,19 @@ int orte_gpr_proxy_finalize(void);
* proxy-local types
*/
typedef struct {
ompi_object_t super; /**< Allows this to be an object */
size_t index; /**< Index of this callback */
orte_gpr_notify_cb_fn_t callback; /**< Function to be called for notificaiton */
void *user_tag; /**< User-provided tag for callback function */
ompi_object_t super; /**< Allows this to be an object */
orte_gpr_subscription_id_t id; /**< id of this subscription */
orte_gpr_notify_cb_fn_t callback; /**< Function to be called for notificaiton */
void *user_tag; /**< User-provided tag for callback function */
} orte_gpr_proxy_subscriber_t;
OBJ_CLASS_DECLARATION(orte_gpr_proxy_subscriber_t);
struct orte_gpr_proxy_notify_tracker_t {
ompi_object_t super; /**< Allows this to be an object */
orte_gpr_notify_id_t remote_idtag; /**< Remote ID tag of subscription */
orte_pointer_array_t *callbacks; /**< Array of registered callbacks for this subscription */
};
typedef struct orte_gpr_proxy_notify_tracker_t orte_gpr_proxy_notify_tracker_t;
OBJ_CLASS_DECLARATION(orte_gpr_proxy_notify_tracker_t);
#define ORTE_GPR_PROXY_MAX_SIZE INT32_MAX
#define ORTE_GPR_PROXY_BLOCK_SIZE 100
/*
* globals used within proxy component
*/
@ -82,7 +73,9 @@ typedef struct {
int debug;
size_t block_size;
size_t max_size;
orte_pointer_array_t *notify_tracker;
orte_gpr_subscription_id_t num_subs;
orte_pointer_array_t *subscriptions;
orte_gpr_trigger_id_t trig_cntr;
ompi_mutex_t mutex;
bool compound_cmd_mode;
orte_buffer_t *compound_cmd;
@ -160,14 +153,14 @@ int orte_gpr_proxy_get_nb(orte_gpr_addr_mode_t addr_mode,
/*
* Subscribe functions
*/
int orte_gpr_proxy_subscribe(orte_gpr_notify_action_t action,
size_t num_subs,
int orte_gpr_proxy_subscribe(size_t num_subs,
orte_gpr_subscription_t **subscriptions,
size_t num_trigs,
orte_gpr_value_t **trigs,
orte_gpr_notify_id_t *sub_number);
orte_gpr_trigger_t **trigs);
int orte_gpr_proxy_unsubscribe(orte_gpr_notify_id_t sub_number);
int orte_gpr_proxy_unsubscribe(orte_gpr_subscription_id_t sub_number);
int orte_gpr_proxy_cancel_trigger(orte_gpr_trigger_id_t trig);
/*
@ -179,6 +172,8 @@ int orte_gpr_proxy_dump_segments(int output_id);
int orte_gpr_proxy_dump_triggers(int output_id);
int orte_gpr_proxy_dump_subscriptions(int output_id);
int orte_gpr_proxy_dump_callbacks(int output_id);
int orte_gpr_proxy_dump_notify_msg(orte_gpr_notify_message_t *msg, int output_id);
@ -205,15 +200,14 @@ void orte_gpr_proxy_notify_recv(int status, orte_process_name_t* sender,
*/
int
orte_gpr_proxy_enter_notify_request(orte_gpr_notify_id_t *local_idtag,
size_t cnt, orte_gpr_subscription_t **subscriptions);
orte_gpr_proxy_enter_subscription(size_t cnt, orte_gpr_subscription_t **subscriptions);
int
orte_gpr_proxy_remove_notify_request(orte_gpr_notify_id_t local_idtag,
orte_gpr_notify_id_t *remote_idtag);
orte_gpr_proxy_remove_subscription(orte_gpr_subscription_id_t id);
int
orte_gpr_proxy_enter_trigger(size_t cnt, orte_gpr_trigger_t **triggers);
int orte_gpr_proxy_set_remote_idtag(orte_gpr_notify_id_t local_idtag,
orte_gpr_notify_id_t remote_idtag);
#if defined(c_plusplus) || defined(__cplusplus)
}

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

@ -88,6 +88,7 @@ static orte_gpr_base_module_t orte_gpr_proxy = {
/* SUBSCRIBE OPERATIONS */
orte_gpr_proxy_subscribe,
orte_gpr_proxy_unsubscribe,
orte_gpr_proxy_cancel_trigger,
/* COMPOUND COMMANDS */
orte_gpr_proxy_begin_compound_cmd,
orte_gpr_proxy_stop_compound_cmd,
@ -96,6 +97,7 @@ static orte_gpr_base_module_t orte_gpr_proxy = {
orte_gpr_proxy_dump_all,
orte_gpr_proxy_dump_segments,
orte_gpr_proxy_dump_triggers,
orte_gpr_proxy_dump_subscriptions,
orte_gpr_proxy_dump_callbacks,
orte_gpr_proxy_dump_notify_msg,
orte_gpr_proxy_dump_notify_data,
@ -122,7 +124,7 @@ static void orte_gpr_proxy_subscriber_construct(orte_gpr_proxy_subscriber_t* req
{
req->callback = NULL;
req->user_tag = NULL;
req->index = 0;
req->id = 0;
}
/* destructor - used to free any resources held by instance */
@ -138,31 +140,6 @@ OBJ_CLASS_INSTANCE(
orte_gpr_proxy_subscriber_destructor); /* destructor */
/* NOTIFY TRACKER */
/* constructor - used to initialize notify message instance */
static void orte_gpr_proxy_notify_tracker_construct(orte_gpr_proxy_notify_tracker_t* req)
{
req->remote_idtag = ORTE_GPR_NOTIFY_ID_MAX;
orte_pointer_array_init(&(req->callbacks), orte_gpr_proxy_globals.block_size,
orte_gpr_proxy_globals.max_size,
orte_gpr_proxy_globals.block_size);
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_proxy_notify_tracker_destructor(orte_gpr_proxy_notify_tracker_t* req)
{
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_proxy_notify_tracker_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_proxy_notify_tracker_construct, /* constructor */
orte_gpr_proxy_notify_tracker_destructor); /* destructor */
/*
* Open the component
*/
@ -214,49 +191,53 @@ orte_gpr_proxy_component_init(bool *allow_multi_user_threads, bool *have_hidden_
the setup and return the module */
if (NULL != orte_process_info.gpr_replica_uri) {
if (orte_gpr_proxy_globals.debug) {
ompi_output(0, "gpr_proxy_init: proxy selected");
}
/* setup the replica location */
if(ORTE_SUCCESS != (ret = orte_rml.parse_uris(orte_process_info.gpr_replica_uri, &name, NULL))) {
ORTE_ERROR_LOG(ret);
return NULL;
}
if(ORTE_SUCCESS != (ret = orte_ns.copy_process_name(&orte_process_info.gpr_replica, &name))) {
ORTE_ERROR_LOG(ret);
return NULL;
}
if (orte_gpr_proxy_globals.debug) {
ompi_output(0, "gpr_proxy_init: proxy selected");
}
/* Return a module (choose an arbitrary, positive priority --
it's only relevant compared to other ns components). If
we're not the seed, then we don't want to be selected, so
return NULL. */
*priority = 10;
/* We allow multi user threads but don't have any hidden threads */
*allow_multi_user_threads = true;
*have_hidden_threads = false;
/* setup thread locks and condition variable */
OBJ_CONSTRUCT(&orte_gpr_proxy_globals.mutex, ompi_mutex_t);
OBJ_CONSTRUCT(&orte_gpr_proxy_globals.wait_for_compound_mutex, ompi_mutex_t);
OBJ_CONSTRUCT(&orte_gpr_proxy_globals.compound_cmd_condition, ompi_condition_t);
/* initialize the registry compound mode */
orte_gpr_proxy_globals.compound_cmd_mode = false;
orte_gpr_proxy_globals.compound_cmd_waiting = 0;
orte_gpr_proxy_globals.compound_cmd = NULL;
/* initialize the notify request tracker */
if (ORTE_SUCCESS != orte_pointer_array_init(&(orte_gpr_proxy_globals.notify_tracker),
/* setup the replica location */
if(ORTE_SUCCESS != (ret = orte_rml.parse_uris(orte_process_info.gpr_replica_uri, &name, NULL))) {
ORTE_ERROR_LOG(ret);
return NULL;
}
if(ORTE_SUCCESS != (ret = orte_ns.copy_process_name(&orte_process_info.gpr_replica, &name))) {
ORTE_ERROR_LOG(ret);
return NULL;
}
/* Return a module (choose an arbitrary, positive priority --
it's only relevant compared to other ns components). If
we're not the seed, then we don't want to be selected, so
return NULL. */
*priority = 10;
/* We allow multi user threads but don't have any hidden threads */
*allow_multi_user_threads = true;
*have_hidden_threads = false;
/* setup thread locks and condition variable */
OBJ_CONSTRUCT(&orte_gpr_proxy_globals.mutex, ompi_mutex_t);
OBJ_CONSTRUCT(&orte_gpr_proxy_globals.wait_for_compound_mutex, ompi_mutex_t);
OBJ_CONSTRUCT(&orte_gpr_proxy_globals.compound_cmd_condition, ompi_condition_t);
/* initialize the registry compound mode */
orte_gpr_proxy_globals.compound_cmd_mode = false;
orte_gpr_proxy_globals.compound_cmd_waiting = 0;
orte_gpr_proxy_globals.compound_cmd = NULL;
/* initialize the subscription tracker */
if (ORTE_SUCCESS != orte_pointer_array_init(&(orte_gpr_proxy_globals.subscriptions),
orte_gpr_proxy_globals.block_size,
orte_gpr_proxy_globals.max_size,
orte_gpr_proxy_globals.block_size)) {
return NULL;
}
/* initialize the trigger counter */
orte_gpr_proxy_globals.trig_cntr = 0;
initialized = true;
return &orte_gpr_proxy;
} else {
@ -305,13 +286,11 @@ void orte_gpr_proxy_notify_recv(int status, orte_process_name_t* sender,
void* cbdata)
{
orte_gpr_cmd_flag_t command;
orte_gpr_notify_id_t id_tag;
orte_gpr_notify_data_t **data;
orte_gpr_proxy_notify_tracker_t *trackptr;
orte_gpr_proxy_subscriber_t **subs;
orte_gpr_proxy_subscriber_t *sub;
size_t n;
int rc;
size_t num_msgs, cnt, i, j, k;
size_t cnt, i;
if (orte_gpr_proxy_globals.debug) {
ompi_output(0, "[%lu,%lu,%lu] gpr proxy: received trigger message",
@ -330,60 +309,46 @@ void orte_gpr_proxy_notify_recv(int status, orte_process_name_t* sender,
}
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &num_msgs, &n, ORTE_SIZE))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &cnt, &n, ORTE_SIZE))) {
ORTE_ERROR_LOG(rc);
goto RETURN_ERROR;
}
for (k=0; k < num_msgs; k++) {
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &id_tag, &n, ORTE_GPR_NOTIFY_ID))) {
ORTE_ERROR_LOG(rc);
goto RETURN_ERROR;
}
/* locate request corresponding to this message */
trackptr = (orte_gpr_proxy_notify_tracker_t*)((orte_gpr_proxy_globals.notify_tracker)->addr[id_tag]);
if (NULL == trackptr) {
ORTE_ERROR_LOG(ORTE_ERR_COMM_FAILURE);
if (cnt > 0) {
/* allocate space for the array */
data = (orte_gpr_notify_data_t**)malloc(cnt * sizeof(orte_gpr_notify_data_t*));
if (NULL == data) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
goto RETURN_ERROR;
}
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, &cnt, &n, ORTE_SIZE))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, data, &cnt, ORTE_GPR_NOTIFY_DATA))) {
ORTE_ERROR_LOG(rc);
goto RETURN_ERROR;
}
if(cnt > 0) {
/* allocate space for the array */
data = (orte_gpr_notify_data_t**)malloc(cnt * sizeof(orte_gpr_notify_data_t*));
if (NULL == data) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
goto RETURN_ERROR;
}
if (ORTE_SUCCESS != (rc = orte_dps.unpack(buffer, data, &cnt, ORTE_GPR_NOTIFY_DATA))) {
ORTE_ERROR_LOG(rc);
goto RETURN_ERROR;
}
for (i=0; i < cnt; i++) {
/* locate the data callback */
subs = (orte_gpr_proxy_subscriber_t**)((trackptr->callbacks)->addr);
for (j=0; j < (trackptr->callbacks)->size; j++) {
if (NULL != subs[j] && subs[j]->index == data[i]->cb_num) {
/* process request */
subs[j]->callback(data[i], subs[j]->user_tag);
break;
}
}
for (i=0; i < cnt; i++) {
/* process request */
if (data[i]->id > orte_gpr_proxy_globals.num_subs) {
ORTE_ERROR_LOG(ORTE_ERR_GPR_DATA_CORRUPT);
OBJ_RELEASE(data[i]);
continue;
}
sub = (orte_gpr_proxy_globals.subscriptions)->addr[data[i]->id];
if (NULL == sub) {
ORTE_ERROR_LOG(ORTE_ERR_GPR_DATA_CORRUPT);
} else {
sub->callback(data[i], sub->user_tag);
}
OBJ_RELEASE(data[i]);
}
/* release data */
free(data);
}
RETURN_ERROR:
RETURN_ERROR:
/* reissue non-blocking receive */
orte_rml.recv_buffer_nb(ORTE_RML_NAME_ANY, ORTE_RML_TAG_GPR_NOTIFY, 0, orte_gpr_proxy_notify_recv, NULL);

61
src/mca/gpr/proxy/gpr_proxy_dump.c
Просмотреть файл

@ -228,6 +228,67 @@ int orte_gpr_proxy_dump_triggers(int output_id)
return rc;
}
int orte_gpr_proxy_dump_subscriptions(int output_id)
{
orte_gpr_cmd_flag_t command;
orte_buffer_t *cmd;
orte_buffer_t *answer;
int rc;
size_t n;
if (orte_gpr_proxy_globals.compound_cmd_mode) {
return orte_gpr_base_pack_dump_subscriptions(orte_gpr_proxy_globals.compound_cmd);
}
cmd = OBJ_NEW(orte_buffer_t);
if (NULL == cmd) { /* got a problem */
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_dump_subscriptions(cmd))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(cmd);
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);
return ORTE_ERR_COMM_FAILURE;
}
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);
return ORTE_ERR_COMM_FAILURE;
}
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(answer, &command, &n, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(answer);
return rc;
}
if (ORTE_GPR_DUMP_SUBSCRIPTIONS_CMD != command) {
ORTE_ERROR_LOG(ORTE_ERR_COMM_FAILURE);
OBJ_RELEASE(answer);
return ORTE_ERR_COMM_FAILURE;
}
if (ORTE_SUCCESS != (rc = orte_gpr_base_print_dump(answer, output_id))) {
ORTE_ERROR_LOG(rc);
}
OBJ_RELEASE(answer);
return rc;
}
int orte_gpr_proxy_dump_callbacks(int output_id)
{
orte_gpr_cmd_flag_t command;

69
src/mca/gpr/proxy/gpr_proxy_internals.c
Просмотреть файл

@ -37,47 +37,26 @@
#include "gpr_proxy.h"
int
orte_gpr_proxy_enter_notify_request(orte_gpr_notify_id_t *local_idtag,
size_t cnt, orte_gpr_subscription_t **subscriptions)
orte_gpr_proxy_enter_subscription(size_t cnt, orte_gpr_subscription_t **subscriptions)
{
orte_gpr_proxy_notify_tracker_t *trackptr;
orte_gpr_proxy_subscriber_t *sub;
size_t idtag, i;
size_t i, id;
*local_idtag = ORTE_GPR_NOTIFY_ID_MAX;
trackptr = OBJ_NEW(orte_gpr_proxy_notify_tracker_t);
if (NULL == trackptr) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trackptr->remote_idtag = ORTE_GPR_NOTIFY_ID_MAX;
for (i=0; i < cnt; i++) {
sub = OBJ_NEW(orte_gpr_proxy_subscriber_t);
if (NULL == sub) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub->index = i;
sub->callback = subscriptions[i]->cbfunc;
sub->user_tag = subscriptions[i]->user_tag;
if (0 > orte_pointer_array_add(&idtag, trackptr->callbacks, sub)) {
if (0 > orte_pointer_array_add(&id, orte_gpr_proxy_globals.subscriptions, sub)) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
}
if (0 > orte_pointer_array_add(&idtag, orte_gpr_proxy_globals.notify_tracker, trackptr)) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
*local_idtag = idtag;
if (orte_gpr_proxy_globals.debug) {
ompi_output(0, "[%lu,%lu,%lu] enter_notify_request: tracker %d created",
ORTE_NAME_ARGS(orte_process_info.my_name), idtag);
sub->id = (orte_gpr_subscription_id_t)id;
subscriptions[i]->id = sub->id;
(orte_gpr_proxy_globals.num_subs)++;
}
return ORTE_SUCCESS;
@ -85,32 +64,32 @@ orte_gpr_proxy_enter_notify_request(orte_gpr_notify_id_t *local_idtag,
int
orte_gpr_proxy_remove_notify_request(orte_gpr_notify_id_t local_idtag,
orte_gpr_notify_id_t *remote_idtag)
orte_gpr_proxy_enter_trigger(size_t cnt, orte_gpr_trigger_t **trigs)
{
orte_gpr_proxy_notify_tracker_t *trackptr;
trackptr = (orte_gpr_proxy_notify_tracker_t*)((orte_gpr_proxy_globals.notify_tracker)->addr[local_idtag]);
if (NULL == trackptr) {
return ORTE_ERR_BAD_PARAM;
size_t i;
for (i=0; i < cnt; i++) {
if (ORTE_GPR_TRIGGER_ID_MAX-1 > orte_gpr_proxy_globals.trig_cntr) {
trigs[i]->id = orte_gpr_proxy_globals.trig_cntr;
(orte_gpr_proxy_globals.trig_cntr)++;
} else {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
}
*remote_idtag = trackptr->remote_idtag;
OBJ_RELEASE(trackptr);
orte_pointer_array_set_item(orte_gpr_proxy_globals.notify_tracker, local_idtag, NULL);
return ORTE_SUCCESS;
}
int orte_gpr_proxy_set_remote_idtag(orte_gpr_notify_id_t local_idtag, orte_gpr_notify_id_t remote_idtag)
int
orte_gpr_proxy_remove_subscription(orte_gpr_subscription_id_t id)
{
orte_gpr_proxy_notify_tracker_t *trackptr;
trackptr = (orte_gpr_proxy_notify_tracker_t*)((orte_gpr_proxy_globals.notify_tracker)->addr[local_idtag]);
if (NULL == trackptr) {
return ORTE_ERR_BAD_PARAM;
if (NULL != (orte_gpr_proxy_globals.subscriptions)->addr[id]) {
OBJ_RELEASE((orte_gpr_proxy_globals.subscriptions)->addr[id]);
orte_pointer_array_set_item(orte_gpr_proxy_globals.subscriptions, (size_t)id, NULL);
}
trackptr->remote_idtag = remote_idtag;
return ORTE_SUCCESS;
}

334
src/mca/gpr/proxy/gpr_proxy_subscribe.c
Просмотреть файл

@ -38,176 +38,160 @@
#include "gpr_proxy.h"
int
orte_gpr_proxy_subscribe(orte_gpr_notify_action_t action,
size_t num_subs,
orte_gpr_proxy_subscribe(size_t num_subs,
orte_gpr_subscription_t **subscriptions,
size_t num_trigs,
orte_gpr_value_t **trigs,
orte_gpr_notify_id_t *sub_number)
orte_gpr_trigger_t **trigs)
{
orte_buffer_t *cmd;
orte_buffer_t *answer;
int rc = ORTE_SUCCESS, ret;
orte_gpr_notify_id_t idtag, remote_idtag;
*sub_number = ORTE_GPR_NOTIFY_ID_MAX;
size_t i;
/* need to protect against errors */
if (NULL == subscriptions) {
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
return ORTE_ERR_BAD_PARAM;
}
/* if this has a trigger in it, must specify the trigger condition */
if (ORTE_GPR_TRIG_ANY & action && NULL == trigs) {
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
return ORTE_ERR_BAD_PARAM;
OMPI_THREAD_LOCK(&orte_gpr_proxy_globals.mutex);
/* store callback function and user_tag in local list for lookup
* generate id_tag to send to replica to identify lookup entry
* for each subscription
*/
if (ORTE_SUCCESS != (rc = orte_gpr_proxy_enter_subscription(
num_subs, subscriptions))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return rc;
}
/* if any triggers were provided, get id tags for them */
if (ORTE_SUCCESS != (rc = orte_gpr_proxy_enter_trigger(
num_trigs, trigs))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return rc;
}
/* check for compound cmd mode - if on, just pack the info into the
* compound cmd buffer and return
*/
if (orte_gpr_proxy_globals.compound_cmd_mode) {
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_subscribe(orte_gpr_proxy_globals.compound_cmd,
action, num_subs, subscriptions,
num_subs, subscriptions,
num_trigs, trigs))) {
ORTE_ERROR_LOG(rc);
return rc;
goto ERROR;
}
OMPI_THREAD_LOCK(&orte_gpr_proxy_globals.mutex);
/* store callback function and user_tag in local list for lookup */
/* generate id_tag to send to replica to identify lookup entry */
if (ORTE_SUCCESS != (rc = orte_gpr_proxy_enter_notify_request(&idtag,
num_subs, subscriptions))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return rc;
}
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
if (ORTE_SUCCESS != (rc = orte_dps.pack(orte_gpr_proxy_globals.compound_cmd,
&idtag, 1, ORTE_GPR_NOTIFY_ID))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* done */
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return ORTE_SUCCESS;
}
/* if compound cmd not on, get new buffer to transmit command to replica */
cmd = OBJ_NEW(orte_buffer_t);
if (NULL == cmd) {
ORTE_ERROR_LOG(rc);
return ORTE_ERR_OUT_OF_RESOURCE;
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto ERROR;
}
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_subscribe(cmd, action,
/* pack the command and send it */
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_subscribe(cmd,
num_subs, subscriptions,
num_trigs, trigs))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(cmd);
return rc;
goto ERROR;
}
OMPI_THREAD_LOCK(&orte_gpr_proxy_globals.mutex);
/* store callback function and user_tag in local list for lookup */
/* generate id_tag to send to replica to identify lookup entry */
if (ORTE_SUCCESS != (rc = orte_gpr_proxy_enter_notify_request(&idtag,
num_subs, subscriptions))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
OBJ_RELEASE(cmd);
return rc;
}
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
if (ORTE_SUCCESS != (rc = orte_dps.pack(cmd, &idtag, 1, ORTE_GPR_NOTIFY_ID))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(cmd);
return rc;
}
if (orte_gpr_proxy_globals.debug) {
ompi_output(0, "[%lu,%lu,%lu] gpr proxy subscribe: register subscribe for local idtag %d",
ORTE_NAME_ARGS(orte_process_info.my_name), (int)idtag);
}
if (0 > orte_rml.send_buffer(orte_process_info.gpr_replica, cmd, ORTE_RML_TAG_GPR, 0)) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_LOCK(&orte_gpr_proxy_globals.mutex);
orte_gpr_proxy_remove_notify_request(idtag, &remote_idtag);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return ORTE_ERR_COMM_FAILURE;
ORTE_ERROR_LOG(ORTE_ERR_COMM_FAILURE);
OBJ_RELEASE(cmd);
rc = ORTE_ERR_COMM_FAILURE;
goto ERROR;
}
OBJ_RELEASE(cmd);
/* get buffer for reply from replica and get it */
answer = OBJ_NEW(orte_buffer_t);
if (NULL == answer) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_LOCK(&orte_gpr_proxy_globals.mutex);
orte_gpr_proxy_remove_notify_request(idtag, &remote_idtag);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return ORTE_ERR_OUT_OF_RESOURCE;
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto ERROR;
}
if (0 > orte_rml.recv_buffer(orte_process_info.gpr_replica, answer, ORTE_RML_TAG_GPR)) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_LOCK(&orte_gpr_proxy_globals.mutex);
orte_gpr_proxy_remove_notify_request(idtag, &remote_idtag);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
OBJ_RELEASE(answer);
return ORTE_ERR_COMM_FAILURE;
ORTE_ERROR_LOG(ORTE_ERR_COMM_FAILURE);
OBJ_RELEASE(answer);
rc = ORTE_ERR_COMM_FAILURE;
goto ERROR;
}
if (ORTE_SUCCESS != (rc = orte_gpr_base_unpack_subscribe(answer, &ret, &remote_idtag))) {
/* unpack the reply - should contain an echo of the subscribe command
* (to ensure the handshake) and the status code of the request. The
* unpack function checks the command for us - will return an error
* if the command was wrong - so all we have to do is record an
* error if the unpack command doesn't return "success", and return
* the resulting status code
*/
if (ORTE_SUCCESS != (rc = orte_gpr_base_unpack_subscribe(answer, &ret))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_LOCK(&orte_gpr_proxy_globals.mutex);
orte_gpr_proxy_remove_notify_request(idtag, &remote_idtag);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return rc;
OBJ_RELEASE(answer);
goto ERROR;
}
/* set the remote id tag field */
if (ORTE_SUCCESS != (rc = orte_gpr_proxy_set_remote_idtag(idtag, remote_idtag))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_LOCK(&orte_gpr_proxy_globals.mutex);
orte_gpr_proxy_remove_notify_request(idtag, &remote_idtag);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return rc;
}
*sub_number = idtag;
return ret;
}
int orte_gpr_proxy_unsubscribe(orte_gpr_notify_id_t sub_number)
{
orte_buffer_t *cmd;
orte_buffer_t *answer;
int rc, ret;
orte_gpr_notify_id_t remote_idtag;
if (orte_gpr_proxy_globals.compound_cmd_mode) {
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_unsubscribe(orte_gpr_proxy_globals.compound_cmd,
sub_number))) {
ORTE_ERROR_LOG(rc);
return rc;
}
OMPI_THREAD_LOCK(&orte_gpr_proxy_globals.mutex);
/* remove the notify tag */
if (ORTE_SUCCESS != (rc = orte_gpr_proxy_remove_notify_request(sub_number, &remote_idtag))) {
OBJ_RELEASE(answer);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return ORTE_SUCCESS;
/* if an error was encountered during processing this request, we need to
* remove the subscriptions from the subscription tracking system. do this
* and then exit.
* NOTE: there is no corresponding function to remove triggers from the local
* trigger tracking system as nothing is stored on it - we just keep track
* of how many triggers were generated so we can identify them, and the
* numbers are NOT re-used.
*/
ERROR:
for (i=0; i < num_subs; i++) {
if (ORTE_SUCCESS != (rc = orte_gpr_proxy_remove_subscription(subscriptions[i]->id))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return rc;
}
if (ORTE_SUCCESS != (rc = orte_dps.pack(orte_gpr_proxy_globals.compound_cmd,
&remote_idtag, 1, ORTE_GPR_NOTIFY_ID))) {
}
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return rc;
}
int orte_gpr_proxy_unsubscribe(orte_gpr_subscription_id_t sub_number)
{
orte_buffer_t *cmd;
orte_buffer_t *answer;
int rc, ret;
OMPI_THREAD_LOCK(&orte_gpr_proxy_globals.mutex);
/* remove the specified subscription from the local tracker */
if (ORTE_SUCCESS != (rc = orte_gpr_proxy_remove_subscription(sub_number))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return rc;
}
/* if in compound cmd mode, then just pack the command into
* that buffer and return
*/
if (orte_gpr_proxy_globals.compound_cmd_mode) {
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_unsubscribe(orte_gpr_proxy_globals.compound_cmd,
sub_number))) {
ORTE_ERROR_LOG(rc);
}
@ -215,53 +199,143 @@ int orte_gpr_proxy_unsubscribe(orte_gpr_notify_id_t sub_number)
return rc;
}
/* if not in compound cmd mode, then init a new buffer to
* transmit the command
*/
cmd = OBJ_NEW(orte_buffer_t);
if (NULL == cmd) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return ORTE_ERR_OUT_OF_RESOURCE;
}
OMPI_THREAD_LOCK(&orte_gpr_proxy_globals.mutex);
if (ORTE_SUCCESS != (rc = orte_gpr_proxy_remove_notify_request(sub_number, &remote_idtag))) {
/* pack and transmit the command */
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_unsubscribe(cmd, sub_number))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(cmd);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return rc;
}
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_unsubscribe(cmd, remote_idtag))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(cmd);
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);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return ORTE_ERR_COMM_FAILURE;
}
OBJ_RELEASE(cmd);
/* init a buffer to receive the replica's reply */
answer = OBJ_NEW(orte_buffer_t);
if (NULL == answer) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
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);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return ORTE_ERR_COMM_FAILURE;
}
/* unpack the response. This function will automatically check to ensure
* that the command in the response matches the unsubscribe command, thus
* verifying the handshake. If the function returns "success", then the
* commands match and the buffer could be unpacked - all we need do, then
* is return the replica's response code
*/
if (ORTE_SUCCESS != (rc = orte_gpr_base_unpack_unsubscribe(answer, &ret))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(answer);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return rc;
}
OBJ_RELEASE(answer);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return ret;
}
int orte_gpr_proxy_cancel_trigger(orte_gpr_trigger_id_t trig)
{
orte_buffer_t *cmd;
orte_buffer_t *answer;
int rc, ret;
OMPI_THREAD_LOCK(&orte_gpr_proxy_globals.mutex);
/* if the compound cmd mode is on, pack the command into that buffer
* and return
*/
if (orte_gpr_proxy_globals.compound_cmd_mode) {
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_cancel_trigger(
orte_gpr_proxy_globals.compound_cmd, trig))) {
ORTE_ERROR_LOG(rc);
}
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return rc;
}
/* if compound cmd mode is off, init a new buffer for transmitting the
* command to the replica
*/
cmd = OBJ_NEW(orte_buffer_t);
if (NULL == cmd) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* pack the trigger number and transmit the command */
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_cancel_trigger(cmd, trig))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(cmd);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
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);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return ORTE_ERR_COMM_FAILURE;
}
OBJ_RELEASE(cmd);
/* init a buffer to receive the replica's response */
answer = OBJ_NEW(orte_buffer_t);
if (NULL == answer) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
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);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return ORTE_ERR_COMM_FAILURE;
}
/* unpack the response. This function will automatically check to ensure
* that the command in the response matches the cancel_trigger command, thus
* verifying the handshake. If the function returns "success", then the
* commands match and the buffer could be unpacked - all we need do, then
* is return the replica's response code
*/
if (ORTE_SUCCESS != (rc = orte_gpr_base_unpack_unsubscribe(answer, &ret))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(answer);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return rc;
}
OBJ_RELEASE(answer);
OMPI_THREAD_UNLOCK(&orte_gpr_proxy_globals.mutex);
return ret;
}

2
src/mca/gpr/replica/Makefile.am
Просмотреть файл

@ -35,6 +35,7 @@ endif
mcacomponentdir = $(libdir)/openmpi
mcacomponent_LTLIBRARIES = $(component_install)
mca_gpr_replica_la_SOURCES = gpr_replica.h \
gpr_replica_class_instances.h \
gpr_replica_component.c
mca_gpr_replica_la_LIBADD = \
@ -46,6 +47,7 @@ mca_gpr_replica_la_LDFLAGS = -module -avoid-version
noinst_LTLIBRARIES = $(component_noinst)
libmca_gpr_replica_la_SOURCES = gpr_replica.h \
gpr_replica_class_instances.h \
gpr_replica_component.c
libmca_gpr_replica_la_LIBADD = \
api_layer/libmca_gpr_replica_api.la \

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

@ -113,15 +113,14 @@ int orte_gpr_replica_get_nb(orte_gpr_addr_mode_t addr_mode,
/*
* Subscribe functions
*/
int orte_gpr_replica_subscribe(orte_gpr_notify_action_t action,
size_t num_subs,
int orte_gpr_replica_subscribe(size_t num_subs,
orte_gpr_subscription_t **subscriptions,
size_t num_trigs,
orte_gpr_value_t **trigs,
orte_gpr_notify_id_t *sub_number);
orte_gpr_trigger_t **trigs);
int orte_gpr_replica_unsubscribe(orte_gpr_notify_id_t sub_number);
int orte_gpr_replica_unsubscribe(orte_gpr_subscription_id_t sub_number);
int orte_gpr_replica_cancel_trigger(orte_gpr_trigger_id_t trig);
/*
* Diagnostic functions
@ -132,6 +131,8 @@ int orte_gpr_replica_dump_segments(int output_id);
int orte_gpr_replica_dump_triggers(int output_id);
int orte_gpr_replica_dump_subscriptions(int output_id);
int orte_gpr_replica_dump_callbacks(int output_id);
int orte_gpr_replica_dump_notify_msg(orte_gpr_notify_message_t *msg, int output_id);

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

@ -44,14 +44,6 @@ int orte_gpr_replica_increment_value(orte_gpr_value_t *value)
return ORTE_ERR_BAD_PARAM;
}
if (orte_gpr_replica_globals.compound_cmd_mode) {
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_increment_value(
orte_gpr_replica_globals.compound_cmd, value))) {
ORTE_ERROR_LOG(rc);
}
return rc;
}
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
/* find the segment */
@ -81,14 +73,12 @@ int orte_gpr_replica_increment_value(orte_gpr_value_t *value)
if (ORTE_SUCCESS == rc) {
if (ORTE_SUCCESS !=
(rc = orte_gpr_replica_check_subscriptions(seg))) {
(rc = orte_gpr_replica_check_events())) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
if (!orte_gpr_replica.processing_callbacks) {
rc = orte_gpr_replica_process_callbacks();
}
rc = orte_gpr_replica_process_callbacks();
}
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
@ -108,14 +98,6 @@ int orte_gpr_replica_decrement_value(orte_gpr_value_t *value)
return ORTE_ERR_BAD_PARAM;
}
if (orte_gpr_replica_globals.compound_cmd_mode) {
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_decrement_value(
orte_gpr_replica_globals.compound_cmd, value))) {
ORTE_ERROR_LOG(rc);
}
return rc;
}
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
/* find the segment */
@ -145,14 +127,12 @@ int orte_gpr_replica_decrement_value(orte_gpr_value_t *value)
if (ORTE_SUCCESS == rc) {
if (ORTE_SUCCESS !=
(rc = orte_gpr_replica_check_subscriptions(seg))) {
(rc = orte_gpr_replica_check_events())) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
if (!orte_gpr_replica.processing_callbacks) {
rc = orte_gpr_replica_process_callbacks();
}
rc = orte_gpr_replica_process_callbacks();
}
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);

12
src/mca/gpr/replica/api_layer/gpr_replica_cleanup_api.c
Просмотреть файл

@ -46,6 +46,12 @@ int orte_gpr_replica_cleanup_job(orte_jobid_t jobid)
return rc;
}
if (ORTE_SUCCESS != (rc = orte_gpr_replica_check_events())) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
rc = orte_gpr_replica_process_callbacks();
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
@ -67,6 +73,12 @@ int orte_gpr_replica_cleanup_proc(orte_process_name_t *proc)
return rc;
}
if (ORTE_SUCCESS != (rc = orte_gpr_replica_check_events())) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
rc = orte_gpr_replica_process_callbacks();
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);

94
src/mca/gpr/replica/api_layer/gpr_replica_compound_cmd_api.c
Просмотреть файл

@ -25,109 +25,25 @@
#include "orte_config.h"
#include "dps/dps.h"
#include "util/output.h"
#include "util/proc_info.h"
#include "mca/ns/ns_types.h"
#include "mca/errmgr/errmgr.h"
#include "mca/gpr/replica/gpr_replica.h"
#include "mca/gpr/replica/communications/gpr_replica_comm.h"
#include "gpr_replica_api.h"
/* COMPOUND COMMANDS ARE NOT USED ON THE REPLICA
* Any process co-located with the replica will "drive" the registry
* directly
*/
int orte_gpr_replica_begin_compound_cmd(void)
{
orte_gpr_cmd_flag_t command;
int rc;
command = ORTE_GPR_COMPOUND_CMD;
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.wait_for_compound_mutex);
while (orte_gpr_replica_globals.compound_cmd_mode) {
orte_gpr_replica_globals.compound_cmd_waiting++;
ompi_condition_wait(&orte_gpr_replica_globals.compound_cmd_condition,
&orte_gpr_replica_globals.wait_for_compound_mutex);
orte_gpr_replica_globals.compound_cmd_waiting--;
}
orte_gpr_replica_globals.compound_cmd_mode = true;
if (NULL != orte_gpr_replica_globals.compound_cmd) {
OBJ_RELEASE(orte_gpr_replica_globals.compound_cmd);
}
orte_gpr_replica_globals.compound_cmd = OBJ_NEW(orte_buffer_t);
if (NULL == orte_gpr_replica_globals.compound_cmd) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
orte_gpr_replica_globals.compound_cmd_mode = false;
return ORTE_ERR_OUT_OF_RESOURCE;
}
if (ORTE_SUCCESS != (rc = orte_dps.pack(orte_gpr_replica_globals.compound_cmd, &command,
1, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
orte_gpr_replica_globals.compound_cmd_mode = false;
OBJ_RELEASE(orte_gpr_replica_globals.compound_cmd);
return rc;
}
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.wait_for_compound_mutex);
return ORTE_SUCCESS;
}
int orte_gpr_replica_stop_compound_cmd(void)
{
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.wait_for_compound_mutex);
orte_gpr_replica_globals.compound_cmd_mode = false;
if (NULL != orte_gpr_replica_globals.compound_cmd) {
OBJ_RELEASE(orte_gpr_replica_globals.compound_cmd);
}
if (orte_gpr_replica_globals.compound_cmd_waiting) {
ompi_condition_signal(&orte_gpr_replica_globals.compound_cmd_condition);
}
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.wait_for_compound_mutex);
return ORTE_SUCCESS;
}
int orte_gpr_replica_exec_compound_cmd(void)
{
int rc;
orte_buffer_t *answer;
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "[%lu,%lu,%lu] Executing compound command",
ORTE_NAME_ARGS(orte_process_info.my_name));
}
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.wait_for_compound_mutex);
if (ORTE_SUCCESS != (rc = orte_gpr_replica_process_command_buffer(orte_gpr_replica_globals.compound_cmd,
NULL, &answer))) {
ORTE_ERROR_LOG(rc);
}
orte_gpr_replica_globals.compound_cmd_mode = false;
if (NULL != orte_gpr_replica_globals.compound_cmd) { /* shouldn't be any way this could be true, but just to be safe... */
OBJ_RELEASE(orte_gpr_replica_globals.compound_cmd);
}
if (orte_gpr_replica_globals.compound_cmd_waiting) {
ompi_condition_signal(&orte_gpr_replica_globals.compound_cmd_condition);
}
if (ORTE_SUCCESS == rc && !orte_gpr_replica.processing_callbacks) {
rc = orte_gpr_replica_process_callbacks();
}
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.wait_for_compound_mutex);
return rc;
return ORTE_SUCCESS;
}

21
src/mca/gpr/replica/api_layer/gpr_replica_del_index_api.c
Просмотреть файл

@ -43,10 +43,6 @@ int orte_gpr_replica_delete_segment(char *segment)
return ORTE_ERROR;
}
if (orte_gpr_replica_globals.compound_cmd_mode) {
return orte_gpr_base_pack_delete_segment(orte_gpr_replica_globals.compound_cmd, segment);
}
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
/* locate the segment */
@ -83,14 +79,6 @@ int orte_gpr_replica_delete_entries(orte_gpr_addr_mode_t addr_mode,
return ORTE_ERROR;
}
if (orte_gpr_replica_globals.compound_cmd_mode) {
rc = orte_gpr_base_pack_delete_entries(orte_gpr_replica_globals.compound_cmd,
addr_mode, segment, tokens, keys);
if (ORTE_SUCCESS != rc)
ORTE_ERROR_LOG(rc);
return rc;
}
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
/* locate the segment */
@ -114,7 +102,7 @@ int orte_gpr_replica_delete_entries(orte_gpr_addr_mode_t addr_mode,
key_itags, num_keys);
if (ORTE_SUCCESS == rc) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_check_subscriptions(seg))) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_check_events())) {
ORTE_ERROR_LOG(rc);
}
}
@ -127,7 +115,7 @@ int orte_gpr_replica_delete_entries(orte_gpr_addr_mode_t addr_mode,
free(key_itags);
}
if (ORTE_SUCCESS == rc && !orte_gpr_replica.processing_callbacks) {
if (ORTE_SUCCESS == rc) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_process_callbacks())) {
ORTE_ERROR_LOG(rc);
}
@ -153,11 +141,6 @@ int orte_gpr_replica_index(char *segment, size_t *cnt, char **index)
orte_gpr_replica_segment_t *seg=NULL;
int rc;
if (orte_gpr_replica_globals.compound_cmd_mode) {
rc = orte_gpr_base_pack_index(orte_gpr_replica_globals.compound_cmd, segment);
return rc;
}
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
if (NULL == segment) { /* want global level index */

59
src/mca/gpr/replica/api_layer/gpr_replica_dump_api.c
Просмотреть файл

@ -46,14 +46,6 @@ int orte_gpr_replica_dump_all(int output_id)
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
if (orte_gpr_replica_globals.compound_cmd_mode) {
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_dump_all(orte_gpr_replica_globals.compound_cmd))) {
ORTE_ERROR_LOG(rc);
}
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
buffer = OBJ_NEW(orte_buffer_t);
if (NULL == buffer) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
@ -86,14 +78,6 @@ int orte_gpr_replica_dump_segments(int output_id)
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
if (orte_gpr_replica_globals.compound_cmd_mode) {
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_dump_segments(orte_gpr_replica_globals.compound_cmd))) {
ORTE_ERROR_LOG(rc);
}
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
buffer = OBJ_NEW(orte_buffer_t);
if (NULL == buffer) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
@ -126,14 +110,6 @@ int orte_gpr_replica_dump_triggers(int output_id)
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
if (orte_gpr_replica_globals.compound_cmd_mode) {
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_dump_triggers(orte_gpr_replica_globals.compound_cmd))) {
ORTE_ERROR_LOG(rc);
}
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
buffer = OBJ_NEW(orte_buffer_t);
if (NULL == buffer) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
@ -154,6 +130,33 @@ int orte_gpr_replica_dump_triggers(int output_id)
return rc;
}
int orte_gpr_replica_dump_subscriptions(int output_id)
{
orte_buffer_t *buffer;
int rc;
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
buffer = OBJ_NEW(orte_buffer_t);
if (NULL == buffer) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
if (ORTE_SUCCESS != (rc = orte_gpr_replica_dump_subscriptions_fn(buffer))) {
ORTE_ERROR_LOG(rc);
}
if (ORTE_SUCCESS == rc) {
orte_gpr_base_print_dump(buffer, output_id);
}
OBJ_RELEASE(buffer);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
int orte_gpr_replica_dump_callbacks(int output_id)
{
orte_buffer_t *buffer;
@ -166,14 +169,6 @@ int orte_gpr_replica_dump_callbacks(int output_id)
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
if (orte_gpr_replica_globals.compound_cmd_mode) {
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_dump_callbacks(orte_gpr_replica_globals.compound_cmd))) {
ORTE_ERROR_LOG(rc);
}
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
buffer = OBJ_NEW(orte_buffer_t);
if (NULL == buffer) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);

13
src/mca/gpr/replica/api_layer/gpr_replica_put_get_api.c
Просмотреть файл

@ -49,10 +49,6 @@ int orte_gpr_replica_put(size_t cnt, orte_gpr_value_t **values)
return ORTE_ERROR;
}
if (orte_gpr_replica_globals.compound_cmd_mode) {
return orte_gpr_base_pack_put(orte_gpr_replica_globals.compound_cmd, cnt, values);
}
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
for (i=0; i < cnt; i++) {
@ -87,7 +83,7 @@ int orte_gpr_replica_put(size_t cnt, orte_gpr_value_t **values)
goto CLEANUP;
}
if (ORTE_SUCCESS != (rc = orte_gpr_replica_check_subscriptions(seg))) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_check_events())) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
@ -104,7 +100,7 @@ CLEANUP:
free(itags);
}
if (ORTE_SUCCESS == rc && !orte_gpr_replica.processing_callbacks) {
if (ORTE_SUCCESS == rc) {
rc = orte_gpr_replica_process_callbacks();
}
@ -139,11 +135,6 @@ int orte_gpr_replica_get(orte_gpr_addr_mode_t addr_mode,
return ORTE_ERR_BAD_PARAM;
}
if (orte_gpr_replica_globals.compound_cmd_mode) {
return orte_gpr_base_pack_get(orte_gpr_replica_globals.compound_cmd,
addr_mode, segment, tokens, keys);
}
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
/* find the segment */

102
src/mca/gpr/replica/api_layer/gpr_replica_subscribe_api.c
Просмотреть файл

@ -33,15 +33,12 @@
#include "gpr_replica_api.h"
int
orte_gpr_replica_subscribe(orte_gpr_notify_action_t action,
size_t num_subs,
orte_gpr_replica_subscribe(size_t num_subs,
orte_gpr_subscription_t **subscriptions,
size_t num_trigs,
orte_gpr_value_t **trigs,
orte_gpr_notify_id_t *sub_number)
orte_gpr_trigger_t **trigs)
{
int rc;
orte_gpr_notify_id_t idtag;
/* protect against errors */
if (NULL == subscriptions) {
@ -49,58 +46,40 @@ orte_gpr_replica_subscribe(orte_gpr_notify_action_t action,
return ORTE_ERR_BAD_PARAM;
}
/* if this has a trigger in it, must specify the trigger condition */
if (ORTE_GPR_TRIG_ANY & action && NULL == trigs) {
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
return ORTE_ERR_BAD_PARAM;
}
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
if (orte_gpr_replica_globals.compound_cmd_mode) {
if (ORTE_SUCCESS != (rc = orte_gpr_base_pack_subscribe(orte_gpr_replica_globals.compound_cmd,
action, num_subs, subscriptions, num_trigs, trigs))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
/* enter request on notify tracking system */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_enter_notify_request(&idtag,
NULL, ORTE_GPR_NOTIFY_ID_MAX,
num_subs, subscriptions))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
*sub_number = idtag;
if (ORTE_SUCCESS != (rc = orte_dps.pack(orte_gpr_replica_globals.compound_cmd,
&idtag, 1, ORTE_GPR_NOTIFY_ID))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return ORTE_SUCCESS;
}
/* enter request on notify tracking system */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_enter_notify_request(&idtag,
NULL, ORTE_GPR_NOTIFY_ID_MAX,
num_subs, subscriptions))) {
/* store callback function and user_tag in local list for lookup
* generate id_tag to put in registry to identify lookup entry
* for each subscription - the subscription id is returned
* inside the subscription objects
*/
if (ORTE_SUCCESS != (rc = orte_gpr_replica_enter_local_subscription(
num_subs, subscriptions))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
*sub_number = idtag;
/* if any triggers were provided, get id tags for them - the
* idtags are returned inside the trigger objects
*/
if (ORTE_SUCCESS != (rc = orte_gpr_replica_enter_local_trigger(
num_trigs, trigs))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
/* register subscriptions */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_subscribe_fn(action, num_subs,
subscriptions, num_trigs, trigs, idtag))) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_subscribe_fn(NULL,
num_subs, subscriptions,
num_trigs, trigs))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
if (ORTE_SUCCESS != (rc = orte_gpr_replica_check_events())) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
@ -114,18 +93,27 @@ orte_gpr_replica_subscribe(orte_gpr_notify_action_t action,
}
int orte_gpr_replica_unsubscribe(orte_gpr_notify_id_t sub_number)
int orte_gpr_replica_unsubscribe(orte_gpr_subscription_id_t sub_number)
{
int rc;
if (orte_gpr_replica_globals.compound_cmd_mode) {
return orte_gpr_base_pack_unsubscribe(orte_gpr_replica_globals.compound_cmd,
sub_number);
}
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
rc = orte_gpr_replica_unsubscribe_fn(sub_number);
rc = orte_gpr_replica_remove_subscription(NULL, sub_number);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
int orte_gpr_replica_cancel_trigger(orte_gpr_trigger_id_t trig)
{
int rc;
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
rc = orte_gpr_replica_remove_trigger(NULL, trig);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);

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

@ -78,7 +78,7 @@ int orte_gpr_replica_recv_increment_value_cmd(orte_buffer_t *cmd, orte_buffer_t
if (ORTE_SUCCESS == ret) {
if (ORTE_SUCCESS !=
(rc = orte_gpr_replica_check_subscriptions(seg))) {
(rc = orte_gpr_replica_check_events())) {
ORTE_ERROR_LOG(rc);
return rc;
}
@ -141,7 +141,7 @@ int orte_gpr_replica_recv_decrement_value_cmd(orte_buffer_t *cmd, orte_buffer_t
if (ORTE_SUCCESS == ret) {
if (ORTE_SUCCESS !=
(rc = orte_gpr_replica_check_subscriptions(seg))) {
(rc = orte_gpr_replica_check_events())) {
ORTE_ERROR_LOG(rc);
return rc;
}

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

@ -161,18 +161,33 @@ int orte_gpr_replica_process_command_buffer(orte_buffer_t *input_buffer,
}
if (ORTE_SUCCESS != (ret =
orte_gpr_replica_recv_unsubscribe_cmd(input_buffer, answer))) {
ORTE_ERROR_LOG(ret);
orte_gpr_replica_recv_unsubscribe_cmd(sender, input_buffer, answer))) {
ORTE_ERROR_LOG(ret);
goto RETURN_ERROR;
}
break;
case ORTE_GPR_CANCEL_TRIGGER_CMD: /***** CANCEL_TRIGGER *****/
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "\tcancel trigger cmd");
}
if (ORTE_SUCCESS != (ret =
orte_gpr_replica_recv_cancel_trigger_cmd(sender, input_buffer, answer))) {
ORTE_ERROR_LOG(ret);
goto RETURN_ERROR;
}
break;
case ORTE_GPR_DUMP_ALL_CMD: /***** DUMP *****/
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "\tdump cmd");
ompi_output(0, "\tdump all cmd");
}
if (ORTE_SUCCESS != (ret = orte_gpr_replica_recv_dump_all_cmd(answer))) {
@ -186,7 +201,7 @@ int orte_gpr_replica_process_command_buffer(orte_buffer_t *input_buffer,
case ORTE_GPR_DUMP_SEGMENTS_CMD: /***** DUMP *****/
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "\tdump cmd");
ompi_output(0, "\tdump segments cmd");
}
if (ORTE_SUCCESS != (ret = orte_gpr_replica_recv_dump_segments_cmd(answer))) {
@ -200,7 +215,7 @@ int orte_gpr_replica_process_command_buffer(orte_buffer_t *input_buffer,
case ORTE_GPR_DUMP_TRIGGERS_CMD: /***** DUMP *****/
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "\tdump cmd");
ompi_output(0, "\tdump triggers cmd");
}
if (ORTE_SUCCESS != (ret = orte_gpr_replica_recv_dump_triggers_cmd(answer))) {
@ -211,10 +226,24 @@ int orte_gpr_replica_process_command_buffer(orte_buffer_t *input_buffer,
case ORTE_GPR_DUMP_SUBSCRIPTIONS_CMD: /***** DUMP *****/
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "\tdump subscriptions cmd");
}
if (ORTE_SUCCESS != (ret = orte_gpr_replica_recv_dump_subscriptions_cmd(answer))) {
ORTE_ERROR_LOG(ret);
goto RETURN_ERROR;
}
break;
case ORTE_GPR_DUMP_CALLBACKS_CMD: /***** DUMP *****/
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "\tdump cmd");
ompi_output(0, "\tdump callbacks cmd");
}
if (ORTE_SUCCESS != (ret = orte_gpr_replica_recv_dump_callbacks_cmd(answer))) {

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

@ -72,7 +72,8 @@ int orte_gpr_replica_process_command_buffer(orte_buffer_t *input_buffer,
/*
* Messaging functions
*/
int orte_gpr_replica_remote_notify(orte_process_name_t *recipient, ompi_list_t *messages);
int orte_gpr_replica_remote_notify(orte_process_name_t *recipient,
orte_gpr_notify_message_t *msg);
/*
* define the local functions for processing commands
@ -98,15 +99,22 @@ int orte_gpr_replica_recv_subscribe_cmd(orte_process_name_t* sender,
orte_buffer_t *input_buffer,
orte_buffer_t *output_buffer);
int orte_gpr_replica_recv_unsubscribe_cmd(orte_buffer_t *input_buffer,
int orte_gpr_replica_recv_unsubscribe_cmd(orte_process_name_t* sender,
orte_buffer_t *input_buffer,
orte_buffer_t *output_buffer);
int orte_gpr_replica_recv_cancel_trigger_cmd(orte_process_name_t* sender,
orte_buffer_t *input_buffer,
orte_buffer_t *output_buffer);
int orte_gpr_replica_recv_dump_all_cmd(orte_buffer_t *answer);
int orte_gpr_replica_recv_dump_segments_cmd(orte_buffer_t *answer);
int orte_gpr_replica_recv_dump_triggers_cmd(orte_buffer_t *answer);
int orte_gpr_replica_recv_dump_subscriptions_cmd(orte_buffer_t *answer);
int orte_gpr_replica_recv_dump_callbacks_cmd(orte_buffer_t *answer);
int orte_gpr_replica_recv_get_startup_msg_cmd(orte_buffer_t *input_buffer,

2
src/mca/gpr/replica/communications/gpr_replica_del_index_cm.c
Просмотреть файл

@ -157,7 +157,7 @@ int orte_gpr_replica_recv_delete_entries_cmd(orte_buffer_t *buffer, orte_buffer_
key_itags, num_keys);
if (ORTE_SUCCESS == ret) {
orte_gpr_replica_check_subscriptions(seg);
orte_gpr_replica_check_events();
}

18
src/mca/gpr/replica/communications/gpr_replica_dump_cm.c
Просмотреть файл

@ -85,6 +85,24 @@ int orte_gpr_replica_recv_dump_triggers_cmd(orte_buffer_t *answer)
return rc;
}
int orte_gpr_replica_recv_dump_subscriptions_cmd(orte_buffer_t *answer)
{
orte_gpr_cmd_flag_t command=ORTE_GPR_DUMP_SUBSCRIPTIONS_CMD;
int rc;
if (ORTE_SUCCESS != (rc = orte_dps.pack(answer, &command, 1, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
rc = orte_gpr_replica_dump_subscriptions_fn(answer);
if (ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
}
return rc;
}
int orte_gpr_replica_recv_dump_callbacks_cmd(orte_buffer_t *answer)
{
orte_gpr_cmd_flag_t command=ORTE_GPR_DUMP_CALLBACKS_CMD;

2
src/mca/gpr/replica/communications/gpr_replica_put_get_cm.c
Просмотреть файл

@ -98,7 +98,7 @@ int orte_gpr_replica_recv_put_cmd(orte_buffer_t *buffer, orte_buffer_t *answer)
if (ORTE_SUCCESS == ret) {
if (ORTE_SUCCESS !=
(rc = orte_gpr_replica_check_subscriptions(seg))) {
(rc = orte_gpr_replica_check_events())) {
ORTE_ERROR_LOG(rc);
return rc;
}

42
src/mca/gpr/replica/communications/gpr_replica_remote_msg.c
Просмотреть файл

@ -34,13 +34,11 @@
#include "gpr_replica_comm.h"
int orte_gpr_replica_remote_notify(orte_process_name_t *recipient, ompi_list_t *messages)
int orte_gpr_replica_remote_notify(orte_process_name_t *recipient,
orte_gpr_notify_message_t *message)
{
orte_buffer_t buffer;
orte_gpr_replica_notify_msg_list_t *msg;
orte_gpr_notify_message_t *message;
orte_gpr_cmd_flag_t command;
size_t count;
int rc;
if (orte_gpr_replica_globals.debug) {
@ -56,36 +54,20 @@ int orte_gpr_replica_remote_notify(orte_process_name_t *recipient, ompi_list_t *
return rc;
}
count = (size_t)ompi_list_get_size(messages);
if (ORTE_SUCCESS != (rc = orte_dps.pack(&buffer, &count, 1, ORTE_SIZE))) {
if (ORTE_SUCCESS != (rc = orte_dps.pack(&buffer, &(message->cnt), 1, ORTE_SIZE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
while (NULL != (msg = (orte_gpr_replica_notify_msg_list_t*)ompi_list_remove_first(messages))) {
message = msg->message;
if (ORTE_SUCCESS != (rc = orte_dps.pack(&buffer, &(message->idtag), 1, ORTE_GPR_NOTIFY_ID))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (ORTE_SUCCESS != (rc = orte_dps.pack(&buffer, &(message->cnt), 1, ORTE_SIZE))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if(message->cnt > 0) {
if (ORTE_SUCCESS != (rc = orte_dps.pack(&buffer, message->data, message->cnt, ORTE_GPR_NOTIFY_DATA))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
OBJ_RELEASE(msg);
}
if(message->cnt > 0) {
if (ORTE_SUCCESS != (rc = orte_dps.pack(&buffer, message->data,
message->cnt, ORTE_GPR_NOTIFY_DATA))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
OBJ_RELEASE(message);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
if (0 > orte_rml.send_buffer(recipient, &buffer, ORTE_RML_TAG_GPR_NOTIFY, 0)) {

116
src/mca/gpr/replica/communications/gpr_replica_subscribe_cm.c
Просмотреть файл

@ -38,11 +38,9 @@ int orte_gpr_replica_recv_subscribe_cmd(orte_process_name_t* sender,
{
orte_gpr_cmd_flag_t command=ORTE_GPR_SUBSCRIBE_CMD;
orte_data_type_t type;
orte_gpr_notify_id_t local_idtag=ORTE_GPR_NOTIFY_ID_MAX, idtag=ORTE_GPR_NOTIFY_ID_MAX;
int rc, ret;
size_t n, num_subs, num_trigs;
orte_gpr_notify_action_t action;
orte_gpr_value_t **trigs=NULL;
orte_gpr_trigger_t **trigs=NULL;
orte_gpr_subscription_t **subscriptions=NULL;
if (ORTE_SUCCESS != (rc = orte_dps.pack(output_buffer, &command, 1, ORTE_GPR_CMD))) {
@ -50,12 +48,6 @@ int orte_gpr_replica_recv_subscribe_cmd(orte_process_name_t* sender,
return rc;
}
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(input_buffer, &action, &n, ORTE_NOTIFY_ACTION))) {
ORTE_ERROR_LOG(rc);
goto RETURN_ERROR;
}
if (ORTE_SUCCESS != (rc = orte_dps.peek(input_buffer, &type, &n))) {
ORTE_ERROR_LOG(rc);
goto RETURN_ERROR;
@ -84,70 +76,37 @@ int orte_gpr_replica_recv_subscribe_cmd(orte_process_name_t* sender,
if (0 < n) {
/* create the space for the triggers */
trigs = (orte_gpr_value_t**)malloc(n * sizeof(orte_gpr_value_t*));
trigs = (orte_gpr_trigger_t**)malloc(n * sizeof(orte_gpr_trigger_t*));
if (NULL == trigs) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto RETURN_ERROR;
}
if (ORTE_SUCCESS != orte_dps.unpack(input_buffer, trigs, &n, ORTE_GPR_VALUE)) {
if (ORTE_SUCCESS != orte_dps.unpack(input_buffer, trigs, &n, ORTE_GPR_TRIGGER)) {
ORTE_ERROR_LOG(rc);
goto RETURN_ERROR;
}
}
num_trigs = n;
n = 1;
if (ORTE_SUCCESS != orte_dps.unpack(input_buffer, &idtag, &n, ORTE_GPR_NOTIFY_ID)) {
/* register subscriptions */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_subscribe_fn(sender,
num_subs, subscriptions,
num_trigs, trigs))) {
ORTE_ERROR_LOG(rc);
goto RETURN_ERROR;
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
if (NULL != sender) { /* remote sender */
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "[%lu,%lu,%lu] subscribe requested for remote sender [%lu,%lu,%lu] for idtag %d",
ORTE_NAME_ARGS(orte_process_info.my_name), ORTE_NAME_ARGS(sender), idtag);
}
/* enter request on local notify tracking system */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_enter_notify_request(&local_idtag,
sender, idtag, num_subs, subscriptions))) {
ORTE_ERROR_LOG(rc);
goto RETURN_ERROR;
}
/* register subscriptions */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_subscribe_fn(action,
num_subs, subscriptions,
num_trigs, trigs,
local_idtag))) {
ORTE_ERROR_LOG(rc);
goto RETURN_ERROR;
}
} else { /* local sender - idtag is for local notify tracking system */
/* register subscription */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_subscribe_fn(action,
num_subs, subscriptions,
num_trigs, trigs,
idtag))) {
ORTE_ERROR_LOG(rc);
goto RETURN_ERROR;
}
/* set the local idtag for return to local sender */
local_idtag = idtag;
if (ORTE_SUCCESS != (rc = orte_gpr_replica_check_events())) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
RETURN_ERROR:
/* pack the local idtag for return to sender */
if (ORTE_SUCCESS != (rc = orte_dps.pack(output_buffer, &local_idtag, 1, ORTE_GPR_NOTIFY_ID))) {
ORTE_ERROR_LOG(rc);
goto RETURN_ERROR;
}
if (ORTE_SUCCESS != (ret = orte_dps.pack(output_buffer, &rc, 1, ORTE_INT))) {
ORTE_ERROR_LOG(ret);
return ret;
@ -156,11 +115,12 @@ int orte_gpr_replica_recv_subscribe_cmd(orte_process_name_t* sender,
return rc;
}
int orte_gpr_replica_recv_unsubscribe_cmd(orte_buffer_t *input_buffer,
int orte_gpr_replica_recv_unsubscribe_cmd(orte_process_name_t *sender,
orte_buffer_t *input_buffer,
orte_buffer_t *output_buffer)
{
orte_gpr_cmd_flag_t command=ORTE_GPR_UNSUBSCRIBE_CMD;
orte_gpr_notify_id_t sub_number=0;
orte_gpr_subscription_id_t sub_number=0;
int rc, ret;
size_t n;
@ -170,13 +130,51 @@ int orte_gpr_replica_recv_unsubscribe_cmd(orte_buffer_t *input_buffer,
}
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(input_buffer, &sub_number, &n, ORTE_GPR_NOTIFY_ID))) {
if (ORTE_SUCCESS != (rc = orte_dps.unpack(input_buffer, &sub_number, &n,
ORTE_GPR_SUBSCRIPTION_ID))) {
ORTE_ERROR_LOG(rc);
ret = rc;
goto RETURN_ERROR;
}
ret = orte_gpr_replica_unsubscribe_fn(sub_number);
ret = orte_gpr_replica_remove_subscription(sender, sub_number);
if (ORTE_SUCCESS != ret) {
ORTE_ERROR_LOG(ret);
}
RETURN_ERROR:
if (ORTE_SUCCESS != (rc = orte_dps.pack(output_buffer, &ret, 1, ORTE_INT))) {
ORTE_ERROR_LOG(rc);
return rc;
}
return ret;
}
int orte_gpr_replica_recv_cancel_trigger_cmd(orte_process_name_t *sender,
orte_buffer_t *input_buffer,
orte_buffer_t *output_buffer)
{
orte_gpr_cmd_flag_t command=ORTE_GPR_CANCEL_TRIGGER_CMD;
orte_gpr_trigger_id_t trig_number=0;
int rc, ret;
size_t n;
if (ORTE_SUCCESS != (rc = orte_dps.pack(output_buffer, &command, 1, ORTE_GPR_CMD))) {
ORTE_ERROR_LOG(rc);
return rc;
}
n = 1;
if (ORTE_SUCCESS != (rc = orte_dps.unpack(input_buffer, &trig_number, &n,
ORTE_GPR_TRIGGER_ID))) {
ORTE_ERROR_LOG(rc);
ret = rc;
goto RETURN_ERROR;
}
ret = orte_gpr_replica_remove_trigger(sender, trig_number);
if (ORTE_SUCCESS != ret) {
ORTE_ERROR_LOG(ret);
}

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

@ -44,7 +44,7 @@ int orte_gpr_replica_increment_value_fn(orte_gpr_addr_mode_t addr_mode,
orte_gpr_replica_addr_mode_t tok_mode;
orte_gpr_replica_itagval_t **ival;
int rc;
size_t i, j, k, num_found;
size_t i, j, k, m, n;
/* extract the token address mode */
tok_mode = 0x004f & addr_mode;
@ -53,13 +53,13 @@ int orte_gpr_replica_increment_value_fn(orte_gpr_addr_mode_t addr_mode,
}
/* find the specified container(s) */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_containers(&num_found, seg, tok_mode,
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_containers(seg, tok_mode,
tokentags, num_tokens))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (0 == num_found) { /* nothing found */
if (0 == orte_gpr_replica_globals.num_srch_cptr) { /* nothing found */
ORTE_ERROR_LOG(ORTE_ERR_NOT_FOUND);
return ORTE_ERR_NOT_FOUND;
}
@ -67,16 +67,20 @@ int orte_gpr_replica_increment_value_fn(orte_gpr_addr_mode_t addr_mode,
/* otherwise, go through list of containers. For each one,
find the entry and then add one to its value */
cptr = (orte_gpr_replica_container_t**)(orte_gpr_replica_globals.srch_cptr)->addr;
for (j=0; j < (orte_gpr_replica_globals.srch_cptr)->size; j++) { /* for each container */
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++;
for (i=0; i < cnt; i++) { /* for each provided keyval to be incremented */
if (ORTE_SUCCESS == orte_gpr_replica_dict_lookup(&itag, seg, keyvals[i]->key) &&
ORTE_SUCCESS == orte_gpr_replica_search_container(&num_found,
ORTE_SUCCESS == orte_gpr_replica_search_container(
ORTE_GPR_REPLICA_OR, &itag, 1, cptr[j]) &&
0 < num_found) {
0 < orte_gpr_replica_globals.num_srch_ival) {
ival = (orte_gpr_replica_itagval_t**)((orte_gpr_replica_globals.srch_ival)->addr);
for (k=0; k < (orte_gpr_replica_globals.srch_ival)->size; k++) { /* for each found keyval */
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++;
switch (ival[k]->type) {
case ORTE_SIZE:
ival[k]->value.size++;
@ -138,7 +142,7 @@ int orte_gpr_replica_decrement_value_fn(orte_gpr_addr_mode_t addr_mode,
orte_gpr_replica_addr_mode_t tok_mode;
orte_gpr_replica_itagval_t **ival;
int rc;
size_t i, j, k, num_found;
size_t i, j, k, m, n;
/* extract the token address mode */
tok_mode = 0x004f & addr_mode;
@ -147,30 +151,34 @@ int orte_gpr_replica_decrement_value_fn(orte_gpr_addr_mode_t addr_mode,
}
/* find the specified container(s) */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_containers(&num_found, seg, tok_mode,
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_containers(seg, tok_mode,
tokentags, num_tokens))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (0 == num_found) { /* nothing found */
/* no ERROR_LOG entry created as this is not a system failure */
if (0 == orte_gpr_replica_globals.num_srch_cptr) { /* nothing found */
ORTE_ERROR_LOG(ORTE_ERR_NOT_FOUND);
return ORTE_ERR_NOT_FOUND;
}
/* otherwise, go through list of containers. For each one,
find the entry and then add one to its value */
cptr = (orte_gpr_replica_container_t**)(orte_gpr_replica_globals.srch_cptr)->addr;
for (j=0; j < (orte_gpr_replica_globals.srch_cptr)->size; j++) { /* for each container */
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]) {
for (i=0; i < cnt; i++) { /* for each provided keyval to be decremented */
m++;
for (i=0; i < cnt; i++) { /* for each provided keyval to be incremented */
if (ORTE_SUCCESS == orte_gpr_replica_dict_lookup(&itag, seg, keyvals[i]->key) &&
ORTE_SUCCESS == orte_gpr_replica_search_container(&num_found,
ORTE_SUCCESS == orte_gpr_replica_search_container(
ORTE_GPR_REPLICA_OR, &itag, 1, cptr[j]) &&
0 < num_found) {
0 < orte_gpr_replica_globals.num_srch_ival) {
ival = (orte_gpr_replica_itagval_t**)((orte_gpr_replica_globals.srch_ival)->addr);
for (k=0; k < (orte_gpr_replica_globals.srch_ival)->size; k++) { /* for each found keyval */
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++;
switch (ival[k]->type) {
case ORTE_SIZE:
ival[k]->value.size--;

427
src/mca/gpr/replica/functional_layer/gpr_replica_dump_fn.c
Просмотреть файл

@ -44,7 +44,7 @@ void orte_gpr_replica_dump_itagval_value(orte_buffer_t *buffer,
orte_gpr_replica_itagval_t *iptr);
static void orte_gpr_replica_dump_trigger(orte_buffer_t *buffer, size_t cnt,
orte_gpr_replica_triggers_t *trig);
orte_gpr_replica_trigger_t *trig);
int orte_gpr_replica_dump_all_fn(orte_buffer_t *buffer)
@ -60,6 +60,10 @@ int orte_gpr_replica_dump_all_fn(orte_buffer_t *buffer)
return rc;
}
if (ORTE_SUCCESS != (rc = orte_gpr_replica_dump_subscriptions_fn(buffer))) {
return rc;
}
if (ORTE_SUCCESS != (rc = orte_gpr_replica_dump_callbacks_fn(buffer))) {
return rc;
}
@ -77,7 +81,7 @@ int orte_gpr_replica_dump_segments_fn(orte_buffer_t *buffer)
orte_gpr_replica_itagval_t **iptr;
char *token;
size_t num_objects;
size_t i, j, k;
size_t i, j, k, m, n, p;
char *tmp_out;
tmp_out = (char*)malloc(1000);
@ -91,9 +95,10 @@ int orte_gpr_replica_dump_segments_fn(orte_buffer_t *buffer)
/* loop through all segments */
seg = (orte_gpr_replica_segment_t**)(orte_gpr_replica.segments)->addr;
for (i=0; i < (orte_gpr_replica.segments)->size; i++) {
for (i=0, m=0; m < orte_gpr_replica.num_segs &&
i < (orte_gpr_replica.segments)->size; i++) {
if (NULL != seg[i]) {
m++;
sprintf(tmp_out, "\nGPR Dump for Segment: %s", seg[i]->name);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
@ -105,8 +110,10 @@ int orte_gpr_replica_dump_segments_fn(orte_buffer_t *buffer)
/* loop through all containers and print their info and contents */
cptr = (orte_gpr_replica_container_t**)(seg[i]->containers)->addr;
for (j=0; j < (seg[i]->containers)->size; j++) {
for (j=0, n=0; n < seg[i]->num_containers &&
j < (seg[i]->containers)->size; j++) {
if (NULL != cptr[j]) {
n++;
sprintf(tmp_out, "\n\tInfo for container %lu"
"\tNumber of keyvals: %lu"
"\n\tTokens:\n",
@ -137,8 +144,10 @@ int orte_gpr_replica_dump_segments_fn(orte_buffer_t *buffer)
/* loop through all itagvals and print their info */
iptr = (orte_gpr_replica_itagval_t**)(cptr[j]->itagvals)->addr;
for (k=0; k < (cptr[j]->itagvals)->size; k++) {
for (k=0, p=0; p < cptr[j]->num_itagvals &&
k < (cptr[j]->itagvals)->size; k++) {
if (NULL != iptr[k]) {
p++;
if (ORTE_SUCCESS != orte_gpr_replica_dict_reverse_lookup(
&token, seg[i], iptr[k]->itag)) {
sprintf(tmp_out, "\n\t\titag num %lu: No entry found for itag %lu",
@ -166,9 +175,7 @@ int orte_gpr_replica_dump_segments_fn(orte_buffer_t *buffer)
int orte_gpr_replica_dump_callbacks_fn(orte_buffer_t *buffer)
{
ompi_list_item_t *item;
orte_gpr_replica_callbacks_t *cb;
orte_gpr_replica_notify_msg_list_t *msg;
orte_gpr_replica_action_taken_t **action;
orte_gpr_replica_itag_t *itaglist;
char *tmp_out, *token;
@ -210,35 +217,22 @@ int orte_gpr_replica_dump_callbacks_fn(orte_buffer_t *buffer)
ORTE_NAME_ARGS(cb->requestor));
}
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
j = ompi_list_get_size(&(cb->messages));
sprintf(tmp_out, "Num messages: %lu", (unsigned long) j);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
for (k=0, item = ompi_list_get_first(&(cb->messages));
item != ompi_list_get_end(&(cb->messages));
item = ompi_list_get_next(item), k++) {
msg = (orte_gpr_replica_notify_msg_list_t*)item;
sprintf(tmp_out, "\n\nInfo for message %lu sending %lu "
" data objects to notifier id %lu",
(unsigned long) k, (unsigned long) (msg->message)->cnt,
(unsigned long) (msg->message)->idtag);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
orte_gpr_base_dump_notify_msg(buffer, msg->message);
}
i++;
orte_gpr_base_dump_notify_msg(buffer, cb->message);
}
}
sprintf(tmp_out, "\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
i = (orte_gpr_replica_globals.acted_upon)->size - (orte_gpr_replica_globals.acted_upon)->number_free;
if (0 < i) {
if (0 < orte_gpr_replica_globals.num_acted_upon) {
sprintf(tmp_out, "\nDUMP OF GPR ACTION RECORDS\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
action = (orte_gpr_replica_action_taken_t**)orte_gpr_replica_globals.acted_upon->addr;
for (i=0; i < (orte_gpr_replica_globals.acted_upon)->size; i++) {
for (i=0, j=0; j < orte_gpr_replica_globals.num_acted_upon &&
i < (orte_gpr_replica_globals.acted_upon)->size; i++) {
if (NULL != action[i]) {
j++;
if (NULL != action[i]->seg) {
sprintf(tmp_out, "\nAction Taken on Segment: %s", action[i]->seg->name);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
@ -322,7 +316,7 @@ int orte_gpr_replica_dump_callbacks_fn(orte_buffer_t *buffer)
int orte_gpr_replica_dump_triggers_fn(orte_buffer_t *buffer)
{
orte_gpr_replica_triggers_t **trig;
orte_gpr_replica_trigger_t **trig;
char tmp_out[100], *tmp;
size_t j, k;
@ -330,17 +324,13 @@ int orte_gpr_replica_dump_triggers_fn(orte_buffer_t *buffer)
sprintf(tmp_out, "\nDUMP OF GPR TRIGGERS\n");
orte_gpr_replica_dump_load_string(buffer, &tmp);
trig = (orte_gpr_replica_triggers_t**)((orte_gpr_replica.triggers)->addr);
k = 0;
for (j=0; j < (orte_gpr_replica.triggers)->size; j++) {
if (NULL != trig[j]) k++;
}
sprintf(tmp_out, "Number of triggers: %lu\n", (unsigned long) k);
trig = (orte_gpr_replica_trigger_t**)((orte_gpr_replica.triggers)->addr);
sprintf(tmp_out, "Number of triggers: %lu\n", (unsigned long) orte_gpr_replica.num_trigs);
orte_gpr_replica_dump_load_string(buffer, &tmp);
/* dump the trigger info for the registry */
for (j=0, k=0; j < (orte_gpr_replica.triggers)->size; j++) {
for (j=0, k=0; k < orte_gpr_replica.num_trigs &&
j < (orte_gpr_replica.triggers)->size; j++) {
if (NULL != trig[j]) {
orte_gpr_replica_dump_trigger(buffer, k, trig[j]);
k++;
@ -351,12 +341,12 @@ int orte_gpr_replica_dump_triggers_fn(orte_buffer_t *buffer)
}
static void orte_gpr_replica_dump_trigger(orte_buffer_t *buffer, size_t cnt,
orte_gpr_replica_triggers_t *trig)
orte_gpr_replica_trigger_t *trig)
{
char *tmp_out, *token;
size_t i, j, k;
orte_gpr_replica_subscribed_data_t **data;
size_t i, j;
orte_gpr_replica_counter_t **cntr;
orte_gpr_replica_subscription_t **subs;
tmp_out = (char*)malloc(1000);
if (NULL == tmp_out) {
@ -364,44 +354,9 @@ static void orte_gpr_replica_dump_trigger(orte_buffer_t *buffer, size_t cnt,
return;
}
sprintf(tmp_out, "\nData for trigger %lu", (unsigned long) cnt);
sprintf(tmp_out, "\nData for trigger %lu", (unsigned long) trig->index);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
/* output recipient info */
if (NULL == trig->requestor) {
sprintf(tmp_out, "\tIntended recipient: LOCAL @ notifier idtag %lu",
(unsigned long) trig->index);
} else {
sprintf(tmp_out, "\tIntended recipient: [%lu,%lu,%lu] @ notifier idtag %lu",
ORTE_NAME_ARGS(trig->requestor),
(unsigned long) trig->remote_idtag);
}
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
sprintf(tmp_out, "\tActions:");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
if (ORTE_GPR_NOTIFY_VALUE_CHG & trig->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_VALUE_CHG");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
} else if (ORTE_GPR_NOTIFY_VALUE_CHG_TO & trig->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_VALUE_CHG_TO");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
} else if (ORTE_GPR_NOTIFY_VALUE_CHG_FRM & trig->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_VALUE_CHG_FRM");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_NOTIFY_DEL_ENTRY & trig->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_DEL_ENTRY");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_NOTIFY_ADD_ENTRY & trig->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_ADD_ENTRY");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_NOTIFY_PRE_EXISTING & trig->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_PRE_EXISTING");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_TRIG_ONE_SHOT & trig->action) {
sprintf(tmp_out, "\t\tORTE_GPR_TRIG_ONE_SHOT");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
@ -414,116 +369,11 @@ static void orte_gpr_replica_dump_trigger(orte_buffer_t *buffer, size_t cnt,
sprintf(tmp_out, "\t\tORTE_GPR_TRIG_CMP_LEVELS");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_TRIG_MONITOR_ONLY & trig->action) {
sprintf(tmp_out, "\t\tORTE_GPR_TRIG_MONITOR_ONLY");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_NOTIFY_STARTS_AFTER_TRIG & trig->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_STARTS_AFTER_TRIG");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_TRIG_INCLUDE_DATA & trig->action) {
sprintf(tmp_out, "\t\tORTE_GPR_TRIG_INCLUDE_DATA");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
sprintf(tmp_out, "\n\tData covered by this subscription");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
data = (orte_gpr_replica_subscribed_data_t**)((trig->subscribed_data)->addr);
for (i=0; i < (trig->subscribed_data)->size; i++) {
if (NULL != data[i]) {
sprintf(tmp_out, "\n\t\tData on segment %s", (data[i]->seg)->name);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
k = (int)orte_value_array_get_size(&(data[i]->tokentags));
if (0 == k) {
sprintf(tmp_out, "\t\tNULL token (wildcard)");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
} else {
sprintf(tmp_out, "\t\tNumber of tokens: %lu",
(unsigned long) k);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
for (j=0; j < k; j++) {
if (ORTE_SUCCESS == orte_gpr_replica_dict_reverse_lookup(&token, data[i]->seg,
ORTE_VALUE_ARRAY_GET_ITEM(&(data[i]->tokentags), orte_gpr_replica_itag_t, j))) {
sprintf(tmp_out, "\t\t\tToken: %s", token);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
free(token);
}
}
}
sprintf(tmp_out, "\t\tToken addressing mode:\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
if (ORTE_GPR_TOKENS_NOT & data[i]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_NOT\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_TOKENS_AND & data[i]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_AND\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_TOKENS_OR & data[i]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_OR\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_TOKENS_XAND & data[i]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_XAND\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_TOKENS_XOR & data[i]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_XOR\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
k = (int)orte_value_array_get_size(&(data[i]->keytags));
if (0 == k) {
sprintf(tmp_out, "\t\tNULL key (wildcard)");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
} else {
sprintf(tmp_out, "\t\tNumber of keys: %lu", (unsigned long) k);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
for (j=0; j < k; j++) {
if (ORTE_SUCCESS == orte_gpr_replica_dict_reverse_lookup(&token, data[i]->seg,
ORTE_VALUE_ARRAY_GET_ITEM(&(data[i]->keytags), orte_gpr_replica_itag_t, j))) {
sprintf(tmp_out, "\t\t\tKey: %s", token);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
free(token);
}
}
}
sprintf(tmp_out, "\t\tKey addressing mode:\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
if (ORTE_GPR_KEYS_NOT & data[i]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_NOT\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_KEYS_AND & data[i]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_AND\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_KEYS_OR & data[i]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_OR\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_KEYS_XAND & data[i]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_XAND\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_KEYS_XOR & data[i]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_XOR\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
} /* if data[i] not NULL */
} /* for i */
if (0 < trig->num_counters) {
if (ORTE_GPR_TRIG_AT_LEVEL & trig->action) {
sprintf(tmp_out, "\tTrigger monitoring %lu counters for level",
@ -534,10 +384,12 @@ static void orte_gpr_replica_dump_trigger(orte_buffer_t *buffer, size_t cnt,
}
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
cntr = (orte_gpr_replica_counter_t**)((trig->counters)->addr);
for (i=0; i < (trig->counters)->size; i++) {
for (i=0, j=0; j < trig->num_counters &&
i < (trig->counters)->size; i++) {
if (NULL != cntr[i] &&
ORTE_SUCCESS == orte_gpr_replica_dict_reverse_lookup(&token, cntr[i]->seg,
(cntr[i]->iptr)->itag)) {
j++;
sprintf(tmp_out, "\t\tCounter: %lu\tSegment: %s\tName: %s",
(unsigned long) i, (cntr[i]->seg)->name, token);
free(token);
@ -554,10 +406,225 @@ static void orte_gpr_replica_dump_trigger(orte_buffer_t *buffer, size_t cnt,
}
}
if (0 < trig->num_subscriptions) {
sprintf(tmp_out, "\tTrigger has %lu subscriptions attached to it",
(unsigned long) trig->num_subscriptions);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
subs = (orte_gpr_replica_subscription_t**)((trig->subscriptions)->addr);
for (i=0, j=0; j < trig->num_subscriptions &&
i < (trig->subscriptions)->size; i++) {
if (NULL != subs[i]) {
j++;
sprintf(tmp_out, "\t\tSubscription %lu name %s",
(unsigned long) subs[i]->index,
subs[i]->name);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
}
}
free(tmp_out);
return;
}
int orte_gpr_replica_dump_subscriptions_fn(orte_buffer_t *buffer)
{
char *tmp_out, *token, *tmp;
size_t i, j, k, m, n, p;
orte_gpr_replica_subscription_t **subs;
orte_gpr_replica_requestor_t **reqs;
orte_gpr_replica_ivalue_t **ivals;
tmp_out = (char*)malloc(1000);
if (NULL == tmp_out) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
tmp = tmp_out;
sprintf(tmp_out, "\nDUMP OF GPR SUBSCRIPTIONS\n");
orte_gpr_replica_dump_load_string(buffer, &tmp);
subs = (orte_gpr_replica_subscription_t**)((orte_gpr_replica.subscriptions)->addr);
sprintf(tmp_out, "Number of subscriptions: %lu\n", (unsigned long) orte_gpr_replica.num_subs);
orte_gpr_replica_dump_load_string(buffer, &tmp);
/* dump the trigger info for the registry */
for (i=0, m=0; m < orte_gpr_replica.num_subs &&
i < (orte_gpr_replica.subscriptions)->size; i++) {
if (NULL != subs[i]) {
m++;
sprintf(tmp_out, "Info for Subscription %lu named %s",
(unsigned long) subs[i]->index, subs[i]->name);
orte_gpr_replica_dump_load_string(buffer, &tmp);
if (subs[i]->active) {
sprintf(tmp_out, "\tSubscription ACTIVE");
} else {
sprintf(tmp_out, "\tSubscription INACTIVE");
}
orte_gpr_replica_dump_load_string(buffer, &tmp);
/* output recipient info */
sprintf(tmp_out, "\tList of requestors for this subscription:");
orte_gpr_replica_dump_load_string(buffer, &tmp);
reqs = (orte_gpr_replica_requestor_t**)(subs[i]->requestors)->addr;
for (j=0, k=0; k < subs[i]->num_requestors &&
j < (subs[i]->requestors)->size; j++) {
if (NULL != reqs[j]) {
k++;
if (NULL == reqs[j]->requestor) {
sprintf(tmp_out, "\t\tRequestor: LOCAL @ subscription id %lu",
(unsigned long) reqs[j]->idtag);
} else {
sprintf(tmp_out, "\t\tRequestor: [%lu,%lu,%lu] @ subscription id %lu",
ORTE_NAME_ARGS(reqs[j]->requestor),
(unsigned long) reqs[j]->idtag);
}
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
}
sprintf(tmp_out, "\tActions:");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
if (ORTE_GPR_NOTIFY_VALUE_CHG & subs[i]->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_VALUE_CHG");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
} else if (ORTE_GPR_NOTIFY_VALUE_CHG_TO & subs[i]->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_VALUE_CHG_TO");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
} else if (ORTE_GPR_NOTIFY_VALUE_CHG_FRM & subs[i]->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_VALUE_CHG_FRM");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_NOTIFY_DEL_ENTRY & subs[i]->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_DEL_ENTRY");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_NOTIFY_ADD_ENTRY & subs[i]->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_ADD_ENTRY");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_NOTIFY_PRE_EXISTING & subs[i]->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_PRE_EXISTING");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_NOTIFY_STARTS_AFTER_TRIG & subs[i]->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_STARTS_AFTER_TRIG");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_NOTIFY_NO_DATA_WITH_TRIG & subs[i]->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_NO_DATA_WITH_TRIG");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_NOTIFY_DELETE_AFTER_TRIG & subs[i]->action) {
sprintf(tmp_out, "\t\tORTE_GPR_NOTIFY_DELETE_AFTER_TRIG");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
sprintf(tmp_out, "\n\tData covered by this subscription");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
ivals = (orte_gpr_replica_ivalue_t**)(subs[i]->values)->addr;
for (n=0, p=0; p < subs[i]->num_values &&
n < (subs[i]->values)->size; n++) {
if (NULL != ivals[n]) {
p++;
sprintf(tmp_out, "\t\tData on segment %s", (ivals[n]->seg)->name);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
k = (int)orte_value_array_get_size(&(ivals[n]->tokentags));
if (0 == k) {
sprintf(tmp_out, "\t\tNULL token (wildcard)");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
} else {
sprintf(tmp_out, "\t\tNumber of tokens: %lu",
(unsigned long) k);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
for (j=0; j < k; j++) {
if (ORTE_SUCCESS == orte_gpr_replica_dict_reverse_lookup(&token, ivals[n]->seg,
ORTE_VALUE_ARRAY_GET_ITEM(&(ivals[n]->tokentags), orte_gpr_replica_itag_t, j))) {
sprintf(tmp_out, "\t\t\tToken: %s", token);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
free(token);
}
}
}
sprintf(tmp_out, "\t\tToken addressing mode:\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
if (ORTE_GPR_TOKENS_NOT & ivals[n]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_NOT\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_TOKENS_AND & ivals[n]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_AND\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_TOKENS_OR & ivals[n]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_OR\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_TOKENS_XAND & ivals[n]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_XAND\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_TOKENS_XOR & ivals[n]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_TOKENS_XOR\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
k = (int)orte_value_array_get_size(&(ivals[n]->keytags));
if (0 == k) {
sprintf(tmp_out, "\t\tNULL key (wildcard)");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
} else {
sprintf(tmp_out, "\t\tNumber of keys: %lu", (unsigned long) k);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
for (j=0; j < k; j++) {
if (ORTE_SUCCESS == orte_gpr_replica_dict_reverse_lookup(&token, ivals[n]->seg,
ORTE_VALUE_ARRAY_GET_ITEM(&(ivals[n]->keytags), orte_gpr_replica_itag_t, j))) {
sprintf(tmp_out, "\t\t\tKey: %s", token);
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
free(token);
}
}
}
sprintf(tmp_out, "\t\tKey addressing mode:\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
if (ORTE_GPR_KEYS_NOT & ivals[n]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_NOT\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_KEYS_AND & ivals[n]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_AND\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_KEYS_OR & ivals[n]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_OR\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_KEYS_XAND & ivals[n]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_XAND\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
if (ORTE_GPR_KEYS_XOR & ivals[n]->addr_mode) {
sprintf(tmp_out, "\t\t\tORTE_GPR_KEYS_XOR\n");
orte_gpr_replica_dump_load_string(buffer, &tmp_out);
}
} /* if ivals[n] not NULL */
} /* for n */
} /* if subs[i] not NULL */
} /* for i */
free(tmp_out);
return ORTE_SUCCESS;
}
void orte_gpr_replica_dump_itagval_value(orte_buffer_t *buffer,
orte_gpr_replica_itagval_t *iptr)

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

@ -111,14 +111,11 @@ int orte_gpr_replica_get_nb_fn(orte_gpr_addr_mode_t addr_mode,
/*
* Subscribe functions
*/
int orte_gpr_replica_subscribe_fn(orte_gpr_notify_action_t action, size_t num_subs,
int orte_gpr_replica_subscribe_fn(orte_process_name_t *requestor,
size_t num_subs,
orte_gpr_subscription_t **subscriptions,
size_t num_trigs,
orte_gpr_value_t **trigs,
orte_gpr_notify_id_t idtag);
int orte_gpr_replica_unsubscribe_fn(orte_gpr_notify_id_t sub_number);
orte_gpr_trigger_t **trigs);
/*
* Diagnostic functions
@ -129,6 +126,8 @@ int orte_gpr_replica_dump_segments_fn(orte_buffer_t *buffer);
int orte_gpr_replica_dump_triggers_fn(orte_buffer_t *buffer);
int orte_gpr_replica_dump_subscriptions_fn(orte_buffer_t *buffer);
int orte_gpr_replica_dump_callbacks_fn(orte_buffer_t *buffer);
/*
@ -139,15 +138,7 @@ int orte_gpr_replica_dump_callbacks_fn(orte_buffer_t *buffer);
*/
int orte_gpr_replica_release_segment(orte_gpr_replica_segment_t **seg);
/**
* Typedef of the orte_gpr_replica_release_segment() function
* signature so that it can be invoked via a function pointer for a
* unit test.
*/
typedef int (*orte_gpr_replica_release_segment_fn_t)
(orte_gpr_replica_segment_t **seg);
int orte_gpr_replica_find_containers(size_t *num_found, orte_gpr_replica_segment_t *seg,
int orte_gpr_replica_find_containers(orte_gpr_replica_segment_t *seg,
orte_gpr_replica_addr_mode_t addr_mode,
orte_gpr_replica_itag_t *taglist, size_t num_tags);
@ -155,16 +146,6 @@ int orte_gpr_replica_create_container(orte_gpr_replica_container_t **cptr,
orte_gpr_replica_segment_t *seg,
size_t num_itags,
orte_gpr_replica_itag_t *itags);
/**
* Typedef of the orte_gpr_replica_create_container() function
* signature so that it can be invoked via a function pointer for a
* unit test.
*/
typedef int (*orte_gpr_replica_create_container_fn_t)
(orte_gpr_replica_container_t **cptr,
orte_gpr_replica_segment_t *seg,
size_t num_itags,
orte_gpr_replica_itag_t *itags);
int orte_gpr_replica_release_container(orte_gpr_replica_segment_t *seg,
orte_gpr_replica_container_t *cptr);
@ -174,30 +155,10 @@ int orte_gpr_replica_add_keyval(orte_gpr_replica_itagval_t **ivalptr,
orte_gpr_replica_container_t *cptr,
orte_gpr_keyval_t *kptr);
/**
* Typedef of the orte_gpr_replica_add_keyval() function
* signature so that it can be invoked via a function pointer for a
* unit test.
*/
typedef int (*orte_gpr_replica_add_keyval_fn_t)
(orte_gpr_replica_itagval_t **ivalptr,
orte_gpr_replica_segment_t *seg,
orte_gpr_replica_container_t *cptr,
orte_gpr_keyval_t *kptr);
int orte_gpr_replica_update_keyval(orte_gpr_replica_segment_t *seg,
orte_gpr_replica_container_t *cptr,
orte_gpr_keyval_t *kptr);
/**
* Typedef of the orte_gpr_replica_update_keyval() function
* signature so that it can be invoked via a function pointer for a
* unit test.
*/
typedef int (*orte_gpr_replica_update_keyval_fn_t)
(orte_gpr_replica_segment_t *seg,
orte_gpr_replica_container_t *cptr,
orte_gpr_keyval_t *kptr);
int orte_gpr_replica_compare_values(int *cmp, orte_gpr_replica_itagval_t *ival1,
orte_gpr_replica_itagval_t *ival2);
@ -205,19 +166,10 @@ int orte_gpr_replica_compare_values(int *cmp, orte_gpr_replica_itagval_t *ival1,
int orte_gpr_replica_purge_itag(orte_gpr_replica_segment_t *seg,
orte_gpr_replica_itag_t itag);
int orte_gpr_replica_search_container(size_t *cnt, orte_gpr_replica_addr_mode_t addr_mode,
int orte_gpr_replica_search_container(orte_gpr_replica_addr_mode_t addr_mode,
orte_gpr_replica_itag_t *itags, size_t num_itags,
orte_gpr_replica_container_t *cptr);
/**
* Typedef of the orte_gpr_replica_search_container() function
* signature so that it can be invoked via a function pointer for a
* unit test.
*/
typedef int (*orte_gpr_replica_search_container_fn_t)
(size_t *cnt, orte_gpr_replica_addr_mode_t addr_mode,
orte_gpr_replica_itag_t *itags, size_t num_itags,
orte_gpr_replica_container_t *cptr);
int orte_gpr_replica_get_value(void *value, orte_gpr_replica_itagval_t *ival);
@ -235,18 +187,6 @@ bool orte_gpr_replica_check_itag_list(orte_gpr_replica_addr_mode_t mode,
size_t num_itags_entry,
orte_gpr_replica_itag_t *entry_itags);
/**
* Typedef of the orte_gpr_replica_check_itag_list() function
* signature so that it can be invoked via a function pointer for a
* unit test.
*/
typedef bool (*orte_gpr_replica_check_itag_list_fn_t)
(orte_gpr_replica_addr_mode_t mode,
size_t num_itags_search,
orte_gpr_replica_itag_t *itags,
size_t num_itags_entry,
orte_gpr_replica_itag_t *entry_itags);
int orte_gpr_replica_copy_itag_list(orte_gpr_replica_itag_t **dest,
orte_gpr_replica_itag_t *src, size_t num_itags);
@ -256,40 +196,51 @@ void orte_gpr_replica_dump_itagval_value(orte_buffer_t *buffer,
/*
* Trigger Operations
*/
int orte_gpr_replica_enter_local_subscription(size_t cnt, orte_gpr_subscription_t **subscriptions);
int orte_gpr_replica_enter_local_trigger(size_t cnt, orte_gpr_trigger_t **trigs);
int orte_gpr_replica_record_action(orte_gpr_replica_segment_t *seg,
orte_gpr_replica_container_t *cptr,
orte_gpr_replica_itagval_t *iptr,
orte_gpr_replica_action_t action);
int orte_gpr_replica_check_subscriptions(orte_gpr_replica_segment_t *seg);
int orte_gpr_replica_check_events(void);
int orte_gpr_replica_check_notify(orte_gpr_replica_triggers_t *trig,
orte_gpr_replica_subscribed_data_t *sub);
int orte_gpr_replica_check_subscription(orte_gpr_replica_subscription_t *sub);
bool orte_gpr_replica_check_notify_matches(orte_gpr_replica_subscribed_data_t *sub,
bool orte_gpr_replica_check_notify_matches(orte_gpr_value_t *value,
orte_gpr_replica_subscription_t *sub,
orte_gpr_replica_action_taken_t *ptr);
int orte_gpr_replica_check_trig(orte_gpr_replica_triggers_t *trig);
int orte_gpr_replica_check_trig(orte_gpr_replica_trigger_t *trig);
int orte_gpr_replica_update_storage_locations(orte_gpr_replica_itagval_t *new_iptr);
int orte_gpr_replica_construct_notify_message(orte_gpr_notify_message_t *msg,
orte_gpr_replica_triggers_t *trig,
orte_gpr_replica_subscribed_data_t *sub,
orte_gpr_replica_trigger_t *trig,
orte_gpr_replica_subscription_t *sub,
orte_gpr_value_t *value);
int
orte_gpr_replica_enter_notify_request(orte_gpr_notify_id_t *local_idtag,
orte_process_name_t *requestor,
orte_gpr_notify_id_t remote_idtag,
size_t cnt, orte_gpr_subscription_t **subscriptions);
orte_gpr_replica_register_subscription(orte_gpr_replica_subscription_t **subptr,
orte_process_name_t *requestor,
orte_gpr_subscription_t *subscription);
int
orte_gpr_replica_remove_notify_request(orte_gpr_notify_id_t local_idtag,
orte_gpr_notify_id_t *remote_idtag);
orte_gpr_replica_register_trigger(orte_gpr_replica_trigger_t **trigptr,
orte_process_name_t *requestor,
orte_gpr_trigger_t *trigger);
int orte_gpr_replica_register_callback(orte_gpr_replica_triggers_t *trig,
orte_gpr_replica_subscribed_data_t *sub,
int
orte_gpr_replica_remove_subscription(orte_process_name_t *requestor,
orte_gpr_subscription_id_t id);
int
orte_gpr_replica_remove_trigger(orte_process_name_t *requestor,
orte_gpr_trigger_id_t id);
int orte_gpr_replica_register_callback(orte_gpr_replica_subscription_t *sub,
orte_gpr_value_t *value);
int orte_gpr_replica_process_callbacks(void);
@ -297,11 +248,12 @@ int orte_gpr_replica_process_callbacks(void);
int orte_gpr_replica_purge_subscriptions(orte_process_name_t *proc);
int orte_gpr_replica_add_values_from_registry(orte_gpr_notify_message_t *msg,
orte_gpr_replica_subscribed_data_t *sptr);
orte_gpr_replica_subscription_t *sptr);
int orte_gpr_replica_store_value_in_msg(orte_gpr_notify_id_t cb_num,
int orte_gpr_replica_store_value_in_msg(orte_gpr_subscription_id_t id,
orte_gpr_notify_message_t *msg,
orte_gpr_value_t *value);
size_t cnt,
orte_gpr_value_t **values);
#if defined(c_plusplus) || defined(__cplusplus)
}

787
src/mca/gpr/replica/functional_layer/gpr_replica_messaging_fn.c
Просмотреть файл

@ -39,359 +39,334 @@
#include "mca/gpr/replica/communications/gpr_replica_comm.h"
#include "gpr_replica_fn.h"
static int orte_gpr_replica_add_value_to_datagram(orte_gpr_notify_data_t *data,
size_t cnt, orte_gpr_value_t **values);
int orte_gpr_replica_process_callbacks(void)
{
orte_gpr_replica_callbacks_t *cb;
orte_gpr_replica_notify_msg_list_t *msg;
orte_gpr_notify_data_t **data;
orte_gpr_replica_subscribed_data_t **sdata;
orte_gpr_replica_triggers_t *trig, **trigs;
bool processed;
size_t i, k;
orte_gpr_replica_trigger_t **trigs;
orte_gpr_replica_subscription_t **subs;
orte_gpr_replica_requestor_t **reqs;
orte_gpr_replica_local_subscriber_t *local_sub;
size_t i, j, k, m;
int rc;
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "gpr replica: process_callbacks entered");
}
/* set flag indicating callbacks being processed */
/* check and set flag indicating callbacks being processed */
if (orte_gpr_replica.processing_callbacks) {
return ORTE_SUCCESS;
}
orte_gpr_replica.processing_callbacks = true;
while (NULL != (cb = (orte_gpr_replica_callbacks_t*)ompi_list_remove_last(&orte_gpr_replica.callbacks))) {
if (NULL == cb->requestor) { /* local callback */
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "process_callbacks: local");
}
/* each callback corresponds to a specific requestor, each of whom can be
* slated to receive multiple messages.
* each message in the callback corresponds to a specific subscription request entered
* on the system. Within each subscription request, we can have multiple callback functions
* specified. Hence, we have to loop through all the callback functions that were logged
* for the subscription request to find the one that is to receive each block of data
* in the message
/* each callback corresponds to a specific requestor
* The message in the callback consists of at least one (and can
* be more) "datagrams" intended for that requestor, each of which
* is slated to be returned to a specific
* subscription that corresponds to a specific callback
* function on the requestor.
*
* Since this requestor is "local", we simply execute
* the callbacks ourself.
*/
while (NULL != (msg = (orte_gpr_replica_notify_msg_list_t*)ompi_list_remove_first(&(cb->messages)))) {
trig = (orte_gpr_replica_triggers_t*)((orte_gpr_replica.triggers)->addr[(msg->message)->idtag]);
if (NULL == trig || NULL == trig->subscribed_data) {
ORTE_ERROR_LOG(ORTE_ERR_GPR_DATA_CORRUPT);
data = (orte_gpr_notify_data_t**)((cb->message)->data);
for (i=0; i < (cb->message)->cnt; i++) {
/* for each datagram in the message, we need to lookup
* the associated subscription id to find the correct
* callback function. This subscription id is in the
* data object itself, and references the local_subscriptions
* array of objects.
*/
local_sub = (orte_gpr_replica_local_subscriber_t*)
(orte_gpr_replica_globals.local_subscriptions)->addr[data[i]->id];
if (NULL == local_sub) { /* this subscription has been deleted - error */
ORTE_ERROR_LOG(ORTE_ERR_NOT_FOUND);
goto CLEANUP;
}
data = (msg->message)->data;
sdata = (orte_gpr_replica_subscribed_data_t**)((trig->subscribed_data)->addr);
for (i=0; i < (msg->message)->cnt; i++) {
processed = false;
for (k=0; k < (trig->subscribed_data)->size && !processed; k++) {
if (NULL != sdata[k] && sdata[k]->index == data[i]->cb_num) {
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
sdata[k]->callback(data[i], sdata[k]->user_tag);
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
processed = true;
}
}
}
OBJ_RELEASE(msg);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
local_sub->callback(data[i], local_sub->user_tag);
OMPI_THREAD_LOCK(&orte_gpr_replica_globals.mutex);
}
} else { /* remote request - send messages back */
} else { /* remote request - send messages back */
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "process_callbacks: remote to [%lu,%lu,%lu]",
ORTE_NAME_ARGS(cb->requestor));
}
orte_gpr_replica_remote_notify(cb->requestor, &(cb->messages));
orte_gpr_replica_remote_notify(cb->requestor, cb->message);
}
CLEANUP:
OBJ_RELEASE(cb);
}
/* all callbacks processed - indicate list is open */
orte_gpr_replica.processing_callbacks = false;
/* cleanup any one-shot triggers that fired */
trigs = (orte_gpr_replica_triggers_t**)((orte_gpr_replica.triggers)->addr);
for (i=0; i < (orte_gpr_replica.triggers)->size; i++) {
if (NULL != trigs[i] && trigs[i]->one_shot_fired) {
/* if no notify actions were specified to stick around after
* the trigger, then simply remove the trigger. Otherwise,
* clear the trigger flags and leave the notify flags alone
*/
if (ORTE_GPR_NOTIFY_ANY & trigs[i]->action) {
trigs[i]->action = trigs[i]->action & ORTE_GPR_NOTIFY_ANY;
} else {
k = trigs[i]->index;
trigs = (orte_gpr_replica_trigger_t**)((orte_gpr_replica.triggers)->addr);
for (i=0, k=0, m=0; k < orte_gpr_replica.num_trigs &&
i < (orte_gpr_replica.triggers)->size; i++) {
if (NULL != trigs[i]) {
k++;
if (trigs[i]->one_shot_fired) {
OBJ_RELEASE(trigs[i]);
if (ORTE_SUCCESS != (rc = orte_pointer_array_set_item(orte_gpr_replica.triggers,
k, NULL))) {
ORTE_ERROR_LOG(rc);
return rc;
orte_pointer_array_set_item(orte_gpr_replica.triggers, i, NULL);
m++;
}
}
}
orte_gpr_replica.num_trigs -= m;
/* cleanup any subscriptions that are supposed to be
* removed based on a trigger having fired
*/
subs = (orte_gpr_replica_subscription_t**)(orte_gpr_replica.subscriptions)->addr;
for (i=0, k=0; k < orte_gpr_replica.num_subs &&
i < (orte_gpr_replica.subscriptions)->size; i++) {
if (NULL != subs[i]) {
k++;
if (subs[i]->cleanup) {
reqs = (orte_gpr_replica_requestor_t**)(subs[i]->requestors)->addr;
for (j=0, m=0; NULL != subs[i] &&
m < subs[i]->num_requestors &&
j < (subs[i]->requestors)->size; j++) {
if (NULL != reqs[j]) {
m++;
if (ORTE_SUCCESS != (rc =
orte_gpr_replica_remove_subscription(reqs[j]->requestor, reqs[j]->idtag))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
}
}
}
}
/* all callbacks processed - indicate list is open */
orte_gpr_replica.processing_callbacks = false;
return ORTE_SUCCESS;
}
int orte_gpr_replica_register_callback(orte_gpr_replica_triggers_t *trig,
orte_gpr_replica_subscribed_data_t *sub,
int orte_gpr_replica_register_callback(orte_gpr_replica_subscription_t *sub,
orte_gpr_value_t *value)
{
orte_gpr_replica_callbacks_t *cb;
orte_gpr_replica_notify_msg_list_t *msg;
orte_gpr_replica_requestor_t **reqs;
size_t interim, cnt, num_tokens, num_keys;
orte_gpr_value_t **vals, **values;
orte_gpr_replica_ivalue_t **ivals;
size_t i, j, k;
bool cleanup_reqd;
int rc;
/* see if a callback has already been requested for this requestor */
for (cb = (orte_gpr_replica_callbacks_t*)ompi_list_get_first(&(orte_gpr_replica.callbacks));
cb != (orte_gpr_replica_callbacks_t*)ompi_list_get_end(&(orte_gpr_replica.callbacks));
cb = (orte_gpr_replica_callbacks_t*)ompi_list_get_next(cb)) {
if ((NULL == trig->requestor && NULL == cb->requestor) /* both local */
|| ((NULL != trig->requestor && NULL != cb->requestor) &&
0 == orte_ns.compare(ORTE_NS_CMP_ALL, trig->requestor, cb->requestor))) { /* same remote requestor - add to existing callback */
/* check to see if we already have something for this trigger - if so, add to it */
for (msg = (orte_gpr_replica_notify_msg_list_t*)ompi_list_get_first(&(cb->messages));
msg != (orte_gpr_replica_notify_msg_list_t*)ompi_list_get_end(&(cb->messages));
msg = (orte_gpr_replica_notify_msg_list_t*)ompi_list_get_next(msg)) {
if ((msg->message)->idtag == trig->index) { /* same trigger - add to it */
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "[%lu,%lu,%lu] process_trig: adding message for requestor [%lu,%lu,%lu] for idtag %lu\n",
ORTE_NAME_ARGS(orte_process_info.my_name), ORTE_NAME_ARGS(cb->requestor), (unsigned long)trig->index);
}
if (ORTE_SUCCESS != (rc =
orte_gpr_replica_construct_notify_message(msg->message,
trig, sub, value))) {
ORTE_ERROR_LOG(rc);
}
return rc;
}
}
/* same requestor, different trigger - add another message to callback */
msg = OBJ_NEW(orte_gpr_replica_notify_msg_list_t);
if (NULL == msg) {
/* The data to be returned will be the same for all requestors
* on this subscription. First, let's get the data (if it hasn't
* already been provided) so we have it ready to be added to
* the callback
*/
/* check to see if value provided - if so, we'll just use it */
if (NULL != value) {
values = &value;
cnt = 1;
cleanup_reqd = false;
} else {
/* value not provided - get the data off the registry. since a
* subscription can have multiple data sources specified, we
* have to loop through those sources, constructing an aggregated
* array of data values that we can work with in composing the
* final message
*/
ivals = (orte_gpr_replica_ivalue_t**)(sub->values)->addr;
cnt = 0;
values = NULL;
for (i=0, j=0; j < sub->num_values &&
i < (sub->values)->size; i++) {
if (NULL != ivals[i]) {
j++;
num_tokens = orte_value_array_get_size(&(ivals[i]->tokentags));
num_keys = orte_value_array_get_size(&(ivals[i]->keytags));
/* get the data for this description off the registry */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_get_fn(ivals[i]->addr_mode,
ivals[i]->seg,
ORTE_VALUE_ARRAY_GET_BASE(&(ivals[i]->tokentags), orte_gpr_replica_itag_t),
num_tokens,
ORTE_VALUE_ARRAY_GET_BASE(&(ivals[i]->keytags), orte_gpr_replica_itag_t),
num_keys,
&interim, &vals))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* if we don't get any data back, just continue - don't
* try to add it to the values since that would cause a
* zero-byte malloc
*/
if (0 == interim) {
continue;
}
/* add these results to those we have already obtained */
if (0 == cnt) { /* first time through */
values = (orte_gpr_value_t**)malloc(interim *
sizeof(orte_gpr_value_t*));
if (NULL == values) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
} else {
/* reallocate values array */
values = (orte_gpr_value_t**)realloc(values,
(cnt+interim)*sizeof(orte_gpr_value_t*));
if (NULL == values) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
}
/* add data to end of array */
for (k=0; k < interim; k++) {
values[k+cnt] = vals[k];
}
/* update the count */
cnt += interim;
}
}
cleanup_reqd = true;
}
/* We now have the data to be sent to each requestor attached
* to this subscription.
* Each subscription that was placed on the system has an associated
* structure containing the process name and array of callback info where
* data is to be returned. For remote processes, the callback
* info is omitted and a subscription id is recorded - this tells
* the remote process which callback function to use when it receives
* a message from us.
* Each subscription can have multiple "requestors" attached to it,
* each "requestor" consisting of the process name and
* subscription id (for remote processes), and callback info (for local
* processes).
* For each requestor, we need to check to see if a callback has
* already been scheduled to that destination - if so, we piggyback
* another datagram onto it to minimize communication costs.
*/
reqs = (orte_gpr_replica_requestor_t**)(sub->requestors)->addr;
for (i=0, j=0; j < sub->num_requestors &&
i < (sub->requestors)->size; i++) {
if (NULL != reqs[i]) {
j++;
/* see if a callback has already been registered for this process */
for (cb = (orte_gpr_replica_callbacks_t*)ompi_list_get_first(&(orte_gpr_replica.callbacks));
cb != (orte_gpr_replica_callbacks_t*)ompi_list_get_end(&(orte_gpr_replica.callbacks));
cb = (orte_gpr_replica_callbacks_t*)ompi_list_get_next(cb)) {
if ((NULL == reqs[i]->requestor && NULL == cb->requestor) ||
((NULL != reqs[i]->requestor && NULL != cb->requestor) &&
(0 == orte_ns.compare(ORTE_NS_CMP_ALL,
reqs[i]->requestor,
cb->requestor)))) {
/* okay, a callback has been registered to send data to this
* process - add to that message
*/
goto PROCESS;
}
}
/* this is going to somebody new - create a new callback
* for this requestor
*/
cb = OBJ_NEW(orte_gpr_replica_callbacks_t);
if (NULL == cb) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
ompi_list_append(&cb->messages, &msg->item);
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
if (NULL == reqs[i]->requestor) {
cb->requestor = NULL;
} else {
if (ORTE_SUCCESS != (rc = orte_ns.copy_process_name(&(cb->requestor), reqs[i]->requestor))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
}
ompi_list_append(&orte_gpr_replica.callbacks, &cb->item);
/* construct the message */
msg->message = OBJ_NEW(orte_gpr_notify_message_t);
if (NULL == msg->message) {
cb->message = OBJ_NEW(orte_gpr_notify_message_t);
if (NULL == cb->message) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
if (NULL == trig->requestor) {
(msg->message)->idtag = trig->index;
} else {
(msg->message)->idtag = trig->remote_idtag;
}
if (ORTE_SUCCESS != (rc =
orte_gpr_replica_construct_notify_message(msg->message,
trig, sub, value))) {
PROCESS:
/* okay, now we have a message going to the requestor. We need to
* store the values in the notify_data structure corresponding to this
* subscription id, combining data where the id's match
*/
if (ORTE_SUCCESS != (rc = orte_gpr_replica_store_value_in_msg(reqs[i]->idtag,
cb->message, cnt, values))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
return rc;
}
}
/* this is going to somebody new - create a new callback for this requestor */
cb = OBJ_NEW(orte_gpr_replica_callbacks_t);
if (NULL == cb) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
if (NULL == trig->requestor) { /* local request - queue local callback */
cb->requestor = NULL;
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "[%lu,%lu,%lu] process_trig: queueing local callback for idtag %lu\n",
ORTE_NAME_ARGS(orte_process_info.my_name), (unsigned long)trig->index);
}
} else { /* remote request - queue remote callback */
if (ORTE_SUCCESS != (rc = orte_ns.copy_process_name(&(cb->requestor), trig->requestor))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(cb);
return rc;
}
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "[%lu,%lu,%lu] process_trig: queueing callback for [%lu,%lu,%lu] using remoteid %lu\n",
ORTE_NAME_ARGS(orte_process_info.my_name), ORTE_NAME_ARGS(cb->requestor),
(unsigned long)trig->remote_idtag);
}
}
ompi_list_append(&orte_gpr_replica.callbacks, &cb->item);
/* construct the message list item */
msg = OBJ_NEW(orte_gpr_replica_notify_msg_list_t);
if (NULL == msg) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* construct the message */
msg->message = OBJ_NEW(orte_gpr_notify_message_t);
if (NULL == msg->message) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
if (NULL == trig->requestor) {
(msg->message)->idtag = trig->index;
} else {
(msg->message)->idtag = trig->remote_idtag;
}
ompi_list_append(&cb->messages, &msg->item);
if (ORTE_SUCCESS != (rc =
orte_gpr_replica_construct_notify_message(msg->message,
trig, sub, value))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(cb);
return rc;
}
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "[%lu,%lu,%lu] gpr replica-process_trig: complete",
ORTE_NAME_ARGS(orte_process_info.my_name));
}
return ORTE_SUCCESS;
}
int orte_gpr_replica_construct_notify_message(orte_gpr_notify_message_t *msg,
orte_gpr_replica_triggers_t *trig,
orte_gpr_replica_subscribed_data_t *sub,
orte_gpr_value_t *value)
{
int rc=ORTE_SUCCESS;
orte_gpr_replica_subscribed_data_t **sptr;
size_t i;
/* if we don't have data, just return */
if (0 >= trig->num_subscribed_data && NULL == value) {
return ORTE_SUCCESS;
}
/* check to see if value provided - if so, use it */
if (NULL != value) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_store_value_in_msg(sub->index,
msg, value))) {
ORTE_ERROR_LOG(rc);
}
return rc;
}
/* otherwise, go get values off of registry and add them to the data object */
sptr = (orte_gpr_replica_subscribed_data_t**)((trig->subscribed_data)->addr);
for (i=0; i < (trig->subscribed_data)->size; i++) {
if (NULL != sptr[i]) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_add_values_from_registry(msg, sptr[i]))) {
ORTE_ERROR_LOG(rc);
return rc;
}
} /* if sptr not NULL */
} /* if NULL */
} /* for i */
return ORTE_SUCCESS;
CLEANUP:
if (cleanup_reqd) {
for (i=0; i < cnt; i++) OBJ_RELEASE(values[i]);
if (NULL != values) free(values);
}
return rc;
}
int orte_gpr_replica_add_values_from_registry(orte_gpr_notify_message_t *msg,
orte_gpr_replica_subscribed_data_t *sptr)
{
size_t i, j, num_tokens, num_keys, cnt;
int rc;
orte_gpr_value_t **values = NULL;
/* get the data off the registry */
num_tokens = orte_value_array_get_size(&(sptr->tokentags));
num_keys = orte_value_array_get_size(&(sptr->keytags));
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "add_values: performing a get");
}
if (ORTE_SUCCESS != (rc = orte_gpr_replica_get_fn(sptr->addr_mode, sptr->seg,
ORTE_VALUE_ARRAY_GET_BASE(&(sptr->tokentags), orte_gpr_replica_itag_t),
num_tokens,
ORTE_VALUE_ARRAY_GET_BASE(&(sptr->keytags), orte_gpr_replica_itag_t),
num_keys,
&cnt, &values))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "add_values: get returned %d values", cnt);
for (i=0; i < cnt; i++) {
ompi_output(0, "Data for value %d from segment %s\nTokens:", i, values[i]->segment);
for (j=0; j < values[i]->num_tokens; j++) {
ompi_output(0, "\ttoken num: %d\tToken: %s", j, values[i]->tokens[j]);
}
ompi_output(0, "\tGot %d keyvals:", values[i]->cnt);
/* for (j=0; j < values[i]->cnt; j++) {
ompi_output(0, "\tValue num: %d\tKey: %s", j, (values[i]->keyvals[j])->key);
orte_gpr_base_dump_keyval_value(values[i]->keyvals[j], 0);
}
*/
}
}
/* store these values in the notify_data structure, combining data
* where containers match
*/
for (i=0; i < cnt; i++) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_store_value_in_msg(sptr->index,
msg, values[i]))) {
ORTE_ERROR_LOG(rc);
for (j=i; j < cnt; j++) OBJ_RELEASE(values[j]);
free(values);
return rc;
}
OBJ_RELEASE(values[i]);
} /* for i */
if (NULL != values) {
free(values);
}
return ORTE_SUCCESS;
}
int orte_gpr_replica_store_value_in_msg(orte_gpr_notify_id_t cb_num,
int orte_gpr_replica_store_value_in_msg(orte_gpr_subscription_id_t id,
orte_gpr_notify_message_t *msg,
orte_gpr_value_t *value)
size_t cnt,
orte_gpr_value_t **values)
{
size_t j, k, n, m, matches, num_tokens;
size_t j, k, n, index;
int rc;
orte_gpr_value_t **data_values;
orte_gpr_value_t **vals;
orte_gpr_keyval_t **kptr;
orte_gpr_notify_data_t **data;
if (NULL == msg->data) { /* first data item on message */
/* find the datagram corresponding to the provided subscription id */
if (NULL == msg->data) { /* first datagram on message */
msg->data = (orte_gpr_notify_data_t**)malloc(sizeof(orte_gpr_notify_data_t*));
if (NULL == msg->data) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
data = &(msg->data[0]); /* need to assign location */
index = 0; /* need to assign location */
msg->cnt = 1;
} else {
/* check to see if this data is going to the same callback as
* any prior data on the message. if so, then we add those keyvals
* to the existing data structure. if not, then we realloc to
* any prior data on the message. if so, then we add the values
* to that existing data structure. if not, then we realloc to
* establish a new data structure and store the data there
*/
for (k=0; k < msg->cnt; k++) {
if (msg->data[k]->cb_num == cb_num) { /* going to the same place */
data = &(msg->data[k]);
goto MOVEON;
if (msg->data[k]->id == id) { /* going to the same place */
if (ORTE_SUCCESS != (rc =
orte_gpr_replica_add_value_to_datagram(
msg->data[k], cnt, values))) {
ORTE_ERROR_LOG(rc);
}
return rc;
}
}
/* no prior matching data found, so add another data location to the message */
@ -400,140 +375,220 @@ int orte_gpr_replica_store_value_in_msg(orte_gpr_notify_id_t cb_num,
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
data = &(msg->data[msg->cnt]);
index = msg->cnt;
(msg->cnt)++;
}
*data = OBJ_NEW(orte_gpr_notify_data_t);
if (NULL == *data) {
msg->data[index] = OBJ_NEW(orte_gpr_notify_data_t);
if (NULL == msg->data[index]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* store the callback_number, addressing mode, and name
* of the segment this data came from
*/
(*data)->cb_num = cb_num;
(*data)->addr_mode = value->addr_mode;
(*data)->segment = strdup(value->segment);
if (NULL == (*data)->segment) {
/* store the callback id */
msg->data[index]->id = id;
/* since this datagram is new, allocate the required data locations */
msg->data[index]->cnt = cnt;
if (0 == cnt) { /* no data to attach */
return ORTE_SUCCESS;
}
msg->data[index]->values = (orte_gpr_value_t**)malloc(cnt * sizeof(orte_gpr_value_t*));
if (NULL == msg->data[index]->values) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
MOVEON:
/* add the values to the data object */
if (NULL == (*data)->values) { /* first value on the structure */
(*data)->values = (orte_gpr_value_t**)malloc(sizeof(orte_gpr_value_t*));
if (NULL == (*data)->values) {
/* transfer the values to the datagram */
vals = msg->data[index]->values;
for (j=0; j < cnt; j++) {
vals[j] = OBJ_NEW(orte_gpr_value_t);
if (NULL == vals[j]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
data_values = &((*data)->values[0]); /* need to assign location */
(*data)->cnt = 1;
} else {
/* record the addressing mode */
vals[j]->addr_mode = values[j]->addr_mode;
/* record the segment these values came from */
vals[j]->segment = strdup(values[j]->segment);
if (NULL == (vals[j]->segment)) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* record the tokens describing the container */
vals[j]->num_tokens = values[j]->num_tokens;
if (0 == values[j]->num_tokens) {
/* this is an illegal case - the tokens here describe
* the container from which this data was obtained. The
* container MUST have tokens that describe it
*/
ORTE_ERROR_LOG(ORTE_ERR_GPR_DATA_CORRUPT);
return ORTE_ERR_GPR_DATA_CORRUPT;
}
vals[j]->tokens = (char **)malloc(values[j]->num_tokens *
sizeof(char*));
if (NULL == vals[j]->tokens) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
for (n=0; n < values[j]->num_tokens; n++) {
vals[j]->tokens[n] = strdup(values[j]->tokens[n]);
if (NULL == vals[j]->tokens[n]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
}
/* record the keyvals */
vals[j]->keyvals = (orte_gpr_keyval_t**)malloc(values[j]->cnt *
sizeof(orte_gpr_keyval_t*));
if (NULL == vals[j]->keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
vals[j]->cnt = values[j]->cnt;
kptr = vals[j]->keyvals;
for (n=0; n < values[j]->cnt; n++) {
kptr[n] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == kptr[n]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
kptr[n]->key = strdup((values[j]->keyvals[n])->key);
if (NULL == kptr[n]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
kptr[n]->type = (values[j]->keyvals[n])->type;
if (ORTE_SUCCESS != (rc = orte_gpr_base_xfer_payload(
&(kptr[n]->value), &((values[j]->keyvals[n])->value),
(values[j]->keyvals[n])->type))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
}
return ORTE_SUCCESS;
}
static int orte_gpr_replica_add_value_to_datagram(orte_gpr_notify_data_t *data,
size_t cnt, orte_gpr_value_t **values)
{
size_t i, j, k, n, m, index, matches, num_tokens;
int rc;
orte_gpr_value_t *value;
orte_gpr_keyval_t **kptr;
for (i=0; i < cnt; i++) {
value = values[i];
/* check to see if this value is from the same container
* as some prior one. if so, then we add those itagvals
* to the existing value structure. if not, then we realloc to
* establish a new value structure and store the data there
*/
for (k=0; k < (*data)->cnt; k++) {
for (k=0; k < data->cnt; k++) {
matches = 0;
num_tokens = (*data)->values[k]->num_tokens;
num_tokens = data->values[k]->num_tokens;
if (num_tokens == value->num_tokens) { /* must have same number or can't match */
for (j=0; j < num_tokens; j++) {
for (m=0; m < num_tokens; m++) {
if (0 == strcmp(((*data)->values[k])->tokens[j], value->tokens[m])) {
if (0 == strcmp((data->values[k])->tokens[j], value->tokens[m])) {
matches++;
}
}
if (num_tokens == matches) { /* from same container - just add keyvals to it */
data_values = &((*data)->values[k]);
goto MOVEON2;
index = k;
goto ADDKVALS;
}
}
}
}
/* no prior matching data found, so add another value location to the object */
(*data)->values = (orte_gpr_value_t**)realloc((*data)->values, ((*data)->cnt + 1)*sizeof(orte_gpr_value_t*));
if (NULL == (*data)->values) {
/* no prior matching data found, so add another value structure to the object */
data->values = (orte_gpr_value_t**)realloc(data->values, (data->cnt + 1)*sizeof(orte_gpr_value_t*));
if (NULL == data->values) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
data_values = &((*data)->values[(*data)->cnt]);
((*data)->cnt)++;
}
index = data->cnt;
(data->cnt)++;
*data_values = OBJ_NEW(orte_gpr_value_t);
if (NULL == *data_values) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* record the addressing mode */
(*data_values)->addr_mode = value->addr_mode;
/* record the segment these values came from */
(*data_values)->segment = strdup(value->segment);
if (NULL == ((*data_values)->segment)) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* record the tokens describing the container */
(*data_values)->num_tokens = value->num_tokens;
if (0 < value->num_tokens) { /* could be a wildcard case */
(*data_values)->tokens = (char **)malloc(value->num_tokens * sizeof(char*));
if (NULL == (*data_values)->tokens) {
data->values[index] = OBJ_NEW(orte_gpr_value_t);
if (NULL == data->values[index]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* record the addressing mode */
data->values[index]->addr_mode = value->addr_mode;
/* record the segment these values came from */
data->values[index]->segment = strdup(value->segment);
if (NULL == data->values[index]->segment) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* record the tokens describing the container */
data->values[index]->num_tokens = value->num_tokens;
if (0 == value->num_tokens) {
/* this is an illegal case - the tokens here describe
* the container from which this data was obtained. The
* container MUST have tokens that describe it
*/
ORTE_ERROR_LOG(ORTE_ERR_GPR_DATA_CORRUPT);
return ORTE_ERR_GPR_DATA_CORRUPT;
}
data->values[index]->tokens = (char **)malloc(value->num_tokens * sizeof(char*));
if (NULL == data->values[index]->tokens) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
for (n=0; n < value->num_tokens; n++) {
(*data_values)->tokens[n] = strdup(value->tokens[n]);
if (NULL == (*data_values)->tokens[n]) {
data->values[index]->tokens[n] = strdup(value->tokens[n]);
if (NULL == data->values[index]->tokens[n]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
}
}
MOVEON2:
/* record the value to be returned */
if (0 < (*data_values)->cnt) { /* already have some data here, so add to the space */
n = (*data_values)->cnt + value->cnt;
(*data_values)->keyvals = (orte_gpr_keyval_t**)
realloc((*data_values)->keyvals, n * sizeof(orte_gpr_keyval_t*));
if (NULL == (*data_values)->keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
ADDKVALS:
/* transfer the data in the value to be returned */
if (0 < data->values[index]->cnt) { /* already have some data here, so add to the space */
n = data->values[index]->cnt + value->cnt;
data->values[index]->keyvals = (orte_gpr_keyval_t**)
realloc(data->values[index]->keyvals, n * sizeof(orte_gpr_keyval_t*));
if (NULL == data->values[index]->keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
kptr = &(data->values[index]->keyvals[data->values[index]->cnt]);
data->values[index]->cnt = n;
} else {
data->values[index]->keyvals = (orte_gpr_keyval_t**)malloc(value->cnt * sizeof(orte_gpr_keyval_t*));
if (NULL == data->values[index]->keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
data->values[index]->cnt = value->cnt;
kptr = data->values[index]->keyvals;
}
kptr = &((*data_values)->keyvals[(*data_values)->cnt]);
(*data_values)->cnt = n;
} else {
(*data_values)->keyvals = (orte_gpr_keyval_t**)malloc(value->cnt * sizeof(orte_gpr_keyval_t*));
if (NULL == (*data_values)->keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
for (n=0; n < value->cnt; n++) {
kptr[n] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == kptr[n]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
kptr[n]->key = strdup((value->keyvals[n])->key);
if (NULL == kptr[n]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
kptr[n]->type = (value->keyvals[n])->type;
if (ORTE_SUCCESS != (rc = orte_gpr_base_xfer_payload(
&(kptr[n]->value), &((value->keyvals[n])->value),
(value->keyvals[n])->type))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
(*data_values)->cnt = value->cnt;
kptr = (*data_values)->keyvals;
}
for (n=0; n < value->cnt; n++) {
kptr[n] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == kptr[n]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
kptr[n]->key = strdup((value->keyvals[n])->key);
if (NULL == kptr[n]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
kptr[n]->type = (value->keyvals[n])->type;
if (ORTE_SUCCESS != (rc = orte_gpr_base_xfer_payload(
&(kptr[n]->value), &((value->keyvals[n])->value),
(value->keyvals[n])->type))) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
return ORTE_SUCCESS;
}

69
src/mca/gpr/replica/functional_layer/gpr_replica_put_get_fn.c
Просмотреть файл

@ -134,7 +134,7 @@ int orte_gpr_replica_put_fn(orte_gpr_addr_mode_t addr_mode,
bool overwrite;
char *tmp=NULL;
int rc;
size_t i, j, num_found;
size_t i, j, k;
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "[%lu,%lu,%lu] gpr replica: put entered on segment %s\nValues:",
@ -164,18 +164,18 @@ int orte_gpr_replica_put_fn(orte_gpr_addr_mode_t addr_mode,
}
/* find the specified container(s) */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_containers(&num_found, seg, tok_mode,
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_containers(seg, tok_mode,
token_itags, num_tokens))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (NULL == token_itags && 0 == num_found) { /* wildcard tokens but nothing found */
if (NULL == token_itags && 0 == orte_gpr_replica_globals.num_srch_cptr) { /* wildcard tokens but nothing found */
/* no ERROR_LOG entry created as this is not a system failure */
return ORTE_ERR_NOT_FOUND;
}
if (0 == num_found) { /* existing container not found - create one */
if (0 == orte_gpr_replica_globals.num_srch_cptr) { /* existing container not found - create one */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_create_container(&cptr2, seg,
num_tokens, token_itags))) {
ORTE_ERROR_LOG(rc);
@ -199,14 +199,16 @@ int orte_gpr_replica_put_fn(orte_gpr_addr_mode_t addr_mode,
} else { /* otherwise, go through list of containers. For each one,
see if entry already exists in container - overwrite if allowed */
cptr = (orte_gpr_replica_container_t**)(orte_gpr_replica_globals.srch_cptr)->addr;
for (j=0; j < (orte_gpr_replica_globals.srch_cptr)->size; j++) {
for (j=0, k=0; k < orte_gpr_replica_globals.num_srch_cptr &&
j < (orte_gpr_replica_globals.srch_cptr)->size; j++) {
if (NULL != cptr[j]) {
k++;
for (i=0; i < cnt; i++) { /* for each provided keyval */
if (ORTE_SUCCESS == orte_gpr_replica_create_itag(&itag, seg, keyvals[i]->key) &&
ORTE_SUCCESS == orte_gpr_replica_search_container(&num_found,
ORTE_SUCCESS == orte_gpr_replica_search_container(
ORTE_GPR_REPLICA_OR,
&itag, 1, cptr[j])) {
if (0 < num_found) {
if (0 < orte_gpr_replica_globals.num_srch_ival) {
/* this key already exists - overwrite, if permission given
* else add this keyval to the container as a new entry
*/
@ -277,7 +279,7 @@ int orte_gpr_replica_get_fn(orte_gpr_addr_mode_t addr_mode,
orte_gpr_keyval_t **kptr;
orte_gpr_replica_addr_mode_t tokmode, keymode;
int rc;
size_t i, j, num_found;
size_t i, j, k, m;
char *token;
if (orte_gpr_replica_globals.debug) {
@ -313,6 +315,7 @@ int orte_gpr_replica_get_fn(orte_gpr_addr_mode_t addr_mode,
OBJ_CONSTRUCT(&get_list, ompi_list_t);
*cnt = 0;
*values = NULL;
tokmode = 0x004f & addr_mode;
if (0x00 == tokmode) { /* default token addressing mode to AND */
tokmode = ORTE_GPR_REPLICA_AND;
@ -323,7 +326,7 @@ int orte_gpr_replica_get_fn(orte_gpr_addr_mode_t addr_mode,
}
/* find all containers that meet search criteria for tokens */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_containers(&num_found, seg, tokmode,
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_containers(seg, tokmode,
tokentags, num_tokens))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&get_list);
@ -331,7 +334,7 @@ int orte_gpr_replica_get_fn(orte_gpr_addr_mode_t addr_mode,
}
/* if nothing found, then can return */
if (0 == num_found) {
if (0 == orte_gpr_replica_globals.num_srch_cptr) {
OBJ_DESTRUCT(&get_list);
return ORTE_SUCCESS;
}
@ -340,29 +343,35 @@ int orte_gpr_replica_get_fn(orte_gpr_addr_mode_t addr_mode,
* subject to specified mode. Collect the results on get_list
*/
cptr = (orte_gpr_replica_container_t**)((orte_gpr_replica_globals.srch_cptr)->addr);
for (i=0; i < (orte_gpr_replica_globals.srch_cptr)->size; i++) {
if ((NULL != cptr[i]) &&
(ORTE_SUCCESS == orte_gpr_replica_search_container(&num_found, keymode,
keytags, num_keys, cptr[i])) && 0 < num_found) {
gptr = OBJ_NEW(orte_gpr_replica_get_list_t);
gptr->cptr = cptr[i];
iptr = (orte_gpr_replica_itagval_t**)((orte_gpr_replica_globals.srch_ival)->addr);
for (j=0; j < (orte_gpr_replica_globals.srch_ival)->size; j++) {
if (NULL != iptr[j]) {
ival_list = OBJ_NEW(orte_gpr_replica_ival_list_t);
ival_list->itag = iptr[j]->itag;
ival_list->type = iptr[j]->type;
if (ORTE_SUCCESS != (rc = orte_gpr_base_xfer_payload(
&(ival_list->value), &(iptr[j]->value), iptr[j]->type))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(ival_list);
return rc;
for (i=0, k=0; k < orte_gpr_replica_globals.num_srch_cptr &&
i < (orte_gpr_replica_globals.srch_cptr)->size; i++) {
if (NULL != cptr[i]) {
k++;
if (ORTE_SUCCESS == orte_gpr_replica_search_container(keymode,
keytags, num_keys, cptr[i]) &&
0 < orte_gpr_replica_globals.num_srch_ival) {
gptr = OBJ_NEW(orte_gpr_replica_get_list_t);
gptr->cptr = cptr[i];
iptr = (orte_gpr_replica_itagval_t**)((orte_gpr_replica_globals.srch_ival)->addr);
for (j=0, m=0; m < orte_gpr_replica_globals.num_srch_ival &&
j < (orte_gpr_replica_globals.srch_ival)->size; j++) {
if (NULL != iptr[j]) {
m++;
ival_list = OBJ_NEW(orte_gpr_replica_ival_list_t);
ival_list->itag = iptr[j]->itag;
ival_list->type = iptr[j]->type;
if (ORTE_SUCCESS != (rc = orte_gpr_base_xfer_payload(
&(ival_list->value), &(iptr[j]->value), iptr[j]->type))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(ival_list);
return rc;
}
ompi_list_append(gptr->ival_list, &ival_list->item);
}
ompi_list_append(gptr->ival_list, &ival_list->item);
}
ompi_list_append(&get_list, &gptr->item);
(*cnt)++; /* update number of containers that had something found */
}
ompi_list_append(&get_list, &gptr->item);
(*cnt)++; /* update number of containers that had something found */
}
}

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

@ -25,6 +25,7 @@
#include "orte_config.h"
#include "class/ompi_object.h"
#include "util/output.h"
#include "util/argv.h"
#include "mca/errmgr/errmgr.h"
@ -33,28 +34,32 @@
#include "gpr_replica_fn.h"
int orte_gpr_replica_find_containers(size_t *num_found, orte_gpr_replica_segment_t *seg,
int orte_gpr_replica_find_containers(orte_gpr_replica_segment_t *seg,
orte_gpr_replica_addr_mode_t addr_mode,
orte_gpr_replica_itag_t *taglist, size_t num_tags)
{
orte_gpr_replica_container_t **cptr;
size_t i, index;
size_t i, j, index;
/* ensure the search array is clear */
orte_pointer_array_clear(orte_gpr_replica_globals.srch_cptr);
*num_found = 0;
orte_gpr_replica_globals.num_srch_cptr = 0;
cptr = (orte_gpr_replica_container_t**)((seg->containers)->addr);
for (i=0; i < (seg->containers)->size; i++) {
if (NULL != cptr[i] && orte_gpr_replica_check_itag_list(addr_mode,
for (i=0, j=0; j < seg->num_containers &&
i < (seg->containers)->size; i++) {
if (NULL != cptr[i]) {
j++;
if (orte_gpr_replica_check_itag_list(addr_mode,
num_tags, taglist,
cptr[i]->num_itags, cptr[i]->itags)) {
if (0 > orte_pointer_array_add(&index, orte_gpr_replica_globals.srch_cptr, cptr[i])) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
orte_pointer_array_clear(orte_gpr_replica_globals.srch_cptr);
return ORTE_ERR_OUT_OF_RESOURCE;
if (0 > orte_pointer_array_add(&index, orte_gpr_replica_globals.srch_cptr, cptr[i])) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
orte_pointer_array_clear(orte_gpr_replica_globals.srch_cptr);
return ORTE_ERR_OUT_OF_RESOURCE;
}
(orte_gpr_replica_globals.num_srch_cptr)++;
}
(*num_found)++;
}
}
return ORTE_SUCCESS;
@ -87,6 +92,7 @@ int orte_gpr_replica_create_container(orte_gpr_replica_container_t **cptr,
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
(seg->num_containers)++;
(*cptr)->index = index;
return ORTE_SUCCESS;
@ -115,6 +121,7 @@ int orte_gpr_replica_release_container(orte_gpr_replica_segment_t *seg,
i = cptr->index;
OBJ_RELEASE(cptr);
orte_pointer_array_set_item(seg->containers, i, NULL);
(seg->num_containers)--;
return ORTE_SUCCESS;
}
@ -154,7 +161,8 @@ int orte_gpr_replica_add_keyval(orte_gpr_replica_itagval_t **ivalptr,
OBJ_RELEASE(iptr);
return ORTE_ERR_OUT_OF_RESOURCE;
}
(cptr->num_itagvals)++;
if (0 > (rc = orte_value_array_append_item(&(cptr->itaglist), (void*)(&(iptr->itag))))) {
ORTE_ERROR_LOG(rc);
orte_pointer_array_set_item(cptr->itagvals, iptr->index, NULL);
@ -192,6 +200,7 @@ int orte_gpr_replica_delete_itagval(orte_gpr_replica_segment_t *seg,
/* remove the entry from the container's itagval array */
orte_pointer_array_set_item(cptr->itagvals, i, NULL);
(cptr->num_itagvals)--;
return ORTE_SUCCESS;
}
@ -226,7 +235,7 @@ int orte_gpr_replica_update_keyval(orte_gpr_replica_segment_t *seg,
OBJ_RELEASE(iptr);
/* remove the entry from the container's itagval array */
orte_pointer_array_set_item(cptr->itagvals, i, NULL);
(cptr->num_itagvals)--;
}
}
@ -255,16 +264,16 @@ int orte_gpr_replica_update_keyval(orte_gpr_replica_segment_t *seg,
}
int orte_gpr_replica_search_container(size_t *cnt, orte_gpr_replica_addr_mode_t addr_mode,
int orte_gpr_replica_search_container(orte_gpr_replica_addr_mode_t addr_mode,
orte_gpr_replica_itag_t *itags, size_t num_itags,
orte_gpr_replica_container_t *cptr)
{
orte_gpr_replica_itagval_t **ptr;
size_t i, index;
size_t i, j, index;
/* ensure the search array is clear */
orte_pointer_array_clear(orte_gpr_replica_globals.srch_ival);
*cnt = 0;
orte_gpr_replica_globals.num_srch_ival = 0;
/* check list of itags in container to see if there is a match according
* to addr_mode spec
@ -274,17 +283,21 @@ int orte_gpr_replica_search_container(size_t *cnt, orte_gpr_replica_addr_mode_t
ORTE_VALUE_ARRAY_GET_BASE(&(cptr->itaglist), orte_gpr_replica_itag_t))) {
/* there is! so now collect those values into the search array */
ptr = (orte_gpr_replica_itagval_t**)((cptr->itagvals)->addr);
for (i=0; i < (cptr->itagvals)->size; i++) {
if (NULL != ptr[i] && orte_gpr_replica_check_itag_list(ORTE_GPR_REPLICA_OR,
for (i=0, j=0; j < cptr->num_itagvals &&
i < (cptr->itagvals)->size; i++) {
if (NULL != ptr[i]) {
j++;
if (orte_gpr_replica_check_itag_list(ORTE_GPR_REPLICA_OR,
num_itags, itags,
1, &(ptr[i]->itag))) {
if (0 > orte_pointer_array_add(&index, orte_gpr_replica_globals.srch_ival, ptr[i])) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
orte_pointer_array_clear(orte_gpr_replica_globals.srch_ival);
return ORTE_ERR_OUT_OF_RESOURCE;
if (0 > orte_pointer_array_add(&index, orte_gpr_replica_globals.srch_ival, ptr[i])) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
orte_pointer_array_clear(orte_gpr_replica_globals.srch_ival);
return ORTE_ERR_OUT_OF_RESOURCE;
}
(orte_gpr_replica_globals.num_srch_ival)++;
}
(*cnt)++;
}
}
}
@ -597,6 +610,8 @@ int orte_gpr_replica_release_segment(orte_gpr_replica_segment_t **seg)
if (0 > (rc = orte_pointer_array_set_item(orte_gpr_replica.segments, i, NULL))) {
return rc;
}
(orte_gpr_replica.num_segs)--;
return ORTE_SUCCESS;
}

313
src/mca/gpr/replica/functional_layer/gpr_replica_subscribe_fn.c
Просмотреть файл

@ -33,296 +33,65 @@
#include "mca/gpr/replica/transition_layer/gpr_replica_tl.h"
#include "gpr_replica_fn.h"
int orte_gpr_replica_subscribe_fn(orte_gpr_notify_action_t action, size_t num_subs,
int orte_gpr_replica_subscribe_fn(orte_process_name_t *requestor,
size_t num_subs,
orte_gpr_subscription_t **subscriptions,
size_t num_trigs,
orte_gpr_value_t **trigs,
orte_gpr_notify_id_t idtag)
orte_gpr_trigger_t **trigs)
{
orte_gpr_replica_triggers_t *trig=NULL;
orte_gpr_replica_subscribed_data_t *data=NULL, **data2=NULL;
orte_gpr_replica_counter_t *cntr;
orte_gpr_replica_segment_t *seg=NULL;
orte_gpr_replica_container_t **cptr=NULL, *cptr2=NULL;
orte_gpr_replica_itag_t itag, *tokentags=NULL, *keytags=NULL;
orte_gpr_replica_itagval_t *iptr=NULL;
orte_gpr_replica_addr_mode_t tok_mode, key_mode;
size_t i, j, k, index, num_tokens, num_keys, num_found;
orte_gpr_replica_subscription_t *sub=NULL, **subs;
orte_gpr_replica_trigger_t *trig=NULL;
size_t i, j, k, index;
int rc=ORTE_SUCCESS;
bool found;
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "[%lu,%lu,%lu] gpr replica: subscribe entered - registering idtag %d",
ORTE_NAME_ARGS(orte_process_info.my_name), idtag);
ompi_output(0, "Received %d subscriptions", num_subs);
for (i=0; i < num_subs; i++) {
ompi_output(0, "Subscription %d on segment %s with %d tokens, %d keys",
i, subscriptions[i]->segment, subscriptions[i]->num_tokens,
subscriptions[i]->num_keys);
for (j=0; j < subscriptions[i]->num_tokens; j++) {
ompi_output(0, "\tToken num: %d\tToken: %s", j, subscriptions[i]->tokens[j]);
}
for (j=0; j < subscriptions[i]->num_keys; j++) {
ompi_output(0, "\tKey num: %d\tKey: %s", j, subscriptions[i]->keys[j]);
}
}
for (i=0; i < num_trigs; i++) {
ompi_output(0, "Trigger %d on segment %s with %d tokens, %d keyvals",
i, trigs[i]->segment, trigs[i]->num_tokens, trigs[i]->cnt);
for (j=0; j < trigs[i]->num_tokens; j++) {
ompi_output(0, "\tToken num: %d\tToken: %s", j, trigs[i]->tokens[j]);
}
for (j=0; j < trigs[i]->cnt; j++) {
ompi_output(0, "\tKey num: %d\tKey: %s", j, (trigs[i]->keyvals[j])->key);
}
}
ompi_output(0, "[%lu,%lu,%lu] gpr replica: subscribe entered",
ORTE_NAME_ARGS(orte_process_info.my_name));
}
trig = (orte_gpr_replica_triggers_t*)((orte_gpr_replica.triggers)->addr[idtag]);
if (NULL == trig) {
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
return ORTE_ERR_BAD_PARAM;
}
trig->action = action;
/* ensure one of the search arrays is clear - in this case, we
* use the sub_ptrs array to temporarily store the subscription pointers so we
* can properly link them to the triggers
*/
orte_pointer_array_clear(orte_gpr_replica_globals.sub_ptrs);
subs = (orte_gpr_replica_subscription_t**)(orte_gpr_replica_globals.sub_ptrs)->addr;
for (i=0; i < num_subs; i++) {
/* find the subscribed_data entry in the trigger pointer array - placed
* there initially by the enter_notify_request function so we could store
* the callback function and user_tag pointers
*/
data2 = (orte_gpr_replica_subscribed_data_t**)((trig->subscribed_data)->addr);
for (j=0, data=NULL; j < (trig->subscribed_data)->size && NULL == data; j++) {
if (NULL != data2[j] && i == data2[j]->index) {
data = data2[j];
}
}
if (NULL == data) { /* if not found, then something very wrong */
ORTE_ERROR_LOG(ORTE_ERR_GPR_DATA_CORRUPT);
return ORTE_ERR_GPR_DATA_CORRUPT;
}
/* find and store the segment */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_seg(&(data->seg), true,
subscriptions[i]->segment))) {
if (ORTE_SUCCESS != (rc =
orte_gpr_replica_register_subscription(&sub, requestor, subscriptions[i]))) {
ORTE_ERROR_LOG(rc);
return rc;
}
tok_mode = 0x004f & subscriptions[i]->addr_mode;
if (0x00 == tok_mode) { /* default token address mode to AND */
tok_mode = ORTE_GPR_REPLICA_AND;
}
key_mode = ((0x4f00 & subscriptions[i]->addr_mode) >> 8) & 0x004f;
if (0x00 == key_mode) { /* default key address mode to OR */
key_mode = ORTE_GPR_REPLICA_OR;
}
data->addr_mode = ((orte_gpr_addr_mode_t)(key_mode) << 8) | (orte_gpr_addr_mode_t)tok_mode;
if (NULL != subscriptions[i]->tokens && 0 < subscriptions[i]->num_tokens) {
num_tokens = subscriptions[i]->num_tokens; /* indicates non-NULL terminated list */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_get_itag_list(&tokentags, data->seg,
subscriptions[i]->tokens, &num_tokens))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (ORTE_SUCCESS != (rc = orte_value_array_set_size(&(data->tokentags), (size_t)num_tokens))) {
ORTE_ERROR_LOG(rc);
return rc;
}
for (j=0; j < num_tokens; j++) {
ORTE_VALUE_ARRAY_SET_ITEM(&(data->tokentags), orte_gpr_replica_itag_t,
j, tokentags[j]);
}
free(tokentags);
tokentags = NULL;
}
if (NULL != subscriptions[i]->keys && 0 < subscriptions[i]->num_keys) {
num_keys = subscriptions[i]->num_keys; /* indicates non-NULL terminated list */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_get_itag_list(&keytags, data->seg,
subscriptions[i]->keys, &num_keys))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (ORTE_SUCCESS != (rc = orte_value_array_set_size(&(data->keytags), (size_t)num_keys))) {
ORTE_ERROR_LOG(rc);
return rc;
}
for (j=0; j < num_keys; j++) {
ORTE_VALUE_ARRAY_SET_ITEM(&(data->keytags), orte_gpr_replica_itag_t,
j, keytags[j]);
}
free(keytags);
keytags = NULL;
/* add the new subscription so we can link
* it to the triggers later
*/
if (0 > orte_pointer_array_add(&index, orte_gpr_replica_globals.sub_ptrs, sub)) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
}
/* if this has a trigger in it, need to setup the counters */
if (ORTE_GPR_TRIG_ANY & action) {
trig->num_counters = 0;
for (j=0; j < num_trigs; j++) {
/* get this counter's addressing modes */
tok_mode = 0x004f & trigs[j]->addr_mode;
if (0x00 == tok_mode) { /* default token address mode to AND */
tok_mode = ORTE_GPR_REPLICA_AND;
}
key_mode = ((0x4f00 & trigs[j]->addr_mode) >> 8) & 0x004f;
if (0x00 == key_mode) { /* default key address mode to OR */
key_mode = ORTE_GPR_REPLICA_OR;
}
/* locate this counter's segment - this is where the counter will be */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_seg(&seg, true, trigs[j]->segment))) {
ORTE_ERROR_LOG(rc);
OMPI_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
return rc;
}
/* convert the counter's tokens to an itaglist */
if (NULL != trigs[j]->tokens && 0 < trigs[j]->num_tokens) {
num_tokens = trigs[j]->num_tokens; /* indicates non-NULL terminated list */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_get_itag_list(&tokentags, seg,
trigs[j]->tokens, &num_tokens))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
/* now register any triggers */
for (i=0; i < num_trigs; i++) {
if (ORTE_SUCCESS != (rc =
orte_gpr_replica_register_trigger(&trig, requestor, trigs[i]))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* link the subscriptions to the new trigger
*/
for (j=0, k=0; k < num_subs &&
j < (orte_gpr_replica_globals.sub_ptrs)->size; j++) {
if (NULL != subs[j]) {
k++;
if (0 > orte_pointer_array_add(&index, trig->subscriptions, subs[j])) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
}
/* find the specified container(s) */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_containers(&num_found, seg, tok_mode,
tokentags, num_tokens))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
if (0 == num_found) { /* no existing container found - create one using all the tokens */
if (ORTE_SUCCESS != (rc = orte_gpr_replica_create_container(&cptr2, seg,
num_tokens, tokentags))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
/* ok, store all of this counters values in the new container, adding a pointer to each
* one in the trigger's counter array
*/
for (i=0; i < trigs[j]->cnt; i++) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_add_keyval(&iptr, seg, cptr2, trigs[j]->keyvals[i]))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
cntr = OBJ_NEW(orte_gpr_replica_counter_t);
if (NULL == cntr) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
cntr->seg = seg;
cntr->cptr = cptr2;
cntr->iptr = iptr;
cntr->trigger_level.type = (trigs[j]->keyvals[i])->type;
if (ORTE_SUCCESS != (rc = orte_gpr_base_xfer_payload(&(cntr->trigger_level.value),
&((trigs[j]->keyvals[i])->value), (trigs[j]->keyvals[i])->type))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
if (0 > orte_pointer_array_add(&index, trig->counters, cntr)) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
}
trig->num_counters += trigs[j]->cnt;
} else { /* For each counter, go through the list of containers and
see if it already exists in container. Only allow each
counter to be identified once - error if either a counter is never
found or already existing in more than one place. */
cptr = (orte_gpr_replica_container_t**)(orte_gpr_replica_globals.srch_cptr)->addr;
for (i=0; i < trigs[j]->cnt; i++) {
found = false;
for (k=0; k < (orte_gpr_replica_globals.srch_cptr)->size; k++) {
if (NULL != cptr[k]) {
if (ORTE_SUCCESS == orte_gpr_replica_dict_lookup(&itag, seg, trigs[j]->keyvals[i]->key) &&
ORTE_SUCCESS == orte_gpr_replica_search_container(&num_found,
ORTE_GPR_REPLICA_OR,
&itag, 1, cptr[k]) &&
0 < num_found) {
/* this key already exists - make sure it's unique
*/
if (1 < num_found || found) { /* not unique - error out */
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
rc = ORTE_ERR_BAD_PARAM;
goto CLEANUP;
}
/* okay, add to trigger's counter array */
found = true;
iptr = (orte_gpr_replica_itagval_t*)((orte_gpr_replica_globals.srch_ival)->addr[0]);
cntr = OBJ_NEW(orte_gpr_replica_counter_t);
if (NULL == cntr) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
cntr->seg = seg;
cntr->cptr = cptr[k];
cntr->iptr = iptr;
cntr->trigger_level.type = (trigs[j]->keyvals[i])->type;
if (ORTE_SUCCESS != (rc = orte_gpr_base_xfer_payload(&(cntr->trigger_level.value),
&((trigs[j]->keyvals[i])->value), (trigs[j]->keyvals[i])->type))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
if (0 > orte_pointer_array_add(&index, trig->counters, cntr)) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
(trig->num_counters)++;
} /* end if found */
} /* end if cptr NULL */
} /* end for j */
if (!found) { /* specified counter never found - error */
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
rc = ORTE_ERR_BAD_PARAM;
goto CLEANUP;
} /* end if found */
} /* end for i */
} /* end if/else container found */
/* check the triggers on this segment before leaving to see if they are already fired */
if (ORTE_SUCCESS !=
(rc = orte_gpr_replica_check_subscriptions(seg))) {
ORTE_ERROR_LOG(rc);
return rc;
}
} /* end for j */
} /* end if trigger */
CLEANUP:
if (NULL != tokentags) {
free(tokentags);
}
trig->num_subscriptions += num_subs;
}
if (ORTE_SUCCESS != rc) OBJ_RELEASE(trig);
return rc;
}
int orte_gpr_replica_unsubscribe_fn(orte_gpr_notify_id_t sub_number)
{
orte_gpr_replica_triggers_t *trig;
if (orte_gpr_replica_globals.debug) {
ompi_output(0, "[%lu,%lu,%lu] gpr replica: unsubscribe entered for sub number %d",
ORTE_NAME_ARGS(orte_process_info.my_name), sub_number);
}
/* release trigger on replica and remove it */
trig = (orte_gpr_replica_triggers_t*)((orte_gpr_replica.triggers)->addr[sub_number]);
if (NULL == trig) {
return ORTE_ERR_BAD_PARAM;
}
OBJ_RELEASE(trig);
orte_pointer_array_set_item(orte_gpr_replica.triggers, sub_number, NULL);
return ORTE_SUCCESS;
}

1032
src/mca/gpr/replica/functional_layer/gpr_replica_trig_ops_fn.c
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

189
src/mca/gpr/replica/gpr_replica.h
Просмотреть файл

@ -77,22 +77,36 @@ typedef uint8_t orte_gpr_replica_addr_mode_t;
typedef int8_t orte_gpr_replica_action_t;
/*
* Local subscription tracker for use by processes
* that are operating on the same node as the replica
*/
typedef struct {
ompi_object_t super; /**< Allows this to be an object */
orte_gpr_subscription_id_t id; /**< id of this subscription */
orte_gpr_notify_cb_fn_t callback; /**< Function to be called for notificaiton */
void *user_tag; /**< User-provided tag for callback function */
} orte_gpr_replica_local_subscriber_t;
OBJ_CLASS_DECLARATION(orte_gpr_replica_local_subscriber_t);
typedef struct {
int debug;
int isolate;
size_t block_size;
size_t max_size;
ompi_mutex_t mutex;
bool compound_cmd_mode;
bool exec_compound_cmd_mode;
orte_buffer_t *compound_cmd;
ompi_mutex_t wait_for_compound_mutex;
ompi_condition_t compound_cmd_condition;
int compound_cmd_waiting;
size_t num_local_subs;
orte_pointer_array_t *local_subscriptions;
size_t trig_cntr;
size_t num_srch_cptr;
orte_pointer_array_t *srch_cptr;
orte_pointer_array_t *sub_ptrs;
size_t num_srch_ival;
orte_pointer_array_t *srch_ival;
orte_pointer_array_t *acted_upon;
size_t num_acted_upon;
orte_pointer_array_t *acted_upon;
orte_bitmap_t srch_itag;
} orte_gpr_replica_globals_t;
@ -125,6 +139,8 @@ struct orte_gpr_replica_t {
size_t num_segs;
orte_pointer_array_t *triggers; /**< Managed array of pointers to triggers */
size_t num_trigs;
orte_pointer_array_t *subscriptions; /**< Managed array of pointers to subscriptions */
size_t num_subs;
bool processing_callbacks;
ompi_list_t callbacks; /**< List of callbacks to be processed */
};
@ -144,7 +160,9 @@ struct orte_gpr_replica_segment_t {
ompi_object_t super; /**< Make this an object */
char *name; /**< Name of the segment */
orte_gpr_replica_itag_t itag; /**< itag of this segment */
size_t num_dict_entries;
orte_pointer_array_t *dict; /**< Managed array of dict structs */
size_t num_containers;
orte_pointer_array_t *containers; /**< Managed array of pointers to containers on this segment */
};
typedef struct orte_gpr_replica_segment_t orte_gpr_replica_segment_t;
@ -177,6 +195,7 @@ struct orte_gpr_replica_container_t {
orte_gpr_replica_itag_t *itags; /**< Array of itags that define this container */
size_t num_itags; /**< Number of itags in array */
orte_pointer_array_t *itagvals; /**< Array of itagval pointers */
size_t num_itagvals; /**< Number of itagvals in container */
orte_value_array_t itaglist; /**< Array of itags from all itagvals - used for rapid search */
};
typedef struct orte_gpr_replica_container_t orte_gpr_replica_container_t;
@ -196,6 +215,23 @@ typedef struct {
OBJ_CLASS_DECLARATION(orte_gpr_replica_itagval_t);
/* The equivalent of the value structure, only using internal
* itags for the tokens/keys and pointers to internal structures
*/
typedef struct {
ompi_object_t super; /**< Makes this an object */
size_t index;
/* the segment upon which this data is located */
orte_gpr_replica_segment_t *seg;
/* describe the data */
orte_gpr_addr_mode_t addr_mode; /**< Tokens/keys addressing mode */
orte_value_array_t tokentags; /**< Array of tokens defining which containers are affected */
orte_value_array_t keytags; /**< Array of keys defining which key-value pairs are affected */
} orte_gpr_replica_ivalue_t;
OBJ_CLASS_DECLARATION(orte_gpr_replica_ivalue_t);
typedef struct {
ompi_object_t super;
orte_gpr_replica_segment_t *seg;
@ -207,58 +243,101 @@ typedef struct {
OBJ_CLASS_DECLARATION(orte_gpr_replica_counter_t);
typedef struct {
ompi_object_t super; /**< Makes this an object */
size_t index; /**< Index of this entry in original subscription */
/* the segment upon which this data is located */
orte_gpr_replica_segment_t *seg;
/* describe the data to be returned with the message -
* for triggers that are counting themselves (i.e., not monitoring a separate
* counter), this also describes the data to be included in the count
*/
orte_gpr_addr_mode_t addr_mode; /**< Tokens/keys addressing mode */
orte_value_array_t tokentags; /**< Array of tokens defining which containers are affected */
orte_value_array_t keytags; /**< Array of keys defining which key-value pairs are affected */
/* where this block of data goes */
orte_gpr_notify_cb_fn_t callback; /**< Function to be called for notification */
void *user_tag; /**< User-provided tag for callback function */
} orte_gpr_replica_subscribed_data_t;
OBJ_CLASS_DECLARATION(orte_gpr_replica_subscribed_data_t);
struct orte_gpr_replica_triggers_t {
ompi_object_t super; /**< Make this an object */
/* index of this trigger in the triggers array */
ompi_object_t super;
/* index of this entry in requestor array */
size_t index;
/* process name of the recipient - set to NULL if local */
orte_process_name_t *requestor;
/* idtag associated with this subscription */
orte_gpr_subscription_id_t idtag;
/* for a local subscription, where this block of data goes */
orte_gpr_notify_cb_fn_t callback; /**< Function to be called for notification */
void *user_tag; /**< User-provided tag for callback function */
} orte_gpr_replica_requestor_t;
OBJ_CLASS_DECLARATION(orte_gpr_replica_requestor_t);
typedef struct {
ompi_object_t super; /**< Makes this an object */
/* index of this entry in subscription array - corresponds to local idtag */
size_t index;
/* name of this subscription, if provided */
char *name;
/* boolean indicating if this subscription is active or not */
bool active;
/* boolean indicating that this subscription
* should be removed after processing
* is completed
*/
bool cleanup;
/* action flags describing when the subscription should
* generate a notification message. This can be NULL if
* the subscription only operates in conjunction
* with a trigger
*/
orte_gpr_notify_action_t action;
/* Array of ivalues that describe the data to be
* returned when this subscription is "fired"
*/
size_t num_values;
orte_pointer_array_t *values;
/*
* Array of requestors that are "attached" to this subscription
*/
size_t num_requestors;
orte_pointer_array_t *requestors;
} orte_gpr_replica_subscription_t;
OBJ_CLASS_DECLARATION(orte_gpr_replica_subscription_t);
typedef struct {
ompi_object_t super;
/* index of this entry in array */
size_t index;
/* process name of the requestor - set to NULL if local */
orte_process_name_t *requestor;
/* requestor's id for this trigger */
orte_gpr_trigger_id_t idtag;
} orte_gpr_replica_trigger_requestor_t;
OBJ_CLASS_DECLARATION(orte_gpr_replica_trigger_requestor_t);
struct orte_gpr_replica_trigger_t {
ompi_object_t super; /**< Make this an object */
/* name of this trigger, if provided */
char *name;
/* index of this trigger in the triggers array - corresponds to local idtag */
size_t index;
/* array of requestors that have "attached" themselves to this trigger */
size_t num_attached;
orte_pointer_array_t *attached;
/* the action that causes the trigger to be fired */
orte_gpr_notify_action_t action;
/* flag that indicates this trigger is a one-shot, has fired and
* now should be cleaned up
*/
bool one_shot_fired;
/* the action that causes a notification message to be sent out */
orte_gpr_notify_action_t action;
/* to whom the notification messages go - set to NULL if local */
orte_process_name_t *requestor; /**< Name of requesting process */
/* remote idtag associated with this subscription -
* set to ORTE_GPR_NOTIFY_ID_MAX if local
*/
orte_gpr_notify_id_t remote_idtag; /**< Remote ID tag of subscription */
/* a pointer to the data belonging to this subscription. Each subscribed data
* object describes a set of data to be returned whenever this subscription
* fires. for subscriptions that do not involve trigger events, these objects
* describe the data being monitored
*/
size_t num_subscribed_data;
orte_pointer_array_t *subscribed_data;
/* for triggers, store a pointer to the counters being monitored. This could
/* pointers to the counters being monitored. This could
* be counters we are using ourselves, or could be counters being run by someone
* else. Store the trigger level for each counter that we are monitoring until they reach
* a specified level (as opposed to comparing values in two or more counters).
* else. For those triggers that fire at a specified level (as opposed to
* comparing values in two or more counters), store the trigger level for
* each counter that we are monitoring until they reach a specified level.
*/
size_t num_counters;
orte_pointer_array_t *counters;
/* a pointer to the subscriptions associated with this trigger. These
* describe the data that will be returned when the trigger fires, and to
* whom and where it goes.
*/
size_t num_subscriptions;
orte_pointer_array_t *subscriptions;
};
typedef struct orte_gpr_replica_triggers_t orte_gpr_replica_triggers_t;
typedef struct orte_gpr_replica_trigger_t orte_gpr_replica_trigger_t;
OBJ_CLASS_DECLARATION(orte_gpr_replica_trigger_t);
OBJ_CLASS_DECLARATION(orte_gpr_replica_triggers_t);
/*
* Action taken object - used to track what action was taken against what
@ -277,25 +356,13 @@ typedef struct {
OBJ_CLASS_DECLARATION(orte_gpr_replica_action_taken_t);
/*
* Notify message list objects - used to track individual messages going to
* the same recipient
*/
typedef struct {
ompi_list_item_t item;
orte_gpr_notify_message_t *message;
} orte_gpr_replica_notify_msg_list_t;
OBJ_CLASS_DECLARATION(orte_gpr_replica_notify_msg_list_t);
/*
* Callback list objects
*/
struct orte_gpr_replica_callbacks_t {
ompi_list_item_t item;
ompi_list_t messages;
orte_process_name_t *requestor;
orte_gpr_notify_message_t *message;
};
typedef struct orte_gpr_replica_callbacks_t orte_gpr_replica_callbacks_t;

536
src/mca/gpr/replica/gpr_replica_class_instances.h Обычный файл
Просмотреть файл

@ -0,0 +1,536 @@
/* -*- C -*-
*
* 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$
*
*/
/** @file
*/
#ifndef ORTE_GPR_REPLICA_CLASS_INSTANCES_H_
#define ORTE_GPR_REPLICA_CLASS_INSTANCES_H_
#include "orte_config.h"
#include "class/orte_bitmap.h"
#include "class/ompi_object.h"
#include "gpr_replica.h"
/*
* CONSTRUCTORS, DESTRUCTORS, AND CLASS INSTANTIATIONS
* FOR GPR REPLICA CLASSES
*/
/* LOCAL_SUBSCRIBER */
/* no constructor or destructor needed, so just
* define instance */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_local_subscriber_t, /* type name */
ompi_object_t, /* parent "class" name */
NULL, /* constructor */
NULL); /* destructor */
/* SEGMENT */
/* constructor - used to initialize state of segment instance */
static void orte_gpr_replica_segment_construct(orte_gpr_replica_segment_t* seg)
{
seg->name = NULL;
seg->itag = ORTE_GPR_REPLICA_ITAG_MAX;
seg->num_dict_entries = 0;
orte_pointer_array_init(&(seg->dict), orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size);
seg->num_containers = 0;
orte_pointer_array_init(&(seg->containers), orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size);
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_segment_destructor(orte_gpr_replica_segment_t* seg)
{
size_t i, k;
orte_gpr_replica_dict_t **dptr;
orte_gpr_replica_container_t **cptr;
if (NULL != seg->name) {
free(seg->name);
}
if (NULL != seg->dict) {
dptr = (orte_gpr_replica_dict_t**)((seg->dict)->addr);
for (i=0, k=0; k < seg->num_dict_entries &&
i < (seg->dict)->size; i++) {
if (NULL != dptr[i]) {
k++;
if (NULL != dptr[i]->entry) {
free(dptr[i]->entry);
}
free(dptr[i]);
}
}
OBJ_RELEASE(seg->dict);
}
if (NULL != seg->containers) {
cptr = (orte_gpr_replica_container_t**)((seg->containers)->addr);
for (i=0, k=0; k < seg->num_containers &&
i < (seg->containers)->size; i++) {
if (NULL != cptr[i]) {
k++;
OBJ_RELEASE(cptr[i]);
}
}
OBJ_RELEASE(seg->containers);
}
}
/* define instance of orte_gpr_replica_segment_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_segment_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_segment_construct, /* constructor */
orte_gpr_replica_segment_destructor); /* destructor */
/* CONTAINER */
/* constructor - used to initialize state of registry container instance */
static void orte_gpr_replica_container_construct(orte_gpr_replica_container_t* reg)
{
reg->index = 0;
reg->itags = NULL;
reg->num_itags = 0;
orte_pointer_array_init(&(reg->itagvals), orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size);
reg->num_itagvals = 0;
OBJ_CONSTRUCT(&(reg->itaglist), orte_value_array_t);
orte_value_array_init(&(reg->itaglist), sizeof(orte_gpr_replica_itag_t));
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_container_destructor(orte_gpr_replica_container_t* reg)
{
orte_gpr_replica_itagval_t **ptr;
size_t i, k;
if (NULL != reg->itags) {
free(reg->itags);
}
if (NULL != reg->itagvals) {
ptr = (orte_gpr_replica_itagval_t**)((reg->itagvals)->addr);
for (i=0, k=0; k < reg->num_itagvals &&
i < (reg->itagvals)->size; i++) {
if (NULL != ptr[i]) {
k++;
OBJ_RELEASE(ptr[i]);
}
}
OBJ_RELEASE(reg->itagvals);
}
OBJ_DESTRUCT(&(reg->itaglist));
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_container_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_container_construct, /* constructor */
orte_gpr_replica_container_destructor); /* destructor */
/* ITAG-VALUE PAIR */
/* constructor - used to initialize state of itagval instance */
static void orte_gpr_replica_itagval_construct(orte_gpr_replica_itagval_t* ptr)
{
ptr->index = 0;
ptr->itag = ORTE_GPR_REPLICA_ITAG_MAX;
ptr->type = ORTE_NULL;
(ptr->value).i32 = 0;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_itagval_destructor(orte_gpr_replica_itagval_t* ptr)
{
if (ORTE_BYTE_OBJECT == ptr->type) {
free(((ptr->value).byteobject).bytes);
} else if (ORTE_STRING == ptr->type) {
if (NULL != ptr->value.strptr)
free(ptr->value.strptr);
} else if (ORTE_APP_CONTEXT == ptr->type) {
if (NULL != ptr->value.app_context)
OBJ_RELEASE(ptr->value.app_context);
}
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_itagval_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_itagval_construct, /* constructor */
orte_gpr_replica_itagval_destructor); /* destructor */
/* IVALUE */
/* constructor - used to initialize state of ivalue instance */
static void orte_gpr_replica_ivalue_construct(orte_gpr_replica_ivalue_t* ptr)
{
ptr->index = 0;
ptr->seg = NULL;
ptr->addr_mode = 0;
OBJ_CONSTRUCT(&(ptr->tokentags), orte_value_array_t);
orte_value_array_init(&(ptr->tokentags), sizeof(orte_gpr_replica_itag_t));
OBJ_CONSTRUCT(&(ptr->keytags), orte_value_array_t);
orte_value_array_init(&(ptr->keytags), sizeof(orte_gpr_replica_itag_t));
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_ivalue_destructor(orte_gpr_replica_ivalue_t* ptr)
{
OBJ_DESTRUCT(&(ptr->tokentags));
OBJ_DESTRUCT(&(ptr->keytags));
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_ivalue_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_ivalue_construct, /* constructor */
orte_gpr_replica_ivalue_destructor); /* destructor */
/* COUNTERS */
/* constructor - used to initialize state of counter instance */
static void orte_gpr_replica_counter_construct(orte_gpr_replica_counter_t* cntr)
{
cntr->seg = NULL;
cntr->cptr = NULL;
cntr->iptr = NULL;
OBJ_CONSTRUCT(&(cntr->trigger_level), orte_gpr_replica_itagval_t);
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_counter_destructor(orte_gpr_replica_counter_t* cntr)
{
OBJ_DESTRUCT(&(cntr->trigger_level));
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_counter_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_counter_construct, /* constructor */
orte_gpr_replica_counter_destructor); /* destructor */
/* REQUESTOR */
/* constructor - used to initialize state of requestor instance */
static void orte_gpr_replica_requestor_construct(orte_gpr_replica_requestor_t* ptr)
{
ptr->index = 0;
ptr->requestor = NULL;
ptr->idtag = 0;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_requestor_destructor(orte_gpr_replica_requestor_t* ptr)
{
if (NULL != ptr->requestor) free(ptr->requestor);
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_requestor_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_requestor_construct, /* constructor */
orte_gpr_replica_requestor_destructor); /* destructor */
/* SUBSCRIPTION */
/* constructor - used to initialize state of subscription instance */
static void orte_gpr_replica_subscription_construct(orte_gpr_replica_subscription_t* sub)
{
sub->index = 0;
sub->name = NULL;
sub->active = false;
sub->cleanup = false;
sub->action = ORTE_GPR_REPLICA_NO_ACTION;
sub->num_values = 0;
orte_pointer_array_init(&(sub->values), orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size);
sub->num_requestors = 0;
orte_pointer_array_init(&(sub->requestors), orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size);
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_subscription_destructor(orte_gpr_replica_subscription_t* sub)
{
orte_gpr_replica_requestor_t **ptr;
orte_gpr_replica_ivalue_t **ivals;
size_t i, k;
if (NULL != sub->name) free(sub->name);
if (NULL != sub->requestors) {
ptr = (orte_gpr_replica_requestor_t**)((sub->requestors)->addr);
for (i=0, k=0; k < sub->num_requestors &&
i < (sub->requestors)->size; i++) {
if (NULL != ptr[i]) {
k++;
OBJ_RELEASE(ptr[i]);
}
}
OBJ_RELEASE(sub->requestors);
}
if (NULL != sub->values) {
ivals = (orte_gpr_replica_ivalue_t**)((sub->values)->addr);
for (i=0, k=0; k < sub->num_values &&
i < (sub->values)->size; i++) {
if (NULL != ivals[i]) {
k++;
OBJ_RELEASE(ivals[i]);
}
}
OBJ_RELEASE(sub->values);
}
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_subscription_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_subscription_construct, /* constructor */
orte_gpr_replica_subscription_destructor); /* destructor */
/* TRIGGER REQUESTOR */
/* constructor - used to initialize state of instance */
static void orte_gpr_replica_trigger_requestor_construct(orte_gpr_replica_trigger_requestor_t* ptr)
{
ptr->index = 0;
ptr->requestor = NULL;
ptr->idtag = 0;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_trigger_requestor_destructor(orte_gpr_replica_trigger_requestor_t* ptr)
{
if (NULL != ptr->requestor) free(ptr->requestor);
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_trigger_requestor_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_trigger_requestor_construct, /* constructor */
orte_gpr_replica_trigger_requestor_destructor); /* destructor */
/* TRIGGER */
/* constructor - used to initialize state of trigger instance */
static void orte_gpr_replica_trigger_construct(orte_gpr_replica_trigger_t* trig)
{
trig->name = NULL;
trig->index = 0;
trig->num_attached = 0;
orte_pointer_array_init(&(trig->attached), orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size);
trig->action = ORTE_GPR_REPLICA_NO_ACTION;
trig->one_shot_fired = false;
trig->num_counters = 0;
orte_pointer_array_init(&(trig->counters), orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size);
trig->num_subscriptions = 0;
orte_pointer_array_init(&(trig->subscriptions), orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size);
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_trigger_destructor(orte_gpr_replica_trigger_t* trig)
{
size_t i, cnt;
orte_gpr_replica_counter_t **cntrs;
orte_gpr_replica_trigger_requestor_t **att;
if (NULL != trig->name) {
free(trig->name);
}
/* must go through the array of atached and release
* the memory for each one prior to releasing the array
*/
if (NULL != trig->attached) {
att = (orte_gpr_replica_trigger_requestor_t**)((trig->attached)->addr);
cnt = 0;
for (i=0; cnt < trig->num_attached && i < (trig->attached)->size; i++) {
if (NULL != att[i]) {
cnt++;
OBJ_RELEASE(att[i]);
}
}
OBJ_RELEASE(trig->attached);
}
/* must go through the array of counters and release
* the memory for each one prior to releasing the array
*/
if (NULL != trig->counters) {
cntrs = (orte_gpr_replica_counter_t**)((trig->counters)->addr);
cnt = 0;
for (i=0; cnt < trig->num_counters && i < (trig->counters)->size; i++) {
if (NULL != cntrs[i]) {
cnt++;
OBJ_RELEASE(cntrs[i]);
}
}
OBJ_RELEASE(trig->counters);
}
/* the array of subscriptions is separately maintained, so we
* do NOT release the subscription memory here. We only release
* the array of pointers we were using to reference into the
* subscription array
*/
if (NULL != trig->subscriptions) {
OBJ_RELEASE(trig->subscriptions);
}
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_trigger_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_trigger_construct, /* constructor */
orte_gpr_replica_trigger_destructor); /* destructor */
/* ACTION_TAKEN */
/* constructor - used to initialize state of action_take instance */
static void orte_gpr_replica_action_taken_construct(orte_gpr_replica_action_taken_t* ptr)
{
ptr->action = ORTE_GPR_REPLICA_NO_ACTION;
ptr->seg = NULL;
ptr->cptr = NULL;
ptr->iptr = NULL;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_action_taken_destructor(orte_gpr_replica_action_taken_t* ptr)
{
/* since we did a "RETAIN" on the objects pointed to by this object,
* we need to "RELEASE" them to indicate we are done with them
*/
if (NULL != ptr->seg) OBJ_RELEASE(ptr->seg);
if (NULL != ptr->cptr) OBJ_RELEASE(ptr->cptr);
if (NULL != ptr->iptr) OBJ_RELEASE(ptr->iptr);
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_action_taken_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_action_taken_construct, /* constructor */
orte_gpr_replica_action_taken_destructor); /* destructor */
/* CALLBACKS */
/* constructor - used to initialize state of callback list instance */
static void orte_gpr_replica_callbacks_construct(orte_gpr_replica_callbacks_t* cb)
{
cb->message = NULL;
cb->requestor = NULL;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_callbacks_destructor(orte_gpr_replica_callbacks_t* cb)
{
if (NULL != cb->message) OBJ_RELEASE(cb->message);
if (NULL != cb->requestor) {
free(cb->requestor);
}
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_callbacks_t, /* type name */
ompi_list_item_t, /* parent "class" name */
orte_gpr_replica_callbacks_construct, /* constructor */
orte_gpr_replica_callbacks_destructor); /* destructor */
/* REPLICA LIST - NOT IMPLEMENTED YET! */
/* constructor - used to initialize state of replica list instance */
static void orte_gpr_replica_list_construct(orte_gpr_replica_list_t* replica)
{
replica->replica = NULL;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_list_destructor(orte_gpr_replica_list_t* replica)
{
if (NULL != replica->replica) {
free(replica->replica);
replica->replica = NULL;
}
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_list_t, /* type name */
ompi_list_item_t, /* parent "class" name */
orte_gpr_replica_list_construct, /* constructor */
orte_gpr_replica_list_destructor); /* destructor */
/* WRITE INVALIDATE - NOT IMPLEMENTED YET! */
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_write_invalidate_t, /* type name */
ompi_list_item_t, /* parent "class" name */
NULL, /* constructor */
NULL); /* destructor */
#endif /* _GPR_REPLICA_CLASS_INSTANCES_H_ */

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

@ -86,6 +86,7 @@ static orte_gpr_base_module_t orte_gpr_replica_module = {
/* SUBSCRIBE OPERATIONS */
orte_gpr_replica_subscribe,
orte_gpr_replica_unsubscribe,
orte_gpr_replica_cancel_trigger,
/* COMPOUND COMMANDS */
orte_gpr_replica_begin_compound_cmd,
orte_gpr_replica_stop_compound_cmd,
@ -94,6 +95,7 @@ static orte_gpr_base_module_t orte_gpr_replica_module = {
orte_gpr_replica_dump_all,
orte_gpr_replica_dump_segments,
orte_gpr_replica_dump_triggers,
orte_gpr_replica_dump_subscriptions,
orte_gpr_replica_dump_callbacks,
orte_gpr_replica_dump_notify_msg,
orte_gpr_replica_dump_notify_data,
@ -116,396 +118,8 @@ orte_gpr_replica_t orte_gpr_replica;
orte_gpr_replica_globals_t orte_gpr_replica_globals;
/*
* CONSTRUCTORS AND DESTRUCTORS
*/
/* SEGMENT */
/* constructor - used to initialize state of segment instance */
static void orte_gpr_replica_segment_construct(orte_gpr_replica_segment_t* seg)
{
seg->name = NULL;
seg->itag = ORTE_GPR_REPLICA_ITAG_MAX;
orte_pointer_array_init(&(seg->dict), orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size);
orte_pointer_array_init(&(seg->containers), orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size);
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_segment_destructor(orte_gpr_replica_segment_t* seg)
{
size_t i, j;
orte_gpr_replica_dict_t **dptr;
orte_gpr_replica_container_t **cptr;
if (NULL != seg->name) {
free(seg->name);
}
if (NULL != seg->dict) {
dptr = (orte_gpr_replica_dict_t**)((seg->dict)->addr);
for (i=0; i < (seg->dict)->size; i++) {
if (NULL != dptr[i]) {
if (NULL != dptr[i]->entry) {
free(dptr[i]->entry);
}
free(dptr[i]);
}
}
OBJ_RELEASE(seg->dict);
}
if (NULL != seg->containers) {
cptr = (orte_gpr_replica_container_t**)((seg->containers)->addr);
for (i=0; i < (seg->containers)->size; i++) {
if (NULL != cptr[i]) {
j = i;
OBJ_RELEASE(cptr[i]);
orte_pointer_array_set_item(seg->containers, j, NULL);
}
}
OBJ_RELEASE(seg->containers);
}
}
/* define instance of orte_gpr_replica_segment_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_segment_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_segment_construct, /* constructor */
orte_gpr_replica_segment_destructor); /* destructor */
/* CONTAINER */
/* constructor - used to initialize state of registry container instance */
static void orte_gpr_replica_container_construct(orte_gpr_replica_container_t* reg)
{
orte_pointer_array_init(&(reg->itagvals), orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size);
OBJ_CONSTRUCT(&(reg->itaglist), orte_value_array_t);
orte_value_array_init(&(reg->itaglist), sizeof(orte_gpr_replica_itag_t));
reg->itags = NULL;
reg->num_itags = 0;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_container_destructor(orte_gpr_replica_container_t* reg)
{
orte_gpr_replica_itagval_t **ptr;
size_t i, j;
if (NULL != reg->itags) {
free(reg->itags);
}
if (NULL != reg->itagvals) {
ptr = (orte_gpr_replica_itagval_t**)((reg->itagvals)->addr);
for (i=0; i < (reg->itagvals)->size; i++) {
if (NULL != ptr[i]) {
j = i;
OBJ_RELEASE(ptr[i]);
orte_pointer_array_set_item(reg->itagvals, j, NULL);
}
}
OBJ_RELEASE(reg->itagvals);
}
OBJ_DESTRUCT(&(reg->itaglist));
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_container_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_container_construct, /* constructor */
orte_gpr_replica_container_destructor); /* destructor */
/* ITAG-VALUE PAIR */
/* constructor - used to initialize state of itagval instance */
static void orte_gpr_replica_itagval_construct(orte_gpr_replica_itagval_t* ptr)
{
ptr->index = 0;
ptr->itag = ORTE_GPR_REPLICA_ITAG_MAX;
ptr->type = ORTE_NULL;
(ptr->value).i32 = 0;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_itagval_destructor(orte_gpr_replica_itagval_t* ptr)
{
if (ORTE_BYTE_OBJECT == ptr->type) {
free(((ptr->value).byteobject).bytes);
} else if (ORTE_STRING == ptr->type) {
if (NULL != ptr->value.strptr)
free(ptr->value.strptr);
} else if (ORTE_APP_CONTEXT == ptr->type) {
if (NULL != ptr->value.app_context)
OBJ_RELEASE(ptr->value.app_context);
}
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_itagval_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_itagval_construct, /* constructor */
orte_gpr_replica_itagval_destructor); /* destructor */
/* COUNTERS */
/* constructor - used to initialize state of counter instance */
static void orte_gpr_replica_counter_construct(orte_gpr_replica_counter_t* cntr)
{
cntr->seg = NULL;
cntr->cptr = NULL;
cntr->iptr = NULL;
OBJ_CONSTRUCT(&(cntr->trigger_level), orte_gpr_replica_itagval_t);
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_counter_destructor(orte_gpr_replica_counter_t* cntr)
{
OBJ_DESTRUCT(&(cntr->trigger_level));
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_counter_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_counter_construct, /* constructor */
orte_gpr_replica_counter_destructor); /* destructor */
/* SUBSCRIBED DATA */
/* constructor - used to initialize state of subscribed data instance */
static void orte_gpr_replica_subscribed_data_construct(orte_gpr_replica_subscribed_data_t* data)
{
data->seg = NULL;
data->addr_mode = 0;
OBJ_CONSTRUCT(&(data->tokentags), orte_value_array_t);
orte_value_array_init(&(data->tokentags), sizeof(orte_gpr_replica_itag_t));
OBJ_CONSTRUCT(&(data->keytags), orte_value_array_t);
orte_value_array_init(&(data->keytags), sizeof(orte_gpr_replica_itag_t));
data->callback = NULL;
data->user_tag = NULL;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_subscribed_data_destructor(orte_gpr_replica_subscribed_data_t* data)
{
OBJ_DESTRUCT(&(data->tokentags));
OBJ_DESTRUCT(&(data->keytags));
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_subscribed_data_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_subscribed_data_construct, /* constructor */
orte_gpr_replica_subscribed_data_destructor); /* destructor */
/* TRIGGERS */
/* constructor - used to initialize state of trigger instance */
static void orte_gpr_replica_trigger_construct(orte_gpr_replica_triggers_t* trig)
{
trig->index = 0;
trig->action = 0;
trig->one_shot_fired = false;
trig->requestor = NULL;
trig->remote_idtag = ORTE_GPR_NOTIFY_ID_MAX;
trig->num_subscribed_data = 0;
orte_pointer_array_init(&(trig->subscribed_data), 10,
orte_gpr_replica_globals.max_size, 10);
trig->num_counters = 0;
orte_pointer_array_init(&(trig->counters), 1, orte_gpr_replica_globals.max_size, 1);
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_trigger_destructor(orte_gpr_replica_triggers_t* trig)
{
size_t i, j;
orte_gpr_replica_subscribed_data_t **data;
orte_gpr_replica_counter_t **cntrs;
if (NULL != trig->requestor) {
free(trig->requestor);
}
if (NULL != trig->subscribed_data) {
data = (orte_gpr_replica_subscribed_data_t**)((trig->subscribed_data)->addr);
for (i=0; i < (trig->subscribed_data)->size; i++) {
if (NULL != data[i]) {
j = i;
OBJ_RELEASE(data[i]);
orte_pointer_array_set_item(trig->subscribed_data, j, NULL);
}
}
OBJ_RELEASE(trig->subscribed_data);
}
if (NULL != trig->counters) {
cntrs = (orte_gpr_replica_counter_t**)((trig->counters)->addr);
for (i=0; i < (trig->counters)->size; i++) {
if (NULL != cntrs[i]) {
j = i;
OBJ_RELEASE(cntrs[i]);
orte_pointer_array_set_item(trig->counters, j, NULL);
}
}
OBJ_RELEASE(trig->counters);
}
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_triggers_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_trigger_construct, /* constructor */
orte_gpr_replica_trigger_destructor); /* destructor */
/* ACTION_TAKEN */
/* constructor - used to initialize state of action_take instance */
static void orte_gpr_replica_action_taken_construct(orte_gpr_replica_action_taken_t* ptr)
{
ptr->action = ORTE_GPR_REPLICA_NO_ACTION;
ptr->seg = NULL;
ptr->cptr = NULL;
ptr->iptr = NULL;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_action_taken_destructor(orte_gpr_replica_action_taken_t* ptr)
{
/* since we did a "RETAIN" on the objects pointed to by this object,
* we need to "RELEASE" them to indicate we are done with them
*/
if (NULL != ptr->seg) OBJ_RELEASE(ptr->seg);
if (NULL != ptr->cptr) OBJ_RELEASE(ptr->cptr);
if (NULL != ptr->iptr) OBJ_RELEASE(ptr->iptr);
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_action_taken_t, /* type name */
ompi_object_t, /* parent "class" name */
orte_gpr_replica_action_taken_construct, /* constructor */
orte_gpr_replica_action_taken_destructor); /* destructor */
/* NOTIFY MSG LIST */
/* constructor - used to initialize state of notify msg list instance */
static void orte_gpr_replica_notify_msg_list_construct(orte_gpr_replica_notify_msg_list_t* msg)
{
msg->message = NULL;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_notify_msg_list_destructor(orte_gpr_replica_notify_msg_list_t* msg)
{
if (NULL != msg->message) {
OBJ_RELEASE(msg->message);
}
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_notify_msg_list_t, /* type name */
ompi_list_item_t, /* parent "class" name */
orte_gpr_replica_notify_msg_list_construct, /* constructor */
orte_gpr_replica_notify_msg_list_destructor); /* destructor */
/* CALLBACKS */
/* constructor - used to initialize state of callback list instance */
static void orte_gpr_replica_callbacks_construct(orte_gpr_replica_callbacks_t* cb)
{
OBJ_CONSTRUCT(&(cb->messages), ompi_list_t);
cb->requestor = NULL;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_callbacks_destructor(orte_gpr_replica_callbacks_t* cb)
{
orte_gpr_replica_notify_msg_list_t *msg;
if (NULL != cb->requestor) {
free(cb->requestor);
cb->requestor = NULL;
}
if (0 < ompi_list_get_size(&(cb->messages))) {
while (NULL != (msg = (orte_gpr_replica_notify_msg_list_t*)ompi_list_remove_first(&(cb->messages)))) {
OBJ_RELEASE(msg);
}
}
OBJ_DESTRUCT(&(cb->messages));
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_callbacks_t, /* type name */
ompi_list_item_t, /* parent "class" name */
orte_gpr_replica_callbacks_construct, /* constructor */
orte_gpr_replica_callbacks_destructor); /* destructor */
/* REPLICA LIST - NOT IMPLEMENTED YET! */
/* constructor - used to initialize state of replica list instance */
static void orte_gpr_replica_list_construct(orte_gpr_replica_list_t* replica)
{
replica->replica = NULL;
}
/* destructor - used to free any resources held by instance */
static void orte_gpr_replica_list_destructor(orte_gpr_replica_list_t* replica)
{
if (NULL != replica->replica) {
free(replica->replica);
replica->replica = NULL;
}
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_list_t, /* type name */
ompi_list_item_t, /* parent "class" name */
orte_gpr_replica_list_construct, /* constructor */
orte_gpr_replica_list_destructor); /* destructor */
/* WRITE INVALIDATE - NOT IMPLEMENTED YET! */
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
orte_gpr_replica_write_invalidate_t, /* type name */
ompi_list_item_t, /* parent "class" name */
NULL, /* constructor */
NULL); /* destructor */
/* instantiate the classes */
#include "mca/gpr/replica/gpr_replica_class_instances.h"
int orte_gpr_replica_open(void)
{
@ -557,66 +171,92 @@ orte_gpr_base_module_t *orte_gpr_replica_init(bool *allow_multi_user_threads, bo
if (NULL == orte_process_info.gpr_replica_uri) {
/* Return a module (choose an arbitrary, positive priority --
it's only relevant compared to other ns components). If
we're not the seed, then we don't want to be selected, so
return NULL. */
/* Return a module (choose an arbitrary, positive priority --
it's only relevant compared to other ns components). If
we're not the seed, then we don't want to be selected, so
return NULL. */
*priority = 50;
/* We allow multi user threads but don't have any hidden threads */
*allow_multi_user_threads = true;
*have_hidden_threads = false;
/* setup the thread locks and condition variables */
OBJ_CONSTRUCT(&orte_gpr_replica_globals.mutex, ompi_mutex_t);
/* initialize the registry head */
if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica.segments),
orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size))) {
ORTE_ERROR_LOG(rc);
return NULL;
}
orte_gpr_replica.num_segs = 0;
*priority = 50;
if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica.triggers),
orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size))) {
ORTE_ERROR_LOG(rc);
return NULL;
}
orte_gpr_replica.num_trigs = 0;
/* We allow multi user threads but don't have any hidden threads */
if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica.subscriptions),
orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size))) {
ORTE_ERROR_LOG(rc);
return NULL;
}
orte_gpr_replica.num_subs = 0;
*allow_multi_user_threads = true;
*have_hidden_threads = false;
/* setup the thread locks and condition variables */
OBJ_CONSTRUCT(&orte_gpr_replica_globals.mutex, ompi_mutex_t);
OBJ_CONSTRUCT(&orte_gpr_replica_globals.wait_for_compound_mutex, ompi_mutex_t);
OBJ_CONSTRUCT(&orte_gpr_replica_globals.compound_cmd_condition, ompi_condition_t);
/* initialize the registry compound mode */
orte_gpr_replica_globals.compound_cmd_mode = false;
orte_gpr_replica_globals.exec_compound_cmd_mode = false;
orte_gpr_replica_globals.compound_cmd_waiting = 0;
orte_gpr_replica_globals.compound_cmd = NULL;
/* initialize the registry head */
if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica.segments),
orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size))) {
ORTE_ERROR_LOG(rc);
return NULL;
}
if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica.triggers),
orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size))) {
ORTE_ERROR_LOG(rc);
return NULL;
}
/* initialize the callback list head */
OBJ_CONSTRUCT(&orte_gpr_replica.callbacks, ompi_list_t);
orte_gpr_replica.processing_callbacks = false;
/* initialize the callback list head */
OBJ_CONSTRUCT(&orte_gpr_replica.callbacks, ompi_list_t);
orte_gpr_replica.processing_callbacks = false;
/* initialize the local subscription and trigger trackers */
if (ORTE_SUCCESS != (rc = orte_pointer_array_init(
&(orte_gpr_replica_globals.local_subscriptions),
orte_gpr_replica_globals.block_size,
orte_gpr_replica_globals.max_size,
orte_gpr_replica_globals.block_size))) {
ORTE_ERROR_LOG(rc);
return NULL;
}
orte_gpr_replica_globals.num_local_subs = 0;
orte_gpr_replica_globals.trig_cntr = 0;
/* initialize the search arrays for temporarily storing search results */
if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica_globals.sub_ptrs),
100, orte_gpr_replica_globals.max_size, 100))) {
ORTE_ERROR_LOG(rc);
return NULL;
}
if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica_globals.srch_cptr),
100, orte_gpr_replica_globals.max_size, 100))) {
ORTE_ERROR_LOG(rc);
return NULL;
}
orte_gpr_replica_globals.num_srch_cptr = 0;
if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica_globals.srch_ival),
100, orte_gpr_replica_globals.max_size, 100))) {
ORTE_ERROR_LOG(rc);
return NULL;
}
orte_gpr_replica_globals.num_srch_ival = 0;
if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica_globals.acted_upon),
100, orte_gpr_replica_globals.max_size, 100))) {
ORTE_ERROR_LOG(rc);
return NULL;
}
orte_gpr_replica_globals.num_acted_upon = 0;
if (ORTE_SUCCESS != (rc = orte_bitmap_init(&(orte_gpr_replica_globals.srch_itag), 64))) {
ORTE_ERROR_LOG(rc);
@ -658,7 +298,7 @@ int orte_gpr_replica_finalize(void)
{
size_t i, j;
orte_gpr_replica_segment_t** seg;
orte_gpr_replica_triggers_t** trig;
orte_gpr_replica_trigger_t** trig;
orte_gpr_replica_callbacks_t* cb;
if (orte_gpr_replica_globals.debug) {
@ -666,21 +306,21 @@ int orte_gpr_replica_finalize(void)
}
seg = (orte_gpr_replica_segment_t**)(orte_gpr_replica.segments)->addr;
for (i=0; i < (orte_gpr_replica.segments)->size; i++) {
for (i=0, j=0; j < orte_gpr_replica.num_segs &&
i < (orte_gpr_replica.segments)->size; i++) {
if (NULL != seg[i]) {
j = i;
j++;
OBJ_RELEASE(seg[i]);
orte_pointer_array_set_item(orte_gpr_replica.segments, j, NULL);
}
}
OBJ_RELEASE(orte_gpr_replica.segments);
trig = (orte_gpr_replica_triggers_t**)(orte_gpr_replica.triggers)->addr;
for (i=0; i < (orte_gpr_replica.triggers)->size; i++) {
trig = (orte_gpr_replica_trigger_t**)(orte_gpr_replica.triggers)->addr;
for (i=0, j=0; j < orte_gpr_replica.num_trigs &&
i < (orte_gpr_replica.triggers)->size; i++) {
if (NULL != trig[i]) {
j = i;
j++;
OBJ_RELEASE(trig[i]);
orte_pointer_array_set_item(orte_gpr_replica.triggers, j, NULL);
}
}
OBJ_RELEASE(orte_gpr_replica.triggers);
@ -692,9 +332,6 @@ int orte_gpr_replica_finalize(void)
/* clean up the globals */
if (NULL != orte_gpr_replica_globals.compound_cmd) {
OBJ_RELEASE(orte_gpr_replica_globals.compound_cmd);
}
if (NULL != orte_gpr_replica_globals.srch_cptr) {
OBJ_RELEASE(orte_gpr_replica_globals.srch_cptr);

11
src/mca/ns/base/ns_base_nds.c
Просмотреть файл

@ -37,7 +37,7 @@ static orte_ns_nds_t orte_ns_nds[] = {
int orte_ns_base_set_my_name(void)
{
int rc, id;
int rc, id, flag;
char *mode;
orte_vpid_t vpid;
@ -50,9 +50,14 @@ int orte_ns_base_set_my_name(void)
/* first check if we are seed or singleton that couldn't
* join an existing universe - if so, name is mandated, and we need
* to set the singleton flag so that our job infrastructure gets built */
* to set the singleton flag so that our job infrastructure gets built
*/
if (orte_process_info.seed || NULL == orte_process_info.ns_replica) {
orte_process_info.singleton = true;
id = mca_base_param_register_int("orte", "base", "infrastructure", NULL, (int)false);
mca_base_param_lookup_int(id, &flag);
if (!flag) {
orte_process_info.singleton = true;
}
return orte_ns_base_create_process_name(
&(orte_process_info.my_name), 0, 0, 0);
}

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

@ -88,7 +88,7 @@ static void mca_oob_tcp_accept(void);
struct mca_oob_tcp_subscription_t {
ompi_list_item_t item;
orte_jobid_t jobid;
orte_gpr_notify_id_t subid;
orte_gpr_subscription_id_t subid;
};
typedef struct mca_oob_tcp_subscription_t mca_oob_tcp_subscription_t;
@ -611,7 +611,7 @@ int mca_oob_tcp_resolve(mca_oob_tcp_peer_t* peer)
{
mca_oob_tcp_addr_t* addr;
mca_oob_tcp_subscription_t* subscription;
orte_gpr_value_t trig, *trigs;
orte_gpr_trigger_t trig, *trigs;
orte_gpr_subscription_t sub, *subs;
ompi_list_item_t* item;
int rc;
@ -638,87 +638,110 @@ int mca_oob_tcp_resolve(mca_oob_tcp_peer_t* peer)
}
OBJ_CONSTRUCT(&sub, orte_gpr_subscription_t);
sub.addr_mode = ORTE_GPR_TOKENS_OR | ORTE_GPR_KEYS_OR;
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(sub.segment), peer->peer_name.jobid))) {
/* indicate that this is a standard subscription. This indicates that the
* subscription will be common to all processes. Thus, the resulting data
* can be consolidated into a process-independent message and broadcast
* to all processes
*/
if (ORTE_SUCCESS != (rc = orte_schema.get_std_subscription_name(&(sub.name),
OMPI_OOB_SUBSCRIPTION, peer->peer_name.jobid))) {
ORTE_ERROR_LOG(rc);
return rc;
}
sub.num_tokens= 0;
sub.tokens = NULL;
sub.num_keys = 1;
sub.keys = (char**)malloc(sizeof(char*));
if(NULL == sub.keys) {
/* send data when trigger fires, continue to monitor. The default
* action for any subscription that includes a trigger condition is
* to send the specified data when the trigger fires. This set of flags
* indicates that - AFTER the trigger fires - the subscription should
* continue to send data any time an entry is added or changed.
*/
sub.action = ORTE_GPR_NOTIFY_ADD_ENTRY |
ORTE_GPR_NOTIFY_VALUE_CHG |
ORTE_GPR_NOTIFY_STARTS_AFTER_TRIG;
/* setup the value structures that describe the data to
* be monitored and returned by this subscription
*/
sub.cnt = 1;
sub.values = (orte_gpr_value_t**)malloc(sizeof(orte_gpr_value_t*));
if (NULL == sub.values) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.keys[0] = strdup("oob-tcp");
if (NULL == sub.keys[0]) {
sub.values[0] = OBJ_NEW(orte_gpr_value_t);
if (NULL == sub.values[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.cnt = 1;
/* define the segment */
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(
&(sub.values[0]->segment),
peer->peer_name.jobid))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&sub);
return rc;
}
sub.values[0]->addr_mode = ORTE_GPR_KEYS_OR | ORTE_GPR_TOKENS_OR;
/* look at all containers on this segment */
sub.values[0]->tokens = NULL;
sub.values[0]->num_tokens = 0;
/* look for any keyval with "modex" key */
sub.values[0]->cnt = 1;
sub.values[0]->keyvals = (orte_gpr_keyval_t**)malloc(sizeof(orte_gpr_keyval_t*));
if (NULL == sub.values[0]->keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.values[0]->keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == sub.values[0]->keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.values[0]->keyvals[0]->key = strdup("oob-tcp");
if (NULL == sub.values[0]->keyvals[0]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* define the callback function */
sub.cbfunc = mca_oob_tcp_registry_callback;
sub.user_tag = NULL;
/* setup the trigger value */
OBJ_CONSTRUCT(&trig, orte_gpr_value_t);
trig.addr_mode = ORTE_GPR_TOKENS_XAND | ORTE_GPR_KEYS_OR;
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(trig.segment), peer->peer_name.jobid))) {
OBJ_CONSTRUCT(&trig, orte_gpr_trigger_t);
if (ORTE_SUCCESS != (rc = orte_schema.get_std_trigger_name(&(trig.name),
ORTE_STG1_TRIGGER, peer->peer_name.jobid))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&trig);
return rc;
}
trig.num_tokens = 1;
trig.tokens = (char**)malloc(sizeof(char*));
if (NULL == trig.tokens) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.tokens[0] = strdup(ORTE_JOB_GLOBALS);
if (NULL == trig.tokens[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals = (orte_gpr_keyval_t**)malloc(2*sizeof(orte_gpr_keyval_t*));
if(NULL == trig.keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.cnt = 2;
trig.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if(NULL == trig.keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[0]->key = strdup(ORTE_JOB_SLOTS_KEY);
trig.keyvals[0]->type = ORTE_NULL;
trig.keyvals[1] = OBJ_NEW(orte_gpr_keyval_t);
if(NULL == trig.keyvals[1]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[1]->key = strdup(ORTE_PROC_NUM_AT_STG1);
trig.keyvals[1]->type = ORTE_NULL;
/* this is an ORTE-standard trigger that is defined by the ORTE resource manager
* when the job was launched - therefore, we don't need to provide any additional
* info
*/
trigs = &trig;
subs = &sub;
subscription = OBJ_NEW(mca_oob_tcp_subscription_t);
subscription->jobid = peer->peer_name.jobid;
rc = orte_gpr.subscribe(
ORTE_GPR_NOTIFY_ADD_ENTRY | ORTE_GPR_NOTIFY_VALUE_CHG |
ORTE_GPR_TRIG_CMP_LEVELS | ORTE_GPR_TRIG_ONE_SHOT |
ORTE_GPR_NOTIFY_STARTS_AFTER_TRIG, /* DON'T START NOTIFYING ME ON CHANGES UNTIL AFTER TRIG FIRES */
1, &subs,
1, &trigs,
&subscription->subid);
rc = orte_gpr.subscribe(1, &subs, 1, &trigs);
if(rc != OMPI_SUCCESS) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return rc;
}
/* the id of each subscription is stored by the system in the corresponding
* subscription object we passed into orte_gpr.subscribe. We record it
* here so we can (if desired) cancel that subscription later
*/
subscription->subid = sub.id;
/* done with these, so release any memory */
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig); /* done with these */
OBJ_DESTRUCT(&trig);
ompi_list_append(&mca_oob_tcp_component.tcp_subscriptions, &subscription->item);
OMPI_THREAD_UNLOCK(&mca_oob_tcp_component.tcp_lock);
@ -733,7 +756,8 @@ int mca_oob_tcp_init(void)
{
orte_jobid_t jobid;
orte_buffer_t *buffer;
orte_gpr_value_t trig, *trigs, *value;
orte_gpr_trigger_t trig, *trigs;
orte_gpr_value_t *value;
mca_oob_tcp_subscription_t *subscription;
orte_gpr_subscription_t sub, *subs;
int rc;
@ -779,90 +803,110 @@ int mca_oob_tcp_init(void)
/* setup the subscription description value */
OBJ_CONSTRUCT(&sub, orte_gpr_subscription_t);
sub.addr_mode = ORTE_GPR_TOKENS_OR | ORTE_GPR_KEYS_OR;
if (ORTE_SUCCESS != (rc = orte_ns.get_jobid(&jobid, orte_process_info.my_name))) {
/* indicate that this is a standard subscription. This indicates that the
* subscription will be common to all processes. Thus, the resulting data
* can be consolidated into a process-independent message and broadcast
* to all processes
*/
if (ORTE_SUCCESS != (rc = orte_schema.get_std_subscription_name(&(sub.name),
OMPI_OOB_SUBSCRIPTION, jobid))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(sub.segment), jobid))) {
/* send data when trigger fires, continue to monitor. The default
* action for any subscription that includes a trigger condition is
* to send the specified data when the trigger fires. This set of flags
* indicates that - AFTER the trigger fires - the subscription should
* continue to send data any time an entry is added or changed.
*/
sub.action = ORTE_GPR_NOTIFY_ADD_ENTRY |
ORTE_GPR_NOTIFY_VALUE_CHG |
ORTE_GPR_NOTIFY_STARTS_AFTER_TRIG;
/* setup the value structures that describe the data to
* be monitored and returned by this subscription
*/
sub.cnt = 1;
sub.values = (orte_gpr_value_t**)malloc(sizeof(orte_gpr_value_t*));
if (NULL == sub.values) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.values[0] = OBJ_NEW(orte_gpr_value_t);
if (NULL == sub.values[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* define the segment */
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(
&(sub.values[0]->segment),
jobid))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&sub);
return rc;
}
sub.num_tokens= 0;
sub.tokens = NULL;
sub.num_keys = 1;
sub.keys = (char**)malloc(sizeof(char*));
if(NULL == sub.keys) {
sub.values[0]->addr_mode = ORTE_GPR_KEYS_OR | ORTE_GPR_TOKENS_OR;
/* look at all containers on this segment */
sub.values[0]->tokens = NULL;
sub.values[0]->num_tokens = 0;
/* look for any keyval with "modex" key */
sub.values[0]->cnt = 1;
sub.values[0]->keyvals = (orte_gpr_keyval_t**)malloc(sizeof(orte_gpr_keyval_t*));
if (NULL == sub.values[0]->keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.keys[0] = strdup("oob-tcp");
if (NULL == sub.keys[0]) {
sub.values[0]->keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == sub.values[0]->keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.values[0]->keyvals[0]->key = strdup("oob-tcp");
if (NULL == sub.values[0]->keyvals[0]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* define the callback function */
sub.cbfunc = mca_oob_tcp_registry_callback;
sub.user_tag = NULL;
/* setup the trigger value */
OBJ_CONSTRUCT(&trig, orte_gpr_value_t);
trig.addr_mode = ORTE_GPR_TOKENS_XAND | ORTE_GPR_KEYS_OR;
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(trig.segment), jobid))) {
OBJ_CONSTRUCT(&trig, orte_gpr_trigger_t);
if (ORTE_SUCCESS != (rc = orte_schema.get_std_trigger_name(&(trig.name),
ORTE_STG1_TRIGGER, jobid))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&value);
OBJ_DESTRUCT(&trig);
return rc;
}
trig.num_tokens = 1;
trig.tokens = (char**)malloc(sizeof(char*));
if (NULL == trig.tokens) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.tokens[0] = strdup(ORTE_JOB_GLOBALS);
if (NULL == trig.tokens[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals = (orte_gpr_keyval_t**)malloc(2*sizeof(orte_gpr_keyval_t*));
if(NULL == trig.keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.cnt = 2;
trig.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if(NULL == trig.keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[0]->key = strdup(ORTE_JOB_SLOTS_KEY);
trig.keyvals[0]->type = ORTE_NULL;
trig.keyvals[1] = OBJ_NEW(orte_gpr_keyval_t);
if(NULL == trig.keyvals[1]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[1]->key = strdup(ORTE_PROC_NUM_AT_STG1);
trig.keyvals[1]->type = ORTE_NULL;
/* this is an ORTE-standard trigger that is defined by the ORTE resource manager
* when the job was launched - therefore, we don't need to provide any additional
* info
*/
trigs = &trig;
subs = &sub;
rc = orte_gpr.subscribe(
ORTE_GPR_NOTIFY_ADD_ENTRY | ORTE_GPR_NOTIFY_VALUE_CHG |
ORTE_GPR_TRIG_CMP_LEVELS | ORTE_GPR_TRIG_ONE_SHOT |
ORTE_GPR_NOTIFY_STARTS_AFTER_TRIG,
1, &subs,
1, &trigs,
&subscription->subid);
subscription = OBJ_NEW(mca_oob_tcp_subscription_t);
subscription->jobid = jobid;
rc = orte_gpr.subscribe(1, &subs, 1, &trigs);
if(rc != OMPI_SUCCESS) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return rc;
}
/* the id of each subscription is stored by the system in the corresponding
* subscription object we passed into orte_gpr.subscribe. We record it
* here so we can (if desired) cancel that subscription later
*/
subscription->subid = sub.id;
/* done with these, so release any memory */
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig); /* done with these */
OBJ_DESTRUCT(&trig);
buffer = OBJ_NEW(orte_buffer_t);
if(buffer == NULL) {

7
src/mca/pls/base/base.h
Просмотреть файл

@ -88,7 +88,7 @@ extern "C" {
OMPI_DECLSPEC int orte_pls_base_finalize(void);
OMPI_DECLSPEC int orte_pls_base_close(void);
/**
* Utility routine to get/set proces pid
* Utility routine to get/set procesS pid
*/
OMPI_DECLSPEC int orte_pls_base_set_proc_pid(const orte_process_name_t*, pid_t);
OMPI_DECLSPEC int orte_pls_base_get_proc_pid(const orte_process_name_t*, pid_t*);
@ -102,6 +102,11 @@ extern "C" {
OMPI_DECLSPEC int orte_pls_base_set_node_pid(orte_cellid_t cellid, char* node_name, orte_jobid_t jobid, pid_t pid);
OMPI_DECLSPEC int orte_pls_base_get_node_pids(orte_jobid_t jobid, pid_t** pids, size_t* num_pids);
/**
* Utility routine to set progress engine schedule
*/
OMPI_DECLSPEC int orte_pls_base_set_progress_sched(int sched);
#if defined(c_plusplus) || defined(__cplusplus)
}
#endif

14
src/mca/pls/rsh/pls_rsh_module.c
Просмотреть файл

@ -520,6 +520,20 @@ int orte_pls_rsh_launch(orte_jobid_t jobid)
var = mca_base_param_environ_variable("seed",NULL,NULL);
ompi_setenv(var, "0", true, &env);
/* set the progress engine schedule for this node.
* if node_slots is set to zero, then we default to
* NOT being oversubscribed
*/
if (node->node_slots > 0 &&
node->node_slots_inuse > node->node_slots) {
var = mca_base_param_environ_variable("mpi", NULL, "yield_when_idle");
ompi_setenv(var, "1", true, &env);
} else {
var = mca_base_param_environ_variable("mpi", NULL, "yield_when_idle");
ompi_setenv(var, "0", true, &env);
}
free(var);
/* exec the daemon */
execve(exec_path, exec_argv, env);
ompi_output(0, "orte_pls_rsh: execv failed with errno=%d\n", errno);

35
src/mca/ras/base/ras_base_node.c
Просмотреть файл

@ -75,8 +75,10 @@ int orte_ras_base_node_query(ompi_list_t* nodes)
NULL,
&cnt,
&values);
if(ORTE_SUCCESS != rc)
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* parse the response */
for(i=0; i<cnt; i++) {
@ -140,8 +142,10 @@ int orte_ras_base_node_query_alloc(ompi_list_t* nodes, orte_jobid_t jobid)
char* jobid_str;
int rc;
if(ORTE_SUCCESS != (rc = orte_ns.convert_jobid_to_string(&jobid_str, jobid)))
if(ORTE_SUCCESS != (rc = orte_ns.convert_jobid_to_string(&jobid_str, jobid))) {
ORTE_ERROR_LOG(rc);
return rc;
}
asprintf(&keys[4], "%s-%s", ORTE_NODE_SLOTS_ALLOC_KEY, jobid_str);
free(jobid_str);
@ -153,8 +157,10 @@ int orte_ras_base_node_query_alloc(ompi_list_t* nodes, orte_jobid_t jobid)
keys,
&cnt,
&values);
if(ORTE_SUCCESS != rc)
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* parse the response */
for(i=0; i<cnt; i++) {
@ -307,6 +313,7 @@ int orte_ras_base_node_insert(ompi_list_t* nodes)
/* setup index/keys for this node */
rc = orte_schema.get_node_tokens(&value->tokens, &value->num_tokens, node->node_cellid, node->node_name);
if (ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
for (j=0; j <= i; j++) {
OBJ_RELEASE(values[j]);
}
@ -316,7 +323,9 @@ int orte_ras_base_node_insert(ompi_list_t* nodes)
}
/* try the insert */
rc = orte_gpr.put(num_values, values);
if (ORTE_SUCCESS != (rc = orte_gpr.put(num_values, values))) {
ORTE_ERROR_LOG(rc);
}
for (j=0; j < num_values; j++) {
OBJ_RELEASE(values[j]);
@ -340,8 +349,10 @@ int orte_ras_base_node_delete(ompi_list_t* nodes)
char* cellid;
char* tokens[3];
if(ORTE_SUCCESS != (rc = orte_ns.convert_cellid_to_string(&cellid, node->node_cellid)))
if(ORTE_SUCCESS != (rc = orte_ns.convert_cellid_to_string(&cellid, node->node_cellid))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* setup index/keys for this node */
tokens[0] = node->node_name;
@ -353,8 +364,10 @@ int orte_ras_base_node_delete(ompi_list_t* nodes)
ORTE_NODE_SEGMENT,
tokens,
NULL);
if(ORTE_SUCCESS != rc)
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
return ORTE_SUCCESS;
}
@ -374,6 +387,7 @@ int orte_ras_base_node_assign(ompi_list_t* nodes, orte_jobid_t jobid)
num_values = ompi_list_get_size(nodes);
if (0 >= num_values) {
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
return ORTE_ERR_BAD_PARAM;
}
@ -426,12 +440,15 @@ int orte_ras_base_node_assign(ompi_list_t* nodes, orte_jobid_t jobid)
if(node->node_slots_alloc == 0)
continue;
if(ORTE_SUCCESS != (rc = orte_ns.convert_jobid_to_string(&jobid_str, jobid)))
if(ORTE_SUCCESS != (rc = orte_ns.convert_jobid_to_string(&jobid_str, jobid))) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* setup index/keys for this node */
rc = orte_schema.get_node_tokens(&values[i]->tokens, &values[i]->num_tokens, node->node_cellid, node->node_name);
if (ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
for (j=0; j < num_values; j++) {
OBJ_RELEASE(values[j]);
}
@ -448,7 +465,9 @@ int orte_ras_base_node_assign(ompi_list_t* nodes, orte_jobid_t jobid)
}
/* try the insert */
rc = orte_gpr.put(num_values, values);
if (ORTE_SUCCESS != (rc = orte_gpr.put(num_values, values))) {
ORTE_ERROR_LOG(rc);
}
for (j=0; j < num_values; j++) {
OBJ_RELEASE(values[j]);

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

@ -39,9 +39,9 @@
int orte_rmgr_base_proc_stage_gate_init(orte_jobid_t job)
{
size_t i, num_counters=6;
orte_gpr_notify_id_t subnum;
int rc;
orte_gpr_value_t *values, value, trig, *trigs;
orte_gpr_value_t *values, value, trigvalue, *trigvals;
orte_gpr_trigger_t trig, *trigs;
orte_gpr_subscription_t sub, *subs;
char* keys[] = {
/* changes to this ordering need to be reflected in code below */
@ -52,6 +52,12 @@ int orte_rmgr_base_proc_stage_gate_init(orte_jobid_t job)
ORTE_PROC_NUM_ABORTED,
ORTE_PROC_NUM_TERMINATED
};
char* trig_names[] = {
/* changes to this ordering need to be reflected in code below */
ORTE_STG1_TRIGGER,
ORTE_STG2_TRIGGER,
ORTE_STG3_TRIGGER
};
/* setup the counters */
OBJ_CONSTRUCT(&value, orte_gpr_value_t);
@ -97,193 +103,286 @@ int orte_rmgr_base_proc_stage_gate_init(orte_jobid_t job)
}
OBJ_DESTRUCT(&value);
/* for the trigger, we want the counter values returned to us AND
/* for the stage gate triggers, we want the counter values returned to us AND
* information on VPID_START so we can generate the list of peers
* to receive the xcast messages for barrier release.
* setup subscriptions for that purpose. we'll enter the precise data
*/
/*** SUBSCRIPTIONS ***/
/* the subscription object is used to define the values we want
* returned to us. we'll enter the precise data
* keys when we are ready to register the subscription - for now,
* do all the basic stuff
*/
OBJ_CONSTRUCT(&sub, orte_gpr_subscription_t);
sub.addr_mode = ORTE_GPR_TOKENS_XAND | ORTE_GPR_KEYS_OR;
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(sub.segment), job))) {
/* we do not name the subscription - see explanation below. also, we do
* not assign the subscription id here - it is assigned for us when the
* registry "registers" the subscription and is returned in the
* subscription object at that time
*/
/*
* set the action to delete the subscription after the trigger fires. this
* subscription is solely for the purpose of returning stagegate information
* to the resource manager - we don't need it after that happens
*/
sub.action = ORTE_GPR_NOTIFY_DELETE_AFTER_TRIG;
/*
* setup the value object to define the data to be returned to us
*/
OBJ_CONSTRUCT(&value, orte_gpr_value_t);
values = &value;
sub.values = &values;
sub.cnt = 1;
/* set the address mode to identify a specific container (in this case,
* the ORTE_JOB_GLOBALS container) and any keys within it
*/
value.addr_mode = ORTE_GPR_TOKENS_XAND | ORTE_GPR_KEYS_OR;
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(value.segment), job))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return rc;
}
sub.tokens = (char**)malloc(sizeof(char*));
if (NULL == sub.tokens) {
/* define the tokens for the container */
value.tokens = (char**)malloc(sizeof(char*));
if (NULL == value.tokens) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.tokens[0] = strdup(ORTE_JOB_GLOBALS); /* the counters are in the job's globals container */
sub.num_tokens = 1;
sub.num_keys = 3;
sub.keys = (char**)malloc(sizeof(char*) * sub.num_keys);
if (NULL == sub.keys) {
value.tokens[0] = strdup(ORTE_JOB_GLOBALS); /* the counters are in the job's globals container */
value.num_tokens = 1;
/* define the keys to be returned */
value.cnt = 3;
value.keyvals = (orte_gpr_keyval_t**)malloc(value.cnt * sizeof(orte_gpr_keyval_t*));
if (NULL == value.keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.keys[1] = strdup(ORTE_JOB_SLOTS_KEY);
sub.keys[2] = strdup(ORTE_JOB_VPID_START_KEY);
for (i=0; i < value.cnt; i++) {
value.keyvals[i] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == value.keyvals[i]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
}
/* the 0th entry will be defined below */
value.keyvals[1]->key = strdup(ORTE_JOB_SLOTS_KEY);
value.keyvals[2]->key = strdup(ORTE_JOB_VPID_START_KEY);
/* we don't need to define the type and value for the keyvals - the subscribe
* function ignores those fields
*/
sub.cbfunc = orte_rmgr_base_proc_stage_gate_mgr;
sub.user_tag = NULL;
/*** TRIGGERS ***/
/* setup the trigger information - initialize the common elements */
OBJ_CONSTRUCT(&trig, orte_gpr_value_t);
trig.addr_mode = ORTE_GPR_TOKENS_XAND;
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(trig.segment), job))) {
OBJ_CONSTRUCT(&trig, orte_gpr_trigger_t);
/* we WILL name the trig - see explanation below. we do
* NOT assign the trigger id here - it is assigned for us when the
* registry "registers" the trigger and is returned in the
* trigger object at that time
*/
/*
* set the action to compare all specified counter levels. this will
* "fire" the trigger when all counters are equal
*/
trig.action = ORTE_GPR_TRIG_ALL_CMP;
/*
* setup the value object to define the data to be returned to us
*/
OBJ_CONSTRUCT(&trigvalue, orte_gpr_value_t);
trigvals = &trigvalue;
trig.values = &trigvals;
trig.cnt = 1;
/* set the address mode to identify a specific container (in this case,
* the ORTE_JOB_GLOBALS container) and any keys within it
*/
trigvalue.addr_mode = ORTE_GPR_TOKENS_XAND | ORTE_GPR_KEYS_OR;
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(trigvalue.segment), job))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&trig);
return rc;
goto CLEANUP;
}
trig.tokens = (char**)malloc(sizeof(char*));
if (NULL == trig.tokens) {
/* define the tokens for the container */
trigvalue.tokens = (char**)malloc(sizeof(char*));
if (NULL == trigvalue.tokens) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
trig.tokens[0] = strdup(ORTE_JOB_GLOBALS);
trig.num_tokens = 1;
trig.cnt = 2;
trig.keyvals = (orte_gpr_keyval_t**)malloc(2*sizeof(orte_gpr_keyval_t*));
if (NULL == trig.keyvals) {
trigvalue.tokens[0] = strdup(ORTE_JOB_GLOBALS); /* the counters are in the job's globals container */
trigvalue.num_tokens = 1;
/* define the keys that identify the counters */
trigvalue.cnt = 2;
trigvalue.keyvals = (orte_gpr_keyval_t**)malloc(trigvalue.cnt * sizeof(orte_gpr_keyval_t*));
if (NULL == trigvalue.keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
trig.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trig.keyvals[0]) {
trigvalue.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trigvalue.keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
trig.keyvals[1] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trig.keyvals[1]) {
trigvalue.keyvals[1] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trigvalue.keyvals[1]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
/* Now do the individual triggers.
* First, setup the triggers for the three main stage gates - these all compare
/* setup the triggers for the three main stage gates - these all compare
* their value to that in ORTE_JOB_SLOTS_KEY
*/
trig.keyvals[0]->key = strdup(ORTE_JOB_SLOTS_KEY);
if (NULL == trig.keyvals[0]->key) {
trigvalue.keyvals[0]->key = strdup(ORTE_JOB_SLOTS_KEY);
if (NULL == trigvalue.keyvals[0]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
trig.keyvals[0]->type = ORTE_NULL;
trig.keyvals[1]->type = ORTE_NULL;
/* we don't need to define the type and value for the keyvals - the subscribe
* function ignores those fields
*/
/* do the three stage gate subscriptions.
*/
for (i=0; i < 3; i++) {
sub.keys[0] = strdup(keys[i]);
if (NULL == sub.keys[0]) {
/*
* NOTE: we do NOT name the subscriptions here as these are not
* standard subscriptions that multiple processes should attach
* themselves to - the subscriptions only have meaning to the
* resource manager
*/
value.keyvals[0]->key = strdup(keys[i]);
if (NULL == value.keyvals[0]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
trig.keyvals[1]->key = strdup(keys[i]);
if (NULL == trig.keyvals[1]->key) {
/*
* NOTE: we DO name the triggers as these will be standard triggers
* that multiple processes will want to attach themselves to - for
* example, a process may well want to receive some information when
* it reaches STAGE_GATE_1, and so will "attach" itself to that
* trigger as defined by us here
*/
if (ORTE_SUCCESS != (rc = orte_schema.get_std_trigger_name(&(trig.name),
trig_names[i], job))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
trigvalue.keyvals[1]->key = strdup(keys[i]);
if (NULL == trigvalue.keyvals[1]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
subs = &sub;
trigs = &trig;
rc = orte_gpr.subscribe(
ORTE_GPR_TRIG_ALL_CMP,
1, &subs,
1, &trigs,
&subnum);
1, &trigs);
if(ORTE_SUCCESS != rc) {
if (ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return rc;
goto CLEANUP;
}
free(sub.keys[0]);
sub.keys[0] = NULL;
free(trig.keyvals[1]->key);
trig.keyvals[1]->key = NULL;
free(value.keyvals[0]->key);
value.keyvals[0]->key = NULL;
free(trig.name);
free(trigvalue.keyvals[1]->key);
trigvalue.keyvals[1]->key = NULL;
}
/* Next, setup the trigger that watches the NUM_ABORTED counter to see if
* any process abnormally terminates - if so, then call the stage_gate_mgr_abort
* any process abnormally terminates - if so, then call the
* stage_gate_mgr_abort function
* so it can in turn order the job to be aborted
*/
sub.cbfunc = orte_rmgr_base_proc_stage_gate_mgr_abort;
sub.keys[0] = strdup(ORTE_PROC_NUM_ABORTED);
if (NULL == sub.keys[0]) {
value.keyvals[0]->key = strdup(ORTE_PROC_NUM_ABORTED);
if (NULL == value.keyvals[0]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
OBJ_RELEASE(trig.keyvals[0]);
OBJ_RELEASE(trig.keyvals[1]);
free(trig.keyvals);
trig.cnt = 1;
trig.keyvals = (orte_gpr_keyval_t**)malloc(sizeof(orte_gpr_keyval_t**));
if (NULL == trig.keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
/* set the trigger name */
if (ORTE_SUCCESS != (rc = orte_schema.get_std_trigger_name(&(trig.name),
ORTE_NUM_ABORTED_TRIGGER, job))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
trig.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trig.keyvals[0]) {
/* set the trigger action to fire at a specified level */
trig.action = ORTE_GPR_TRIG_ALL_AT;
/* cleanup the trigger keyvals that are no longer needed - we will
* rebuild them as required
*/
OBJ_RELEASE(trigvalue.keyvals[0]);
OBJ_RELEASE(trigvalue.keyvals[1]);
free(trigvalue.keyvals);
/* we only need one trigger keyval here as we are not comparing
* trigger levels - we are just asking to be notified when
* a specific counter changes value to "1"
*/
trigvalue.cnt = 1;
trigvalue.keyvals = (orte_gpr_keyval_t**)malloc(sizeof(orte_gpr_keyval_t**));
if (NULL == trigvalue.keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
trig.keyvals[0]->key = strdup(ORTE_PROC_NUM_ABORTED);
if (NULL == trig.keyvals[0]->key) {
trigvalue.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trigvalue.keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
trig.keyvals[0]->type = ORTE_SIZE;
trig.keyvals[0]->value.size = 1; /* trigger on the first process that aborts */
trigvalue.keyvals[0]->key = strdup(ORTE_PROC_NUM_ABORTED);
if (NULL == trigvalue.keyvals[0]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
/* trigger on the first process that aborts */
trigvalue.keyvals[0]->type = ORTE_SIZE;
trigvalue.keyvals[0]->value.size = 1;
subs = &sub;
trigs = &trig;
rc = orte_gpr.subscribe(
ORTE_GPR_TRIG_ALL_AT,
1, &subs,
1, &trigs,
&subnum);
1, &trigs);
if (ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return rc;
}
if (ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
}
OBJ_DESTRUCT(&sub);
CLEANUP:
OBJ_DESTRUCT(&trigvalue);
trig.values = NULL;
OBJ_DESTRUCT(&trig);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return ORTE_SUCCESS;
return rc;
}
@ -300,8 +399,15 @@ void orte_rmgr_base_proc_stage_gate_mgr(orte_gpr_notify_data_t *data,
orte_buffer_t msg;
orte_jobid_t job;
/* get the jobid from the segment name */
if (ORTE_SUCCESS != (rc = orte_schema.extract_jobid_from_segment_name(&job, data->segment))) {
/* get the jobid from the segment name
* we setup the stage gate triggers to return at least one value
* to us. we use that value to extract the jobid for the returned
* data
*/
values = data->values;
if (ORTE_SUCCESS != (rc =
orte_schema.extract_jobid_from_segment_name(&job,
values[0]->segment))) {
ORTE_ERROR_LOG(rc);
return;
}
@ -375,11 +481,19 @@ void orte_rmgr_base_proc_stage_gate_mgr(orte_gpr_notify_data_t *data,
void orte_rmgr_base_proc_stage_gate_mgr_abort(orte_gpr_notify_data_t *data,
void *user_tag)
{
orte_gpr_value_t **values;
orte_jobid_t job;
int rc;
/* get the jobid from the segment name */
if (ORTE_SUCCESS != (rc = orte_schema.extract_jobid_from_segment_name(&job, data->segment))) {
/* get the jobid from the segment name
* we setup the stage gate triggers to return at least one value
* to us. we use that value to extract the jobid for the returned
* data
*/
values = data->values;
if (ORTE_SUCCESS != (rc =
orte_schema.extract_jobid_from_segment_name(&job,
values[0]->segment))) {
ORTE_ERROR_LOG(rc);
return;
}
@ -394,9 +508,10 @@ void orte_rmgr_base_proc_stage_gate_mgr_abort(orte_gpr_notify_data_t *data,
int orte_rmgr_base_proc_stage_gate_subscribe(orte_jobid_t job, orte_gpr_notify_cb_fn_t cbfunc, void* cbdata)
{
size_t i, sub_num;
size_t i;
int rc;
orte_gpr_value_t trig, *trigs;
orte_gpr_value_t value, *values;
orte_gpr_trigger_t trig, *trigs;
orte_gpr_subscription_t sub, *subs;
char* keys[] = {
/* changes to this ordering need to be reflected in code below */
@ -406,175 +521,168 @@ int orte_rmgr_base_proc_stage_gate_subscribe(orte_jobid_t job, orte_gpr_notify_c
ORTE_PROC_NUM_FINALIZED,
ORTE_PROC_NUM_TERMINATED
};
char* trig_names[] = {
/* changes to this ordering need to be reflected in code below
* number of entries MUST match those above
*/
ORTE_STG1_TRIGGER,
ORTE_STG2_TRIGGER,
ORTE_STG3_TRIGGER,
ORTE_NUM_FINALIZED_TRIGGER,
ORTE_NUM_TERMINATED_TRIGGER
};
size_t num_counters = sizeof(keys)/sizeof(keys[0]);
/* for the trigger, we want the counter values returned to us
* setup subscriptions for that purpose. we'll enter the precise data
/*** SUBSCRIPTIONS ***/
/* the subscription object is used to define the values we want
* returned to us. we'll enter the precise data
* keys when we are ready to register the subscription - for now,
* do all the basic stuff
*/
OBJ_CONSTRUCT(&sub, orte_gpr_subscription_t);
sub.addr_mode = ORTE_GPR_TOKENS_XAND | ORTE_GPR_KEYS_OR;
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(sub.segment), job))) {
/* we do not name the subscription - see explanation below. also, we do
* not assign the subscription id here - it is assigned for us when the
* registry "registers" the subscription and is returned in the
* subscription object at that time
*/
/*
* set the action to delete the subscription after the trigger fires. this
* subscription is solely for the purpose of returning stagegate information
* to the resource manager - we don't need it after that happens
*/
sub.action = ORTE_GPR_NOTIFY_DELETE_AFTER_TRIG;
/*
* setup the value object to define the data to be returned to us
*/
OBJ_CONSTRUCT(&value, orte_gpr_value_t);
values = &value;
sub.values = &values;
sub.cnt = 1;
/* set the address mode to identify a specific container (in this case,
* the ORTE_JOB_GLOBALS container) and any keys within it
*/
value.addr_mode = ORTE_GPR_TOKENS_XAND | ORTE_GPR_KEYS_OR;
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(value.segment), job))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return rc;
}
sub.tokens = (char**)malloc(sizeof(char*));
if (NULL == sub.tokens) {
/* define the tokens for the container */
value.tokens = (char**)malloc(sizeof(char*));
if (NULL == value.tokens) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.tokens[0] = strdup(ORTE_JOB_GLOBALS); /* the counters are in the job's globals container */
sub.num_tokens = 1;
sub.keys = (char**)malloc(sizeof(char*)*1);
if (NULL == sub.keys) {
value.tokens[0] = strdup(ORTE_JOB_GLOBALS); /* the counters are in the job's globals container */
value.num_tokens = 1;
/* the keys describing the data to be returned will be defined later
* for now, we simply allocate the space
*/
value.keyvals = (orte_gpr_keyval_t**)malloc(sizeof(orte_gpr_keyval_t*));
if (NULL == value.keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
sub.num_keys = 1;
value.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == value.keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return ORTE_ERR_OUT_OF_RESOURCE;
}
value.cnt = 1;
/* define the callback and associated data tag */
sub.cbfunc = cbfunc;
sub.user_tag = cbdata;
/*** TRIGGERS ***/
/* setup the trigger information - initialize the common elements */
OBJ_CONSTRUCT(&trig, orte_gpr_value_t);
trig.addr_mode = ORTE_GPR_TOKENS_XAND;
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(trig.segment), job))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&trig);
return rc;
}
trig.tokens = (char**)malloc(sizeof(char*));
if (NULL == trig.tokens) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.tokens[0] = strdup(ORTE_JOB_GLOBALS);
trig.num_tokens = 1;
trig.cnt = 2;
trig.keyvals = (orte_gpr_keyval_t**)malloc(2*sizeof(orte_gpr_keyval_t*));
if (NULL == trig.keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trig.keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[1] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trig.keyvals[1]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* Now do the individual triggers.
* First, setup the triggers for the three main stage gates - these all compare
* their value to that in ORTE_JOB_SLOTS_KEY
OBJ_CONSTRUCT(&trig, orte_gpr_trigger_t);
/* since the named triggers have already been defined, we don't need
* to replicate that here! all we need to do is refer to the
* proper trigger name - we'll do that below
*/
trig.keyvals[0]->key = strdup(ORTE_JOB_SLOTS_KEY);
if (NULL == trig.keyvals[0]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[0]->type = ORTE_NULL;
trig.keyvals[1]->type = ORTE_NULL;
/* do the counter subscriptions. */
trig.action = ORTE_GPR_TRIG_ALL_CMP;
/* do the trigger subscriptions */
for (i=0; i < num_counters; i++) {
sub.keys[0] = strdup(keys[i]);
if (NULL == sub.keys[0]) {
/* insert the subscription key identifying the data to
* be returned from this trigger
*/
value.keyvals[0]->key = strdup(keys[i]);
if (NULL == value.keyvals[0]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
trig.keyvals[1]->key = strdup(keys[i]);
if (NULL == trig.keyvals[1]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
/* get the standard trigger name to which we are "attaching" */
if (ORTE_SUCCESS != (rc = orte_schema.get_std_trigger_name(&(trig.name),
trig_names[i], job))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
subs = &sub;
trigs = &trig;
rc = orte_gpr.subscribe(
ORTE_GPR_TRIG_ALL_CMP,
1, &subs,
1, &trigs,
&sub_num);
1, &trigs);
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return rc;
goto CLEANUP;
}
free(sub.keys[0]);
sub.keys[0] = NULL;
free(trig.keyvals[1]->key);
trig.keyvals[1]->key = NULL;
free(value.keyvals[0]->key);
value.keyvals[0]->key = NULL;
free(trig.name);
trig.name = NULL;
}
/* Now do the abort trigger */
sub.keys[0] = strdup(ORTE_PROC_NUM_ABORTED);
if (NULL == sub.keys[0]) {
/* Now do the abort trigger.
* setup the subscription to return the number aborted\
*/
value.keyvals[0]->key = strdup(ORTE_PROC_NUM_ABORTED);
if (NULL == value.keyvals[0]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
rc = ORTE_ERR_OUT_OF_RESOURCE;
goto CLEANUP;
}
OBJ_RELEASE(trig.keyvals[0]);
OBJ_RELEASE(trig.keyvals[1]);
free(trig.keyvals);
trig.cnt = 1;
trig.keyvals = (orte_gpr_keyval_t**)malloc(sizeof(orte_gpr_keyval_t**));
if (NULL == trig.keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
/* set the trigger action */
trig.action = ORTE_GPR_TRIG_ALL_AT;
/* get the standard "abort" trigger name */
if (ORTE_SUCCESS != (rc = orte_schema.get_std_trigger_name(&(trig.name),
ORTE_NUM_ABORTED_TRIGGER, job))) {
ORTE_ERROR_LOG(rc);
goto CLEANUP;
}
trig.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trig.keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[0]->key = strdup(ORTE_PROC_NUM_ABORTED);
if (NULL == trig.keyvals[0]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[0]->type = ORTE_SIZE;
trig.keyvals[0]->value.size = 1; /* trigger on the first process that aborts */
subs = &sub;
trigs = &trig;
rc = orte_gpr.subscribe(
ORTE_GPR_TRIG_ALL_AT,
1, &subs,
1, &trigs,
&sub_num);
1, &trigs);
if (ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
}
OBJ_DESTRUCT(&sub);
CLEANUP:
OBJ_DESTRUCT(&trig);
return ORTE_SUCCESS;
OBJ_DESTRUCT(&value);
sub.values = NULL;
OBJ_DESTRUCT(&sub);
return rc;
}

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

@ -235,16 +235,21 @@ static int orte_rmgr_proxy_terminate_proc(const orte_process_name_t* proc_name)
static void orte_rmgr_proxy_callback(orte_gpr_notify_data_t *data, void *cbdata)
{
orte_rmgr_cb_fn_t cbfunc = (orte_rmgr_cb_fn_t)cbdata;
orte_gpr_value_t **values;
orte_gpr_keyval_t** keyvals;
orte_jobid_t jobid;
size_t i, j;
int rc;
/* get the jobid from the segment name */
if (ORTE_SUCCESS != (rc = orte_schema.extract_jobid_from_segment_name(&jobid, data->segment))) {
/* 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 = data->values;
if (ORTE_SUCCESS != (rc =
orte_schema.extract_jobid_from_segment_name(&jobid,
values[0]->segment))) {
ORTE_ERROR_LOG(rc);
ompi_output(0, "[%lu,%lu,%lu] orte_rmgr_proxy_callback: %s\n",
ORTE_NAME_ARGS(orte_process_info.my_name), data->segment);
return;
}

11
src/mca/rmgr/urm/rmgr_urm.c
Просмотреть файл

@ -182,13 +182,20 @@ static void orte_rmgr_urm_wireup_stdin(orte_jobid_t jobid)
static void orte_rmgr_urm_callback(orte_gpr_notify_data_t *data, void *cbdata)
{
orte_rmgr_cb_fn_t cbfunc = (orte_rmgr_cb_fn_t)cbdata;
orte_gpr_value_t **values;
orte_gpr_keyval_t** keyvals;
orte_jobid_t jobid;
size_t i, j;
int rc;
/* get the jobid from the segment name */
if (ORTE_SUCCESS != (rc = orte_schema.extract_jobid_from_segment_name(&jobid, data->segment))) {
/* 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 = data->values;
if (ORTE_SUCCESS != (rc =
orte_schema.extract_jobid_from_segment_name(&jobid,
values[0]->segment))) {
ORTE_ERROR_LOG(rc);
return;
}

6
src/mca/schema/base/base.h
Просмотреть файл

@ -60,6 +60,12 @@ int orte_schema_base_get_cell_tokens(char ***tokens, size_t* num_tokens, orte_ce
int orte_schema_base_get_job_segment_name(char **name, orte_jobid_t jobid);
int orte_schema_base_extract_jobid_from_segment_name(orte_jobid_t *jobid, char *name);
int orte_schema_base_store_my_info(void);
int orte_schema_base_get_std_trigger_name(char **name,
char *trigger,
orte_jobid_t jobid);
int orte_schema_base_get_std_subscription_name(char **name,
char *subscription,
orte_jobid_t jobid);
#if defined(c_plusplus) || defined(__cplusplus)

43
src/mca/schema/base/schema_base_fns.c
Просмотреть файл

@ -246,3 +246,46 @@ int orte_schema_base_store_my_info(void)
return rc;
}
int orte_schema_base_get_std_trigger_name(char **name,
char *trigger,
orte_jobid_t jobid)
{
char *jobidstring;
int rc;
if (ORTE_SUCCESS != (rc = orte_ns.convert_jobid_to_string(&jobidstring, jobid))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (0 > asprintf(name, "%s-%s", trigger, jobidstring)) {
free(jobidstring);
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
free(jobidstring);
return ORTE_SUCCESS;
}
int orte_schema_base_get_std_subscription_name(char **name,
char *subscription,
orte_jobid_t jobid)
{
char *jobidstring;
int rc;
if (ORTE_SUCCESS != (rc = orte_ns.convert_jobid_to_string(&jobidstring, jobid))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if (0 > asprintf(name, "%s-%s", subscription, jobidstring)) {
free(jobidstring);
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
return ORTE_ERR_OUT_OF_RESOURCE;
}
free(jobidstring);
return ORTE_SUCCESS;
}

4
src/mca/schema/base/schema_base_open.c
Просмотреть файл

@ -42,7 +42,9 @@ OMPI_DECLSPEC orte_schema_base_module_t orte_schema = {
orte_schema_base_get_cell_tokens,
orte_schema_base_get_job_segment_name,
orte_schema_base_extract_jobid_from_segment_name,
orte_schema_base_store_my_info
orte_schema_base_store_my_info,
orte_schema_base_get_std_trigger_name,
orte_schema_base_get_std_subscription_name
};

11
src/mca/schema/schema.h
Просмотреть файл

@ -53,6 +53,15 @@ typedef int (*orte_schema_extract_jobid_from_segment_name_fn_t)(orte_jobid_t *jo
typedef int (*orte_schema_store_my_info_fn_t)(void);
typedef int (*orte_schema_get_std_trigger_name_fn_t)(char **name,
char *trigger,
orte_jobid_t jobid);
typedef int (*orte_schema_get_std_subscription_name_fn_t)(char **name,
char *subscription,
orte_jobid_t jobid);
/*
* Ver 1.0.0
*/
@ -63,6 +72,8 @@ struct orte_schema_base_module_1_0_0_t {
orte_schema_get_job_segment_name_fn_t get_job_segment_name;
orte_schema_extract_jobid_from_segment_name_fn_t extract_jobid_from_segment_name;
orte_schema_store_my_info_fn_t store_my_info;
orte_schema_get_std_trigger_name_fn_t get_std_trigger_name;
orte_schema_get_std_subscription_name_fn_t get_std_subscription_name;
};

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

@ -82,5 +82,14 @@ extern char *orte_error_strings[];
#define ORTE_PROC_NUM_FINALIZED "orte-proc-num-finalized"
#define ORTE_PROC_NUM_TERMINATED "orte-proc-num-terminated"
/*
* ORTE-wide names for specific system triggers and subscriptions
*/
#define ORTE_STG1_TRIGGER "orte-stage1"
#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"
#endif

172
src/runtime/ompi_progress.c
Просмотреть файл

@ -24,10 +24,6 @@
#include "mca/pml/pml.h"
#include "runtime/ompi_progress.h"
#include "include/constants.h"
#include "mca/errmgr/errmgr.h"
#include "mca/ns/ns.h"
#include "mca/gpr/gpr.h"
#include "mca/schema/schema.h"
/*
* default parameters
@ -59,154 +55,6 @@ static long event_progress_counter_reset = 0;
static int32_t event_num_mpi_users = 0;
static void
node_schedule_callback(orte_gpr_notify_data_t *notify_data, void *user_tag)
{
size_t proc_slots = 0;
size_t used_proc_slots = 0;
int param;
size_t i;
/* parse the response */
for(i = 0 ; i < notify_data->cnt ; i++) {
orte_gpr_value_t* value = notify_data->values[i];
size_t k;
for(k = 0 ; k < value->cnt ; k++) {
orte_gpr_keyval_t* keyval = value->keyvals[k];
if(strcmp(keyval->key, ORTE_NODE_SLOTS_KEY) == 0) {
proc_slots = keyval->value.size;
continue;
}
if(strncmp(keyval->key, ORTE_NODE_SLOTS_ALLOC_KEY,
strlen(ORTE_NODE_SLOTS_ALLOC_KEY)) == 0) {
used_proc_slots += keyval->value.size;
continue;
}
}
}
param = mca_base_param_find("mpi", NULL, "yield_when_idle");
mca_base_param_set_int(param, (used_proc_slots <= proc_slots) ? 0 : 1);
}
static int
register_node_schedule_callback(void)
{
orte_gpr_notify_id_t rctag;
orte_gpr_value_t trig, *trigs;
orte_gpr_subscription_t sub, *subs;
orte_jobid_t jobid;
int rc;
char **tokens;
size_t num_tokens;
char *my_name_string;
orte_cellid_t cellid;
/* query our node... */
rc = orte_ns.get_proc_name_string(&my_name_string,
orte_process_info.my_name);
if (ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
rc = orte_ns.get_cellid(&cellid, orte_process_info.my_name);
if (ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
rc = orte_ns.get_jobid(&jobid, orte_process_info.my_name);
if (ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
rc = orte_schema.get_node_tokens(&tokens, &num_tokens,
cellid,
my_name_string);
if (ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
/* setup the subscription definition */
OBJ_CONSTRUCT(&sub, orte_gpr_subscription_t);
sub.addr_mode = ORTE_GPR_KEYS_OR | ORTE_GPR_TOKENS_OR;
sub.segment = strdup(ORTE_NODE_SEGMENT);
sub.tokens = tokens;
sub.num_tokens = num_tokens;
sub.num_keys = 0;
sub.keys = NULL;
sub.cbfunc = node_schedule_callback;
sub.user_tag = NULL;
/* setup the trigger definition */
OBJ_CONSTRUCT(&trig, orte_gpr_value_t);
trig.addr_mode = ORTE_GPR_TOKENS_XAND;
if (ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&(trig.segment), jobid))) {
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return rc;
}
trig.tokens = (char**)malloc(sizeof(char*));
if (NULL == trig.tokens) {
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.tokens[0] = strdup(ORTE_JOB_GLOBALS);
trig.num_tokens = 1;
trig.cnt = 2;
trig.keyvals = (orte_gpr_keyval_t**)malloc(2*sizeof(orte_gpr_keyval_t*));
if (NULL == trig.keyvals) {
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trig.keyvals[0]) {
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[0]->key = strdup(ORTE_JOB_SLOTS_KEY);
trig.keyvals[0]->type = ORTE_NULL;
trig.keyvals[1] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == trig.keyvals[1]) {
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return ORTE_ERR_OUT_OF_RESOURCE;
}
trig.keyvals[1]->key = strdup(ORTE_PROC_NUM_AT_STG1);
trig.keyvals[1]->type = ORTE_NULL;
/* register the subscription */
subs = &sub;
trigs = &trig;
rc = orte_gpr.subscribe(
ORTE_GPR_TRIG_ALL_CMP,
1, &subs,
1, &trigs,
&rctag);
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return OMPI_ERROR;
}
OBJ_DESTRUCT(&sub);
OBJ_DESTRUCT(&trig);
return OMPI_SUCCESS;
}
/* init the progress engine - called from orte_init */
int
ompi_progress_init(void)
@ -225,25 +73,9 @@ ompi_progress_init(void)
}
/* do all the registration stuff during the compound command */
int
ompi_progress_mpi_init(void)
{
int param, value, rc;
/* call sched yield when oversubscribed. */
param = mca_base_param_find("mpi", NULL, "yield_when_idle");
mca_base_param_lookup_int(param, &value);
if (value < 0) {
/* no default given. Register a callback so that we have a
value when we get to mpi_enable() */
rc = register_node_schedule_callback();
if (OMPI_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
}
event_num_mpi_users = 0;
return OMPI_SUCCESS;
@ -260,9 +92,7 @@ ompi_progress_mpi_enable(void)
mca_base_param_lookup_int(param, &value);
if (value < 0) {
/* this should never happen (as mpi_enable should be called
after the compound command is executed). set to 1 if this
happens */
/* this should never happen set to 1 if it somehow does */
call_yield = 1;
} else {
call_yield = value;

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

@ -63,6 +63,8 @@ int orte_init_stage1(void)
pid_t pid;
orte_universe_t univ;
orte_jobid_t my_jobid;
orte_cellid_t my_cellid;
orte_gpr_value_t value, *values;
/* Ensure the system_info structure is instantiated and initialized */
if (ORTE_SUCCESS != (ret = orte_sys_info())) {
@ -356,25 +358,87 @@ int orte_init_stage1(void)
return ret;
}
/* if we are a singleton, setup the infrastructure for our job */
/* if we are a singleton or the seed, setup the infrastructure for our job */
if(orte_process_info.singleton) {
if (ORTE_SUCCESS != (ret = orte_ns.get_jobid(&my_jobid, orte_process_info.my_name))) {
ORTE_ERROR_LOG(ret);
return ret;
}
if (ORTE_SUCCESS != (ret = orte_rmgr_base_set_job_slots(my_jobid,1))) {
ORTE_ERROR_LOG(ret);
return ret;
}
if (ORTE_SUCCESS != (ret = orte_rmaps_base_set_vpid_range(my_jobid,0,1))) {
ORTE_ERROR_LOG(ret);
return ret;
}
if (ORTE_SUCCESS != (ret = orte_rmgr_base_proc_stage_gate_init(my_jobid))) {
ORTE_ERROR_LOG(ret);
return ret;
}
if(orte_process_info.singleton || orte_process_info.seed) {
if (ORTE_SUCCESS != (ret = orte_ns.get_jobid(&my_jobid, orte_process_info.my_name))) {
ORTE_ERROR_LOG(ret);
return ret;
}
if (ORTE_SUCCESS != (ret = orte_ns.get_cellid(&my_cellid, orte_process_info.my_name))) {
ORTE_ERROR_LOG(ret);
return ret;
}
if (orte_process_info.singleton) {
/* setup a fake node structure - this is required to support
* the MPI attributes function that is sitting on a trigger
* waiting for info on available node slots. since we can't
* really know that info for a singleton, we make the assumption
* that the allocation is unity and place a structure on the
* registry for it
*
* THIS ONLY SHOULD BE DONE FOR SINGLETONS - DO NOT DO IT
* FOR ANY OTHER CASE
*/
OBJ_CONSTRUCT(&value, orte_gpr_value_t);
values = &value;
/* define the addressing mode and segment */
value.addr_mode = ORTE_GPR_TOKENS_OR | ORTE_GPR_KEYS_OR;
value.segment = strdup(ORTE_NODE_SEGMENT);
if (NULL == value.segment) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
return ORTE_ERR_OUT_OF_RESOURCE;
}
if (ORTE_SUCCESS != (rc = orte_schema.get_node_tokens(&(value.tokens),
&(value.num_tokens), my_cellid, orte_system_info.nodename))) {
ORTE_ERROR_LOG(rc);
return rc;
}
value.cnt = 1;
value.keyvals = (orte_gpr_keyval_t**)malloc(sizeof(orte_gpr_keyval_t*));
if (NULL == value.keyvals) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
return ORTE_ERR_OUT_OF_RESOURCE;
}
value.keyvals[0] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == value.keyvals[0]) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
return ORTE_ERR_OUT_OF_RESOURCE;
}
value.keyvals[0]->key = strdup(ORTE_NODE_SLOTS_KEY);
if (NULL == value.keyvals[0]->key) {
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
OBJ_DESTRUCT(&value);
return ORTE_ERR_OUT_OF_RESOURCE;
}
value.keyvals[0]->type = ORTE_UINT32;
value.keyvals[0]->value.ui32 = 1;
/* put the value on the registry */
if (ORTE_SUCCESS != (ret = orte_gpr.put(1, &values))) {
ORTE_ERROR_LOG(ret);
OBJ_DESTRUCT(&value);
return ret;
}
/* cleanup the mess */
OBJ_DESTRUCT(&value);
}
/* set the rest of the infrastructure */
if (ORTE_SUCCESS != (ret = orte_rmgr_base_set_job_slots(my_jobid,1))) {
ORTE_ERROR_LOG(ret);
return ret;
}
if (ORTE_SUCCESS != (ret = orte_rmaps_base_set_vpid_range(my_jobid,0,1))) {
ORTE_ERROR_LOG(ret);
return ret;
}
if (ORTE_SUCCESS != (ret = orte_rmgr_base_proc_stage_gate_init(my_jobid))) {
ORTE_ERROR_LOG(ret);
return ret;
}
}
return ORTE_SUCCESS;

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

@ -277,7 +277,15 @@ int main(int argc, char *argv[])
}
/* Intialize our Open RTE environment */
/* first, set the flag telling orte_init that I am NOT a
* singleton, but am "infrastructure" - prevents setting
* up incorrect infrastructure that only a singleton would
* require
*/
id = mca_base_param_register_int("orte", "base", "infrastructure", NULL, 0);
mca_base_param_set_int(id, 1);
/* now call orte_init and setup the RTE */
if (ORTE_SUCCESS != (rc = orte_init())) {
ompi_show_help("help-orterun.txt", "orterun:init-failure", true,
"orte_init()", rc);

107
test/dps/dps_test.c
Просмотреть файл

@ -1466,33 +1466,47 @@ static bool test13(void)
{
orte_buffer_t *bufA;
int rc;
size_t i, j, k;
size_t i, j, k, m;
orte_gpr_subscription_t *src[NUM_ELEMS];
orte_gpr_subscription_t *dst[NUM_ELEMS];
for(i=0; i<NUM_ELEMS; i++) {
src[i] = OBJ_NEW(orte_gpr_subscription_t);
src[i]->addr_mode = (uint16_t) i;
src[i]->segment = strdup("test-segment-name");
if (i % 2) {
src[i]->name = strdup("dummy-name");
}
src[i]->id = (orte_gpr_subscription_id_t)i;
/* test value counts of 1 to NUM_ELEMS+1 */
src[i]->cnt = i + 1;
src[i]->values = (orte_gpr_value_t**)malloc(src[i]->cnt * sizeof(orte_gpr_value_t*));
for (k=0; k < src[i]->cnt; k++) {
src[i]->values[k] = OBJ_NEW(orte_gpr_value_t);
src[i]->values[k]->addr_mode = (uint16_t) i;
src[i]->values[k]->segment = strdup("test-segment");
/* test token counts of 0! to NUM_ELEMS */
src[i]->values[k]->num_tokens = i;
if (src[i]->values[k]->num_tokens) { /* if to allow testing of token count of zero */
src[i]->values[k]->tokens = (char**)malloc(src[i]->values[k]->num_tokens * sizeof(char*));
for (j=0; j < src[i]->values[k]->num_tokens; j++) {
src[i]->values[k]->tokens[j] = strdup("test-token");
}
}
/* test token counts of 0! to NUM_ELEMS */
src[i]->num_tokens = i;
if (src[i]->num_tokens) { /* if to allow testing of token count of zero */
src[i]->tokens = (char**)malloc(src[i]->num_tokens * sizeof(char*));
for (j=0; j < src[i]->num_tokens; j++) {
src[i]->tokens[j] = strdup("test-token");
}
}
/* test key counts of 0 to NUM_ELEMS */
src[i]->num_keys = i;
if (src[i]->num_keys) { /* if to allow testing of num_keys count of zero */
src[i]->keys = (char**)malloc(src[i]->num_keys * sizeof(char*));
for (j=0; j < src[i]->num_keys; j++) {
src[i]->keys[j] = strdup("test-key");
}
}
/* test key counts of 0 to NUM_ELEMS */
src[i]->values[k]->cnt = i;
if (src[i]->values[k]->cnt) { /* if to allow testing of num_keys count of zero */
src[i]->values[k]->keyvals = (orte_gpr_keyval_t**)malloc(
src[i]->values[k]->cnt * sizeof(orte_gpr_keyval_t*));
for (j=0; j < src[i]->values[k]->cnt; j++) {
src[i]->values[k]->keyvals[j] = OBJ_NEW(orte_gpr_keyval_t);
src[i]->values[k]->keyvals[j]->key = strdup("test-key");
}
}
/* skip the pointers for cb_func and user_tag */
}
}
/* source data set, now create buffer and pack source data */
@ -1528,29 +1542,48 @@ static bool test13(void)
for(j=0; j<NUM_ELEMS; j++) {
if (
src[j]->addr_mode != dst[j]->addr_mode ||
0 != strcmp(src[j]->segment, dst[j]->segment) ||
src[j]->num_tokens != dst[j]->num_tokens ||
src[j]->num_keys != dst[j]->num_keys
if ((NULL == src[j]->name && NULL != dst[j]->name) ||
(NULL != src[j]->name && NULL == dst[j]->name)
) {
test_comment ("test13: invalid results from unpack");
return(false);
}
if ((NULL != src[j]->name &&
0 != strcmp(src[j]->name, dst[j]->name)) ||
src[j]->id != dst[j]->id ||
src[j]->cnt != dst[j]->cnt
) {
test_comment ("test13: invalid results from unpack");
return(false);
}
/* now compare each of the size/cnt depedant values */
for (k=0; k<src[j]->num_tokens; k++) {
if (0 != strcmp(src[j]->tokens[k], dst[j]->tokens[k])) {
test_comment ("test13: invalid results (tokens) from unpack");
/* now compare each of the size/cnt dependent values */
for (k=0; k<src[j]->cnt; k++) {
if (src[j]->values[k]->num_tokens != dst[j]->values[k]->num_tokens) {
test_comment ("test13: invalid results (value num_tokens) from unpack");
return(false);
}
}
for (m=0; m < src[j]->values[k]->num_tokens; m++) {
if (0 != strcmp(src[j]->values[k]->tokens[m], dst[j]->values[k]->tokens[m])) {
test_comment ("test13: invalid results (tokens) from unpack");
return(false);
}
}
for (k=0; k< src[j]->num_keys; k++) {
if (0 != strcmp(src[j]->keys[k], dst[j]->keys[k])) {
test_comment ("test13: invalid results (keys) from unpack");
if (src[j]->values[k]->cnt != dst[j]->values[k]->cnt) {
test_comment ("test13: invalid results (value cnt) from unpack");
return(false);
}
for (m=0; m < src[j]->values[k]->cnt; m++) {
if (0 != strcmp(src[j]->values[k]->keyvals[m]->key,
dst[j]->values[k]->keyvals[m]->key)) {
test_comment ("test13: invalid results (keys) from unpack");
return(false);
}
}
}
}
}
@ -1576,9 +1609,7 @@ static bool test14(void)
for(i=0; i<NUM_ELEMS; i++) {
src[i] = OBJ_NEW(orte_gpr_notify_data_t);
src[i]->cb_num = i;
src[i]->addr_mode = (orte_gpr_addr_mode_t) i;
src[i]->segment = strdup("test-segment-name");
src[i]->id = i;
/* test value counts of 0 to NUM_ELEMS-1 */
src[i]->cnt = i; /* value count */
@ -1651,9 +1682,7 @@ static bool test14(void)
for(j=0; j<NUM_ELEMS; j++) {
if (
src[j]->cb_num != dst[j]->cb_num ||
src[j]->addr_mode != dst[j]->addr_mode ||
0 != strcmp(src[j]->segment, dst[j]->segment) ||
src[j]->id != dst[j]->id ||
src[j]->cnt != dst[j]->cnt
) {
test_comment ("test14: invalid results from unpack");

2
test/mca/Makefile.am
Просмотреть файл

@ -16,4 +16,4 @@
include $(top_srcdir)/config/Makefile.options
SUBDIRS = gpr ns oob ras rds rmaps schema
SUBDIRS = ns oob ras rds rmaps schema

3
test/mca/gpr/Makefile.am
Просмотреть файл

@ -28,8 +28,7 @@ check_PROGRAMS = \
gpr_threads \
gpr_triggers
TESTS = \
$(check_PROGRAMS)
TESTS =
gpr_internal_fns_SOURCES = gpr_internal_fns.c
gpr_internal_fns_LDADD = \

166
test/mca/gpr/gpr_internal_fns.c
Просмотреть файл

@ -35,7 +35,6 @@
#include "mca/rmgr/base/base.h"
#include "support.h"
#include "components.h"
#include "class/orte_pointer_array.h"
#include "dps/dps.h"
@ -57,17 +56,11 @@ static FILE *test_out=NULL;
static char *cmd_str="diff ./test_gpr_replica_out ./test_gpr_replica_out_std";
/*
* Local functions
*/
static void find(const char *name, test_component_handle_t *handle,
test_component_fn_t *ptr);
int main(int argc, char **argv)
{
int rc;
size_t num_names, num_found;
size_t num_names;
size_t i;
char *tmp=NULL, *tmp2=NULL, *names[15], *keys[5];
orte_gpr_replica_segment_t *seg=NULL;
@ -75,25 +68,7 @@ int main(int argc, char **argv)
orte_gpr_replica_container_t *cptr=NULL;
orte_gpr_keyval_t *kptr=NULL;
orte_gpr_replica_itagval_t **ivals=NULL, *iptr;
bool allow, have;
int priority;
test_component_handle_t handle;
mca_gpr_base_component_t *gpr_component = NULL;
orte_gpr_base_module_t *gpr_module = NULL;
orte_gpr_replica_find_seg_fn_t find_seg_fn;
orte_gpr_replica_create_itag_fn_t create_itag_fn;
orte_gpr_replica_dict_lookup_fn_t dict_lookup_fn;
orte_gpr_replica_dict_reverse_lookup_fn_t dict_reverse_lookup_fn;
orte_gpr_replica_delete_itag_fn_t delete_itag_fn;
orte_gpr_replica_get_itag_list_fn_t get_itag_list_fn;
orte_gpr_replica_create_container_fn_t create_container_fn;
orte_gpr_replica_add_keyval_fn_t add_keyval_fn;
orte_gpr_replica_search_container_fn_t search_container_fn;
orte_gpr_replica_update_keyval_fn_t update_keyval_fn;
orte_gpr_replica_check_itag_list_fn_t check_itag_list_fn;
orte_gpr_replica_release_segment_fn_t release_segment_fn;
test_init("test_gpr_replica");
/* test_out = fopen( "test_gpr_replica_out", "w+" ); */
@ -190,59 +165,27 @@ int main(int argc, char **argv)
exit (1);
}
/* Open the gpr replica component and initialize a module */
if (OMPI_SUCCESS !=
test_component_open("gpr", "replica", &handle,
(mca_base_component_t**) &gpr_component) ||
NULL == gpr_component) {
fprintf(test_out, "Could not open replica\n");
exit(1);
}
gpr_module = gpr_component->gpr_init(&allow, &have, &priority);
if (NULL == gpr_module) {
fprintf(test_out, "replica component did not return a module\n");
exit(1);
}
if (ORTE_SUCCESS == orte_dps_open()) {
fprintf(test_out, "DPS started\n");
/* startup the registry */
if (OMPI_SUCCESS == orte_gpr_base_open()) {
fprintf(test_out, "GPR started\n");
} else {
fprintf(test_out, "DPS could not start\n");
fprintf(test_out, "GPR could not start\n");
exit (1);
}
/* Find a bunch of function pointers */
/* do a select on the registry components */
if (OMPI_SUCCESS == orte_gpr_base_select()) {
fprintf(test_out, "GPR selected\n");
} else {
fprintf(test_out, "GPR could not select\n");
exit (1);
}
fprintf(stderr, "finding relevant function pointers in component\n");
find("orte_gpr_replica_find_seg", &handle,
(test_component_fn_t*) &find_seg_fn);
find("orte_gpr_replica_create_itag", &handle,
(test_component_fn_t*) &create_itag_fn);
find("orte_gpr_replica_dict_lookup", &handle,
(test_component_fn_t*) &dict_lookup_fn);
find("orte_gpr_replica_dict_reverse_lookup", &handle,
(test_component_fn_t*) &dict_reverse_lookup_fn);
find("orte_gpr_replica_delete_itag", &handle,
(test_component_fn_t*) &delete_itag_fn);
find("orte_gpr_replica_get_itag_list", &handle,
(test_component_fn_t*) &get_itag_list_fn);
find("orte_gpr_replica_check_itag_list", &handle,
(test_component_fn_t*) &check_itag_list_fn);
find("orte_gpr_replica_create_container", &handle,
(test_component_fn_t*) &create_container_fn);
find("orte_gpr_replica_add_keyval", &handle,
(test_component_fn_t*) &add_keyval_fn);
find("orte_gpr_replica_search_container", &handle,
(test_component_fn_t*) &search_container_fn);
find("orte_gpr_replica_update_keyval", &handle,
(test_component_fn_t*) &update_keyval_fn);
find("orte_gpr_replica_release_segment", &handle,
(test_component_fn_t*) &release_segment_fn);
/* Now do the tests */
fprintf(stderr, "going to find seg\n");
if (ORTE_SUCCESS != (rc = find_seg_fn(&seg, true, "test-segment"))) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_find_seg(&seg, true, "test-segment"))) {
fprintf(test_out, "gpr_test: find_seg failed with error code %s\n",
ORTE_ERROR_NAME(rc));
test_failure("gpr_test: find_seg failed");
@ -253,12 +196,12 @@ int main(int argc, char **argv)
fprintf(test_out, "gpr_test: find_seg passed\n");
}
gpr_module->dump_all(0);
orte_gpr.dump_all(0);
fprintf(stderr, "creating tags\n");
for (i=0; i<10; i++) {
asprintf(&tmp, "test-tag-%lu", (unsigned long) i);
if (ORTE_SUCCESS != (rc = create_itag_fn(&itag[i], seg, tmp))) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_create_itag(&itag[i], seg, tmp))) {
fprintf(test_out, "gpr_test: create_itag failed with error code %s\n",
ORTE_ERROR_NAME(rc));
test_failure("gpr_test: create_itag failed");
@ -274,7 +217,7 @@ int main(int argc, char **argv)
fprintf(stderr, "lookup tags\n");
for (i=0; i<10; i++) {
asprintf(&tmp, "test-tag-%lu", (unsigned long) i);
if (ORTE_SUCCESS != (rc = dict_lookup_fn(&itag2, seg, tmp)) ||
if (ORTE_SUCCESS != (rc = orte_gpr_replica_dict_lookup(&itag2, seg, tmp)) ||
itag2 != itag[i]) {
fprintf(test_out, "gpr_test: lookup failed with error code %s\n",
ORTE_ERROR_NAME(rc));
@ -291,7 +234,7 @@ int main(int argc, char **argv)
fprintf(stderr, "reverse lookup tags\n");
for (i=0; i<10; i++) {
asprintf(&tmp2, "test-tag-%lu", (unsigned long) i);
if (ORTE_SUCCESS != (rc = dict_reverse_lookup_fn(&tmp, seg, itag[i])) ||
if (ORTE_SUCCESS != (rc = orte_gpr_replica_dict_reverse_lookup(&tmp, seg, itag[i])) ||
0 != strcmp(tmp2, tmp)) {
fprintf(test_out, "gpr_test: reverse lookup failed with error code %s\n",
ORTE_ERROR_NAME(rc));
@ -309,7 +252,7 @@ int main(int argc, char **argv)
fprintf(stderr, "delete tags\n");
for (i=0; i<10; i++) {
asprintf(&tmp, "test-tag-%lu", (unsigned long) i);
if (ORTE_SUCCESS != (rc = delete_itag_fn(seg, tmp))) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_delete_itag(seg, tmp))) {
fprintf(test_out, "gpr_test: delete tag failed with error code %s\n",
ORTE_ERROR_NAME(rc));
test_failure("gpr_test: delete tag failed");
@ -327,7 +270,7 @@ int main(int argc, char **argv)
}
names[14] = NULL;
num_names = 0;
if (ORTE_SUCCESS != (rc = get_itag_list_fn(&itaglist, seg,
if (ORTE_SUCCESS != (rc = orte_gpr_replica_get_itag_list(&itaglist, seg,
names, &num_names))) {
fprintf(test_out, "gpr_test: get itag list failed with error code %s\n",
ORTE_ERROR_NAME(rc));
@ -346,7 +289,7 @@ int main(int argc, char **argv)
}
fprintf(stderr, "creating container\n");
if (ORTE_SUCCESS != (rc = create_container_fn(&cptr, seg,
if (ORTE_SUCCESS != (rc = orte_gpr_replica_create_container(&cptr, seg,
3, itaglist))) {
fprintf(test_out, "gpr_test: create_container failed with error code %s\n",
ORTE_ERROR_NAME(rc));
@ -357,7 +300,7 @@ int main(int argc, char **argv)
fprintf(test_out, "gpr_test: create_container passed\n");
}
gpr_module->dump_all(0);
orte_gpr.dump_all(0);
fprintf(test_out, "itags for container\n");
for (i=0; i < cptr->num_itags; i++) {
@ -370,7 +313,7 @@ int main(int argc, char **argv)
kptr->key = strdup("stupid-value");
kptr->type = ORTE_INT16;
kptr->value.i16 = 21;
if (ORTE_SUCCESS != (rc = add_keyval_fn(&iptr, seg, cptr, kptr))) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_add_keyval(&iptr, seg, cptr, kptr))) {
fprintf(test_out, "gpr_test: add keyval failed with error code %s\n",
ORTE_ERROR_NAME(rc));
test_failure("gpr_test: add keyval failed");
@ -392,10 +335,10 @@ int main(int argc, char **argv)
kptr->key = strdup("stupid-value");
kptr->type = ORTE_STRING;
kptr->value.strptr = strdup("try-string-value");
create_itag_fn(&itag2, seg, kptr->key);
if (ORTE_SUCCESS != (rc = search_container_fn(&num_found, ORTE_GPR_REPLICA_OR,
orte_gpr_replica_create_itag(&itag2, seg, kptr->key);
if (ORTE_SUCCESS != (rc = orte_gpr_replica_search_container(ORTE_GPR_REPLICA_OR,
&itag2, 1, cptr) ||
0 >= num_found)) {
0 >= orte_gpr_replica_globals.num_srch_ival)) {
fprintf(test_out, "gpr_test: search container for single entry failed - returned %s for itag %lu\n",
ORTE_ERROR_NAME(rc), (unsigned long) itag2);
test_failure("gpr_test: search container for single entry failed");
@ -411,7 +354,7 @@ int main(int argc, char **argv)
kptr->key = strdup("stupid-value");
kptr->type = ORTE_STRING;
kptr->value.strptr = strdup("try-string-value");
if (ORTE_SUCCESS != (rc = update_keyval_fn(seg, cptr, kptr))) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_update_keyval(seg, cptr, kptr))) {
fprintf(test_out, "gpr_test: update single keyval failed with error code %s\n",
ORTE_ERROR_NAME(rc));
test_failure("gpr_test: update single keyval failed");
@ -443,7 +386,7 @@ int main(int argc, char **argv)
kptr->key = strdup("stupid-value");
kptr->type = ORTE_INT16;
kptr->value.i16 = i * 100;
if (ORTE_SUCCESS != (rc = add_keyval_fn(&iptr, seg, cptr, kptr))) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_add_keyval(&iptr, seg, cptr, kptr))) {
fprintf(test_out, "gpr_test: add keyval failed with error code %s\n",
ORTE_ERROR_NAME(rc));
test_failure("gpr_test: add keyval failed");
@ -455,26 +398,20 @@ int main(int argc, char **argv)
OBJ_RELEASE(kptr);
}
fprintf(stderr, "update multiple keyvals in a container\n");
if(ORTE_SUCCESS != find_seg_fn(&seg, false, "test-segment")) {
fprintf(test_out, "Failure in orte_gpr_replica_find_seg\n");
return -1;
}
gpr_module->dump_all(0);
orte_gpr.dump_all(0);
kptr = OBJ_NEW(orte_gpr_keyval_t);
kptr->key = strdup("stupid-value");
kptr->type = ORTE_INT32;
kptr->value.i32 = 123456;
if (ORTE_SUCCESS != (rc = create_itag_fn(&itag2, seg, kptr->key))) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_create_itag(&itag2, seg, kptr->key))) {
fprintf(test_out, "gpr_internal_fns: update multiple keyvals - failed to get itag with error %s\n",
ORTE_ERROR_NAME(rc));
test_failure("gpr_test: update multiple keyvals failed");
test_finalize();
return rc;
}
if (ORTE_SUCCESS != (rc = search_container_fn(&num_found, ORTE_GPR_REPLICA_OR,
if (ORTE_SUCCESS != (rc = orte_gpr_replica_search_container(ORTE_GPR_REPLICA_OR,
&itag2, 1, cptr))) {
fprintf(test_out, "gpr_internal_fns: update multiple keyvals - failed to find itag with error %s\n",
ORTE_ERROR_NAME(rc));
@ -482,7 +419,7 @@ int main(int argc, char **argv)
test_finalize();
return rc;
}
if (ORTE_SUCCESS != (rc = update_keyval_fn(seg, cptr, kptr))) {
if (ORTE_SUCCESS != (rc = orte_gpr_replica_update_keyval(seg, cptr, kptr))) {
fprintf(test_out, "gpr_test: update multiple keyvals failed with error code %s\n",
ORTE_ERROR_NAME(rc));
test_failure("gpr_test: update multiple keyvals failed");
@ -493,47 +430,50 @@ int main(int argc, char **argv)
}
OBJ_RELEASE(kptr);
gpr_module->dump_all(0);
orte_gpr.dump_all(0);
fprintf(stderr, "check itag list\n");
if (check_itag_list_fn(ORTE_GPR_REPLICA_XAND, 0, NULL, 15, itaglist)) {
if (orte_gpr_replica_check_itag_list(ORTE_GPR_REPLICA_XAND, 0, NULL, 15, itaglist)) {
fprintf(test_out, "check_itag_list: trivial NULL case passed\n");
} else {
fprintf(test_out, "check_itag_list: trivial NULL case failed\n");
}
if (!check_itag_list_fn(ORTE_GPR_REPLICA_XAND, 5, itaglist, 15, itaglist)) {
if (!orte_gpr_replica_check_itag_list(ORTE_GPR_REPLICA_XAND, 5, itaglist, 15, itaglist)) {
fprintf(test_out, "check_itag_list: trivial mismatched xand case passed\n");
} else {
fprintf(test_out, "check_itag_list: trivial mismatched xand case failed\n");
}
if (!check_itag_list_fn(ORTE_GPR_REPLICA_AND, 15, itaglist, 5, itaglist)) {
if (!orte_gpr_replica_check_itag_list(ORTE_GPR_REPLICA_AND, 15, itaglist, 5, itaglist)) {
fprintf(test_out, "check_itag_list: trivial mismatched and case passed\n");
} else {
fprintf(test_out, "check_itag_list: trivial mismatched and case failed\n");
}
if (check_itag_list_fn(ORTE_GPR_REPLICA_XAND, 10, itaglist, 10, itaglist)) {
if (orte_gpr_replica_check_itag_list(ORTE_GPR_REPLICA_XAND, 10, itaglist, 10, itaglist)) {
fprintf(test_out, "check_itag_list: non-trivial xand case passed\n");
} else {
fprintf(test_out, "check_itag_list: non-trivial xand case failed\n");
}
if (check_itag_list_fn(ORTE_GPR_REPLICA_AND, 5, itaglist, 10, itaglist)) {
if (orte_gpr_replica_check_itag_list(ORTE_GPR_REPLICA_AND, 5, itaglist, 10, itaglist)) {
fprintf(test_out, "check_itag_list: non-trivial and case passed\n");
} else {
fprintf(test_out, "check_itag_list: non-trivial and case failed\n");
}
if (check_itag_list_fn(ORTE_GPR_REPLICA_OR, 5, itaglist, 10, itaglist)) {
if (orte_gpr_replica_check_itag_list(ORTE_GPR_REPLICA_OR, 5, itaglist, 10, itaglist)) {
fprintf(test_out, "check_itag_list: non-trivial or case passed\n");
} else {
fprintf(test_out, "check_itag_list: non-trivial or case failed\n");
}
if (check_itag_list_fn(ORTE_GPR_REPLICA_XOR, 10, itaglist, 5, itaglist)) {
if (orte_gpr_replica_check_itag_list(ORTE_GPR_REPLICA_XOR, 10, itaglist, 5, itaglist)) {
fprintf(test_out, "check_itag_list: non-trivial or case passed\n");
} else {
fprintf(test_out, "check_itag_list: non-trivial or case failed\n");
}
fprintf(stderr, "\ncheck events prior to releasing segment to clear action records\n");
orte_gpr_replica_check_events();
fprintf(stderr, "\nreleasing segment\n");
if (ORTE_SUCCESS != (rc = release_segment_fn(&seg)) ||
if (ORTE_SUCCESS != (rc = orte_gpr_replica_release_segment(&seg)) ||
NULL != seg) {
fprintf(test_out, "gpr_test: release segment failed with error code %s\n",
ORTE_ERROR_NAME(rc));
@ -554,10 +494,8 @@ int main(int argc, char **argv)
free(itaglist);
/* finalize the gpr component */
if (NULL != gpr_component->gpr_finalize) {
gpr_component->gpr_finalize();
}
test_component_close(&handle);
orte_gpr_base_close();
orte_dps_close();
orte_sys_info_finalize();
@ -581,17 +519,3 @@ int main(int argc, char **argv)
return 0;
}
static void find(const char *name, test_component_handle_t *handle,
test_component_fn_t *ptr)
{
test_component_sym_t sym;
if (OMPI_SUCCESS !=
test_component_find_symbol(name, handle, &sym)) {
fprintf(test_out, "Unable to find symbol: %s\n", name);
exit(1);
}
fprintf(test_out, "Found symbol: %s\n", name);
*ptr = sym.tcs_function;
}

41
test/mca/gpr/gpr_mem_leaks.c
Просмотреть файл

@ -35,7 +35,6 @@
#include "mca/rmgr/base/base.h"
#include "support.h"
#include "components.h"
#include "class/orte_pointer_array.h"
#include "dps/dps.h"
@ -59,12 +58,7 @@ int main(int argc, char **argv)
size_t i, cnt;
char *names[15], *keys[5];
orte_gpr_value_t **values, *val;
test_component_handle_t handle;
mca_gpr_base_component_t *gpr_component = NULL;
orte_gpr_base_module_t *gpr_module = NULL;
bool allow, have;
int priority;
test_init("test_gpr_replica");
/* test_out = fopen( "test_gpr_replica_out", "w+" ); */
@ -156,24 +150,19 @@ int main(int argc, char **argv)
exit (1);
}
/* Open the gpr replica component and initialize a module */
if (OMPI_SUCCESS !=
test_component_open("gpr", "replica", &handle,
(mca_base_component_t**) &gpr_component) ||
NULL == gpr_component) {
fprintf(test_out, "Could not open replica\n");
exit(1);
}
gpr_module = gpr_component->gpr_init(&allow, &have, &priority);
if (NULL == gpr_module) {
fprintf(test_out, "replica component did not return a module\n");
exit(1);
/* startup the registry */
if (OMPI_SUCCESS == orte_gpr_base_open()) {
fprintf(test_out, "GPR started\n");
} else {
fprintf(test_out, "GPR could not start\n");
exit (1);
}
if (ORTE_SUCCESS == orte_dps_open()) {
fprintf(test_out, "DPS started\n");
/* do a select on the registry components */
if (OMPI_SUCCESS == orte_gpr_base_select()) {
fprintf(test_out, "GPR selected\n");
} else {
fprintf(test_out, "DPS could not start\n");
fprintf(test_out, "GPR could not select\n");
exit (1);
}
@ -195,7 +184,7 @@ int main(int argc, char **argv)
(val->keyvals[i])->type = ORTE_UINT32;
(val->keyvals[i])->value.ui32 = (uint32_t)i;
}
if (ORTE_SUCCESS != (rc = gpr_module->put(1, &val))) {
if (ORTE_SUCCESS != (rc = orte_gpr.put(1, &val))) {
fprintf(test_out, "gpr_test: put 1 value/multiple keyval failed with error code %s\n",
ORTE_ERROR_NAME(rc));
test_failure("gpr_test: put 1 value/multiple keyval failed");
@ -214,7 +203,7 @@ int main(int argc, char **argv)
keys[2] = strdup("stupid-test-5");
keys[3] = strdup("stupid-test-8");
keys[4] = NULL;
if (ORTE_SUCCESS != (rc = gpr_module->get(ORTE_GPR_KEYS_OR | ORTE_GPR_TOKENS_OR,
if (ORTE_SUCCESS != (rc = orte_gpr.get(ORTE_GPR_KEYS_OR | ORTE_GPR_TOKENS_OR,
"test-put-segment",
names, keys,
&cnt, &values))) {
@ -252,7 +241,7 @@ int main(int argc, char **argv)
(val->keyvals[0])->value.strptr = strdup("try-string-value");
for (i = 0; i < 10; i++) {
fprintf(stderr, "\tputting copy %lu\n", (unsigned long) i);
if (ORTE_SUCCESS != (rc = gpr_module->put(1, &val))) {
if (ORTE_SUCCESS != (rc = orte_gpr.put(1, &val))) {
fprintf(test_out, "gpr_test: put multiple copies of one keyval in a container failed with error code %s\n",
ORTE_ERROR_NAME(rc));
test_failure("gpr_test: put multiple copies of one keyval in a container failed");
@ -265,7 +254,7 @@ int main(int argc, char **argv)
fprintf(stderr, "generate a trigger event\n");
fprintf(stderr, "now finalize and see if all memory cleared\n");
test_component_close(&handle);
orte_gpr_base_close();
orte_dps_close();
orte_sys_info_finalize();
orte_proc_info_finalize();

64
test/mca/gpr/gpr_triggers.c
Просмотреть файл

@ -177,27 +177,23 @@ int main(int argc, char **argv)
exit (1);
}
/* Open the gpr replica component and initialize a module */
if (OMPI_SUCCESS !=
test_component_open("gpr", "replica", &handle,
(mca_base_component_t**) &gpr_component) ||
NULL == gpr_component) {
fprintf(test_out, "Could not open replica\n");
exit(1);
}
gpr_module = gpr_component->gpr_init(&allow, &have, &priority);
if (NULL == gpr_module) {
fprintf(test_out, "replica component did not return a module\n");
exit(1);
}
if (ORTE_SUCCESS == orte_dps_open()) {
fprintf(test_out, "DPS started\n");
/* startup the registry */
if (OMPI_SUCCESS == orte_gpr_base_open()) {
fprintf(test_out, "GPR started\n");
} else {
fprintf(test_out, "DPS could not start\n");
fprintf(test_out, "GPR could not start\n");
exit (1);
}
/* do a select on the registry components */
if (OMPI_SUCCESS == orte_gpr_base_select()) {
fprintf(test_out, "GPR selected\n");
} else {
fprintf(test_out, "GPR could not select\n");
exit (1);
}
if (ORTE_SUCCESS == orte_errmgr_base_open()) {
fprintf(test_out, "error mgr started\n");
} else {
@ -205,22 +201,22 @@ int main(int argc, char **argv)
exit (1);
}
// /* test triggers that compare two counters to each other */
// if (ORTE_SUCCESS == test1()) {
// fprintf(test_out, "triggers: compare two counters successful\n");
// } else {
// fprintf(test_out, "triggers: compare two counters failed\n");
// rc = 1;
// }
//
// /* test triggers that fire at a level */
// if (ORTE_SUCCESS == test2()) {
// fprintf(test_out, "triggers: trigger at level successful\n");
// } else {
// fprintf(test_out, "triggers: trigger at level failed\n");
// rc = 1;
// }
//
/* test triggers that compare two counters to each other */
if (ORTE_SUCCESS == test1()) {
fprintf(test_out, "triggers: compare two counters successful\n");
} else {
fprintf(test_out, "triggers: compare two counters failed\n");
rc = 1;
}
/* test triggers that fire at a level */
if (ORTE_SUCCESS == test2()) {
fprintf(test_out, "triggers: trigger at level successful\n");
} else {
fprintf(test_out, "triggers: trigger at level failed\n");
rc = 1;
}
/* test notification on value added */
if (ORTE_SUCCESS == test3()) {
fprintf(test_out, "triggers: notify upon value added successful\n");