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

Added the local support functions for the replica. Everything compiles fine on my machine - next step is to test these functions.

Просмотр исходного кода 
This commit was SVN r2154.
Этот коммит содержится в:
Ralph Castain 2004-08-15 22:37:01 +00:00
родитель 6bdf9c0cbc
Коммит b433fc3ad9
5 изменённых файлов: 197 добавлений и 192 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

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

@ -8,4 +8,6 @@ noinst_LTLIBRARIES = libmca_gpr_replica.la
libmca_gpr_replica_la_SOURCES = \ libmca_gpr_replica_la_SOURCES = \
gpr_replica.h \ gpr_replica.h \
gpr_replica.c \ gpr_replica.c \
gpr_replica_internals.h \
gpr_replica_internals.c \
gpr_replica_component.c gpr_replica_component.c

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

@ -18,13 +18,13 @@
*/ */
typedef uint32_t mca_gpr_replica_key_t; typedef uint32_t mca_gpr_replica_key_t;
struct ompi_registry_t { struct mca_gpr_registry_t {
ompi_list_t registry; ompi_list_t registry;
ompi_list_t segment_dict; ompi_list_t segment_dict;
mca_gpr_replica_key_t lastkey; mca_gpr_replica_key_t lastkey;
ompi_list_t freekeys; ompi_list_t freekeys;
}; };
typedef struct ompi_registry_t ompi_registry_t; typedef struct mca_gpr_registry_t mca_gpr_registry_t;
/** Dictionary of token-key pairs. /** Dictionary of token-key pairs.
* This structure is used to create a linked list of token-key pairs. All calls to * This structure is used to create a linked list of token-key pairs. All calls to
@ -33,41 +33,41 @@ typedef struct ompi_registry_t ompi_registry_t;
* for faster searches of the registry. This structure is also used to return token-key pairs * for faster searches of the registry. This structure is also used to return token-key pairs
* from the dictionary in response to an ompi_registry_index() call. * from the dictionary in response to an ompi_registry_index() call.
*/ */
struct ompi_keytable_t { struct mca_gpr_keytable_t {
ompi_list_item_t item; /**< Allows this item to be placed on a list */ ompi_list_item_t item; /**< Allows this item to be placed on a list */
char *token; /**< Char string that defines the key */ char *token; /**< Char string that defines the key */
unsigned long int key; /**< Numerical value assigned by registry to represent token string */ mca_gpr_replica_key_t key; /**< Numerical value assigned by registry to represent token string */
}; };
typedef struct ompi_keytable_t ompi_keytable_t; typedef struct mca_gpr_keytable_t mca_gpr_keytable_t;
OBJ_CLASS_DECLARATION(ompi_keytable_t); OBJ_CLASS_DECLARATION(mca_gpr_keytable_t);
/** List of keys that describe a stored object. /** List of keys that describe a stored object.
* Each object stored in the registry may have as many keys describing it as the * Each object stored in the registry may have as many keys describing it as the
* creator desires. This structure is used to create a linked list of keys * creator desires. This structure is used to create a linked list of keys
* associated with each object. * associated with each object.
*/ */
struct ompi_keylist_t { struct mca_gpr_keylist_t {
ompi_list_item_t item; /**< Allows this item to be placed on a list */ ompi_list_item_t item; /**< Allows this item to be placed on a list */
unsigned long int key; /**< Numerical key that defines stored object */ mca_gpr_replica_key_t key; /**< Numerical key that defines stored object */
}; };
typedef struct ompi_keylist_t ompi_keylist_t; typedef struct mca_gpr_keylist_t mca_gpr_keylist_t;
OBJ_CLASS_DECLARATION(ompi_keylist_t); OBJ_CLASS_DECLARATION(mca_gpr_keylist_t);
/** List of subscribers to a stored object. /** List of subscribers to a stored object.
* Each object can have an arbitrary number of subscribers desiring notification * Each object can have an arbitrary number of subscribers desiring notification
* upon specified actions being performed against the object. This structure is * upon specified actions being performed against the object. This structure is
* used to create a linked list of subscribers for objects. * used to create a linked list of subscribers for objects.
*/ */
struct ompi_subscribe_list_t { struct mca_gpr_subscriber_list_t {
ompi_list_item_t item; /**< Allows this item to be placed on a list */ ompi_list_item_t item; /**< Allows this item to be placed on a list */
unsigned long int id; /**< ID of the subscriber */ ompi_process_name_t *subscriber; /**< ID of the subscriber */
uint8_t action; /**< Bit-mask of actions that trigger notification */ ompi_registry_notify_action_t action; /**< Bit-mask of actions that trigger notification */
}; };
typedef struct ompi_subscribe_list_t ompi_subscribe_list_t; typedef struct mca_gpr_subscriber_list_t mca_gpr_subscriber_list_t;
OBJ_CLASS_DECLARATION(ompi_subscribe_list_t); OBJ_CLASS_DECLARATION(mca_gpr_subscribe_list_t);
/** List of replicas that hold a stored object. /** List of replicas that hold a stored object.
* Each object can have an arbitrary number of replicas that hold a copy * Each object can have an arbitrary number of replicas that hold a copy
@ -75,13 +75,13 @@ OBJ_CLASS_DECLARATION(ompi_subscribe_list_t);
* two locations. This structure is used to create a linked list of * two locations. This structure is used to create a linked list of
* replicas for the object. * replicas for the object.
*/ */
struct ompi_replica_list_t { struct mca_gpr_replica_list_t {
ompi_list_item_t item; /**< Allows this item to be placed on a list */ ompi_list_item_t item; /**< Allows this item to be placed on a list */
char *name; /**< Name of the replica */ ompi_process_name_t *replica; /**< Name of the replica */
}; };
typedef struct ompi_replica_list_t ompi_replica_list_t; typedef struct mca_gpr_replica_list_t mca_gpr_replica_list_t;
OBJ_CLASS_DECLARATION(ompi_replica_list_t); OBJ_CLASS_DECLARATION(mca_gpr_replica_list_t);
/** Write invalidate structure. /** Write invalidate structure.
* The structure used to indicate that an object has been updated somewhere else in the GPR. * The structure used to indicate that an object has been updated somewhere else in the GPR.
@ -90,12 +90,12 @@ OBJ_CLASS_DECLARATION(ompi_replica_list_t);
* of the object within the global registry, and the replica holding the last known * of the object within the global registry, and the replica holding the last known
* up-to-date version of the object. * up-to-date version of the object.
*/ */
struct ompi_write_invalidate_t { struct mca_gpr_write_invalidate_t {
bool invalidate; bool invalidate;
time_t last_mod; time_t last_mod;
char *replica; ompi_process_name_t *valid_replica;
}; };
typedef struct ompi_write_invalidate_t ompi_write_invalidate_t; typedef struct mca_gpr_write_invalidate_t mca_gpr_write_invalidate_t;
/** The core registry structure. /** The core registry structure.
@ -110,18 +110,18 @@ typedef struct ompi_write_invalidate_t ompi_write_invalidate_t;
* object are automatically granted. This may be changed at some future time by adding an * object are automatically granted. This may be changed at some future time by adding an
* "authorization" linked list of ID's and their access rights to this structure. * "authorization" linked list of ID's and their access rights to this structure.
*/ */
struct ompi_registry_core_t { struct mca_gpr_registry_core_t {
ompi_list_item_t item; /**< Allows this item to be placed on a list */ ompi_list_item_t item; /**< Allows this item to be placed on a list */
ompi_list_t keys; /**< Linked list of keys that define stored object */ ompi_list_t keys; /**< Linked list of keys that define stored object */
int object_size; /**< Size of stored object, in bytes */ ompi_registry_object_size_t object_size; /**< Size of stored object, in bytes */
uint8_t *object; /**< Pointer to stored object */ ompi_registry_object_t *object; /**< Pointer to stored object */
ompi_list_t subscriber; /**< Linked list of subscribers to this object */ ompi_list_t subscriber; /**< Linked list of subscribers to this object */
ompi_list_t replicas; /**< Linked list of replicas that also contain this object */ ompi_list_t replicas; /**< Linked list of replicas that also contain this object */
ompi_write_invalidate_t write_invalidate; /**< Structure containing write invalidate info */ mca_gpr_write_invalidate_t write_invalidate; /**< Structure containing write invalidate info */
}; };
typedef struct ompi_registry_core_t ompi_registry_core_t; typedef struct mca_gpr_registry_core_t mca_gpr_registry_core_t;
OBJ_CLASS_DECLARATION(ompi_registry_core_t); OBJ_CLASS_DECLARATION(mca_gpr_registry_core_t);
/** Registry segment definition. /** Registry segment definition.
* The registry is subdivided into segments, each defining a unique domain. The "universe" segment * The registry is subdivided into segments, each defining a unique domain. The "universe" segment
@ -132,23 +132,23 @@ OBJ_CLASS_DECLARATION(ompi_registry_core_t);
* list of registry elements for that segment. Each segment also holds its own token-key dictionary * list of registry elements for that segment. Each segment also holds its own token-key dictionary
* to avoid naming conflicts between tokens from CommWorlds sharing a given universe. * to avoid naming conflicts between tokens from CommWorlds sharing a given universe.
*/ */
struct ompi_registry_segment_t { struct mca_gpr_registry_segment_t {
ompi_list_item_t item; /**< Allows this item to be placed on a list */ ompi_list_item_t item; /**< Allows this item to be placed on a list */
unsigned long int segment; /**< ID of registry segment */ mca_gpr_replica_key_t segment; /**< Key corresponding to name of registry segment */
unsigned long int lastkey; /**< Highest key value used */ mca_gpr_replica_key_t lastkey; /**< Highest key value used */
ompi_list_t reg_list; /**< Linked list of stored objects within this segment */ ompi_list_t registry_entries; /**< Linked list of stored objects within this segment */
ompi_list_t keytable; /**< Token-key dictionary for this segment */ ompi_list_t keytable; /**< Token-key dictionary for this segment */
ompi_list_t freekeys; /**< List of keys that have been made available */ ompi_list_t freekeys; /**< List of keys that have been made available */
}; };
typedef struct ompi_registry_segment_t ompi_registry_segment_t; typedef struct mca_gpr_registry_segment_t mca_gpr_registry_segment_t;
OBJ_CLASS_DECLARATION(ompi_registry_segment_t); OBJ_CLASS_DECLARATION(mca_gpr_registry_segment_t);
/* /*
* globals needed within component * globals needed within component
*/ */
extern ompi_registry_t mca_gpr_head; extern mca_gpr_registry_t mca_gpr_replica_head;
/* /*
* Module open / close * Module open / close

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

@ -65,18 +65,18 @@ static bool initialized = false;
/* /*
* globals needed within replica component * globals needed within replica component
*/ */
ompi_registry_t mca_gpr_head; mca_gpr_registry_t mca_gpr_replica_head;
/* constructor - used to initialize state of keytable instance */ /* constructor - used to initialize state of keytable instance */
static void ompi_keytable_construct(ompi_keytable_t* keytable) static void mca_gpr_keytable_construct(mca_gpr_keytable_t* keytable)
{ {
keytable->token = NULL; keytable->token = NULL;
keytable->key = 0; keytable->key = 0;
} }
/* destructor - used to free any resources held by instance */ /* destructor - used to free any resources held by instance */
static void ompi_keytable_destructor(ompi_keytable_t* keytable) static void mca_gpr_keytable_destructor(mca_gpr_keytable_t* keytable)
{ {
if (NULL != keytable->token) { if (NULL != keytable->token) {
free(keytable->token); free(keytable->token);
@ -85,125 +85,130 @@ static void ompi_keytable_destructor(ompi_keytable_t* keytable)
/* define instance of ompi_class_t */ /* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE( OBJ_CLASS_INSTANCE(
ompi_keytable_t, /* type name */ mca_gpr_keytable_t, /* type name */
ompi_list_item_t, /* parent "class" name */ ompi_list_item_t, /* parent "class" name */
ompi_keytable_construct, /* constructor */ mca_gpr_keytable_construct, /* constructor */
ompi_keytable_destructor); /* destructor */ mca_gpr_keytable_destructor); /* destructor */
/* constructor - used to initialize state of keytable instance */ /* constructor - used to initialize state of keytable instance */
static void ompi_keylist_construct(ompi_keylist_t* keylist) static void mca_gpr_keylist_construct(mca_gpr_keylist_t* keylist)
{ {
keylist->key = 0; keylist->key = 0;
} }
/* destructor - used to free any resources held by instance */ /* destructor - used to free any resources held by instance */
static void ompi_keylist_destructor(ompi_keylist_t* keylist) static void mca_gpr_keylist_destructor(mca_gpr_keylist_t* keylist)
{ {
} }
/* define instance of ompi_class_t */ /* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE( OBJ_CLASS_INSTANCE(
ompi_keylist_t, /* type name */ mca_gpr_keylist_t, /* type name */
ompi_list_item_t, /* parent "class" name */ ompi_list_item_t, /* parent "class" name */
ompi_keylist_construct, /* constructor */ mca_gpr_keylist_construct, /* constructor */
ompi_keylist_destructor); /* destructor */ mca_gpr_keylist_destructor); /* destructor */
/* constructor - used to initialize state of keytable instance */ /* constructor - used to initialize state of keytable instance */
static void ompi_subscribe_list_construct(ompi_subscribe_list_t* subscriber) static void mca_gpr_subscriber_list_construct(mca_gpr_subscriber_list_t* subscriber)
{ {
subscriber->id = 0; subscriber->subscriber = NULL;
subscriber->action = 0x00; subscriber->action = 0x00;
} }
/* destructor - used to free any resources held by instance */ /* destructor - used to free any resources held by instance */
static void ompi_subscribe_list_destructor(ompi_subscribe_list_t* subscriber) static void mca_gpr_subscriber_list_destructor(mca_gpr_subscriber_list_t* subscriber)
{ {
} if (NULL != subscriber->subscriber) {
free(subscriber->subscriber);
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
ompi_subscribe_list_t, /* type name */
ompi_list_item_t, /* parent "class" name */
ompi_subscribe_list_construct, /* constructor */
ompi_subscribe_list_destructor); /* destructor */
/* constructor - used to initialize state of replica list instance */
static void ompi_replica_list_construct(ompi_replica_list_t* replica)
{
replica->name = NULL;
}
/* destructor - used to free any resources held by instance */
static void ompi_replica_list_destructor(ompi_replica_list_t* replica)
{
if (NULL != replica->name) {
free(replica->name);
} }
} }
/* define instance of ompi_class_t */ /* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE( OBJ_CLASS_INSTANCE(
ompi_replica_list_t, /* type name */ mca_gpr_subscriber_list_t, /* type name */
ompi_list_item_t, /* parent "class" name */ ompi_list_item_t, /* parent "class" name */
ompi_replica_list_construct, /* constructor */ mca_gpr_subscriber_list_construct, /* constructor */
ompi_replica_list_destructor); /* destructor */ mca_gpr_subscriber_list_destructor); /* destructor */
/* constructor - used to initialize state of replica list instance */
static void mca_gpr_replica_list_construct(mca_gpr_replica_list_t* replica)
{
replica->replica = NULL;
}
/* destructor - used to free any resources held by instance */
static void mca_gpr_replica_list_destructor(mca_gpr_replica_list_t* replica)
{
if (NULL != replica->replica) {
free(replica->replica);
}
}
/* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE(
mca_gpr_replica_list_t, /* type name */
ompi_list_item_t, /* parent "class" name */
mca_gpr_replica_list_construct, /* constructor */
mca_gpr_replica_list_destructor); /* destructor */
/* constructor - used to initialize state of registry core instance */ /* constructor - used to initialize state of registry core instance */
static void ompi_registry_core_construct(ompi_registry_core_t* reg) static void mca_gpr_registry_core_construct(mca_gpr_registry_core_t* reg)
{ {
reg->object = NULL;
reg->object_size = 0;
OBJ_CONSTRUCT(&reg->subscriber, ompi_list_t);
OBJ_CONSTRUCT(&reg->keys, ompi_list_t); OBJ_CONSTRUCT(&reg->keys, ompi_list_t);
reg->object_size = 0;
reg->object = NULL;
OBJ_CONSTRUCT(&reg->subscriber, ompi_list_t);
OBJ_CONSTRUCT(&reg->replicas, ompi_list_t);
} }
/* destructor - used to free any resources held by instance */ /* destructor - used to free any resources held by instance */
static void ompi_registry_core_destructor(ompi_registry_core_t* reg) static void mca_gpr_registry_core_destructor(mca_gpr_registry_core_t* reg)
{ {
OBJ_DESTRUCT(&reg->keys);
if (NULL != reg->object) { if (NULL != reg->object) {
free(reg->object); free(reg->object);
} }
OBJ_DESTRUCT(&reg->subscriber); OBJ_DESTRUCT(&reg->subscriber);
OBJ_DESTRUCT(&reg->keys); OBJ_DESTRUCT(&reg->replicas);
} }
/* define instance of ompi_class_t */ /* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE( OBJ_CLASS_INSTANCE(
ompi_registry_core_t, /* type name */ mca_gpr_registry_core_t, /* type name */
ompi_list_item_t, /* parent "class" name */ ompi_list_item_t, /* parent "class" name */
ompi_registry_core_construct, /* constructor */ mca_gpr_registry_core_construct, /* constructor */
ompi_registry_core_destructor); /* destructor */ mca_gpr_registry_core_destructor); /* destructor */
/* constructor - used to initialize state of segment instance */ /* constructor - used to initialize state of segment instance */
static void ompi_registry_segment_construct(ompi_registry_segment_t* seg) static void mca_gpr_registry_segment_construct(mca_gpr_registry_segment_t* seg)
{ {
seg->segment = 0; seg->segment = NULL;
seg->lastkey = 0; seg->lastkey = 0;
OBJ_CONSTRUCT(&seg->reg_list, ompi_list_t); OBJ_CONSTRUCT(&seg->registry_entries, ompi_list_t);
OBJ_CONSTRUCT(&seg->keytable, ompi_list_t); OBJ_CONSTRUCT(&seg->keytable, ompi_list_t);
OBJ_CONSTRUCT(&seg->freekeys, ompi_list_t); OBJ_CONSTRUCT(&seg->freekeys, ompi_list_t);
} }
/* destructor - used to free any resources held by instance */ /* destructor - used to free any resources held by instance */
static void ompi_registry_segment_destructor(ompi_registry_segment_t* seg) static void mca_gpr_registry_segment_destructor(mca_gpr_registry_segment_t* seg)
{ {
OBJ_DESTRUCT(&seg->reg_list); OBJ_DESTRUCT(&seg->registry_entries);
OBJ_DESTRUCT(&seg->keytable); OBJ_DESTRUCT(&seg->keytable);
OBJ_DESTRUCT(&seg->freekeys); OBJ_DESTRUCT(&seg->freekeys);
} }
/* define instance of ompi_class_t */ /* define instance of ompi_class_t */
OBJ_CLASS_INSTANCE( OBJ_CLASS_INSTANCE(
ompi_registry_segment_t, /* type name */ mca_gpr_registry_segment_t, /* type name */
ompi_list_item_t, /* parent "class" name */ ompi_list_item_t, /* parent "class" name */
ompi_registry_segment_construct, /* constructor */ mca_gpr_registry_segment_construct, /* constructor */
ompi_registry_segment_destructor); /* destructor */ mca_gpr_registry_segment_destructor); /* destructor */
/* /*
@ -246,12 +251,12 @@ mca_gpr_base_module_t *mca_gpr_replica_init(bool *allow_multi_user_threads, bool
*have_hidden_threads = false; *have_hidden_threads = false;
/* initialize the registry head */ /* initialize the registry head */
OBJ_CONSTRUCT(&mca_gpr_head.registry, ompi_list_t); OBJ_CONSTRUCT(&mca_gpr_replica_head.registry, ompi_list_t);
/* initialize the global dictionary for segment id's */ /* initialize the global dictionary for segment id's */
OBJ_CONSTRUCT(&mca_gpr_head.segment_dict, ompi_list_t); OBJ_CONSTRUCT(&mca_gpr_replica_head.segment_dict, ompi_list_t);
OBJ_CONSTRUCT(&mca_gpr_head.freekeys, ompi_list_t); OBJ_CONSTRUCT(&mca_gpr_replica_head.freekeys, ompi_list_t);
mca_gpr_head.lastkey = 0; mca_gpr_replica_head.lastkey = 0;
/* define the "universe" segment key */ /* define the "universe" segment key */
/* if (0 == gpr_replica_definekey("universe", NULL)) { /* if (0 == gpr_replica_definekey("universe", NULL)) {

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

@ -30,24 +30,24 @@
/* /*
* *
*/ */
ompi_registry_segment_t *ompi_registry_findseg(char *segment) mca_gpr_registry_segment_t *gpr_replica_find_seg(char *segment)
{ {
ompi_keytable_t *ptr_seg; mca_gpr_keytable_t *ptr_seg;
ompi_registry_segment_t *seg; mca_gpr_registry_segment_t *seg;
/* search the registry segments to find which one is being referenced */ /* search the registry segments to find which one is being referenced */
for (ptr_seg = (ompi_keytable_t*)ompi_list_get_first(&ompi_registry.segment_dict); for (ptr_seg = (mca_gpr_keytable_t*)ompi_list_get_first(&mca_gpr_replica_head.segment_dict);
ptr_seg != (ompi_keytable_t*)ompi_list_get_end(&ompi_registry.segment_dict); ptr_seg != (mca_gpr_keytable_t*)ompi_list_get_end(&mca_gpr_replica_head.segment_dict);
ptr_seg = (ompi_keytable_t*)ompi_list_get_next(ptr_seg)) { ptr_seg = (mca_gpr_keytable_t*)ompi_list_get_next(ptr_seg)) {
if (0 == strcmp(segment, ptr_seg->token)) { if (0 == strcmp(segment, ptr_seg->token)) {
fprintf(stderr, "findseg: found segment token %s key %ld\n", ptr_seg->token, ptr_seg->key); fprintf(stderr, "findseg: found segment token %s key %d\n", ptr_seg->token, (int)ptr_seg->key);
/* search ompi_registry to find segment */ /* search mca_gpr_replica_head to find segment */
for (seg=(ompi_registry_segment_t*)ompi_list_get_first(&ompi_registry.registry); for (seg=(mca_gpr_registry_segment_t*)ompi_list_get_first(&mca_gpr_replica_head.registry);
seg != (ompi_registry_segment_t*)ompi_list_get_end(&ompi_registry.registry); seg != (mca_gpr_registry_segment_t*)ompi_list_get_end(&mca_gpr_replica_head.registry);
seg = (ompi_registry_segment_t*)ompi_list_get_next(seg)) { seg = (mca_gpr_registry_segment_t*)ompi_list_get_next(seg)) {
fprintf(stderr, "findseg: checking seg\n"); fprintf(stderr, "findseg: checking seg\n");
if(seg->segment == ptr_seg->key) { if(seg->segment == ptr_seg->key) {
fprintf(stderr, "findseg: found segment key %ld\n", seg->segment); fprintf(stderr, "findseg: found segment key %d\n", (int)seg->segment);
return(seg); return(seg);
} }
} }
@ -56,29 +56,29 @@ ompi_registry_segment_t *ompi_registry_findseg(char *segment)
return(NULL); /* couldn't find the specified segment */ return(NULL); /* couldn't find the specified segment */
} }
ompi_keytable_t *ompi_registry_finddictentry(char *segment, char *token) mca_gpr_keytable_t *gpr_replica_find_dict_entry(char *segment, char *token)
{ {
ompi_keytable_t *ptr_seg; mca_gpr_keytable_t *ptr_seg;
ompi_keytable_t *ptr_key; mca_gpr_keytable_t *ptr_key;
ompi_registry_segment_t *seg; mca_gpr_registry_segment_t *seg;
/* search the registry segments to find which one is being referenced */ /* search the registry segments to find which one is being referenced */
for (ptr_seg = (ompi_keytable_t*)ompi_list_get_first(&ompi_registry.segment_dict); for (ptr_seg = (mca_gpr_keytable_t*)ompi_list_get_first(&mca_gpr_replica_head.segment_dict);
ptr_seg != (ompi_keytable_t*)ompi_list_get_end(&ompi_registry.segment_dict); ptr_seg != (mca_gpr_keytable_t*)ompi_list_get_end(&mca_gpr_replica_head.segment_dict);
ptr_seg = (ompi_keytable_t*)ompi_list_get_next(ptr_seg)) { ptr_seg = (mca_gpr_keytable_t*)ompi_list_get_next(ptr_seg)) {
if (0 == strcmp(segment, ptr_seg->token)) { if (0 == strcmp(segment, ptr_seg->token)) {
if (NULL == token) { /* just want segment token-key pair */ if (NULL == token) { /* just want segment token-key pair */
return(ptr_seg); return(ptr_seg);
} }
/* search ompi_registry to find segment */ /* search registry to find segment */
for (seg=(ompi_registry_segment_t*)ompi_list_get_first(&ompi_registry.registry); for (seg=(mca_gpr_registry_segment_t*)ompi_list_get_first(&mca_gpr_replica_head.registry);
seg != (ompi_registry_segment_t*)ompi_list_get_end(&ompi_registry.registry); seg != (mca_gpr_registry_segment_t*)ompi_list_get_end(&mca_gpr_replica_head.registry);
seg = (ompi_registry_segment_t*)ompi_list_get_next(seg)) { seg = (mca_gpr_registry_segment_t*)ompi_list_get_next(seg)) {
if(seg->segment == ptr_seg->key) { if(seg->segment == ptr_seg->key) {
/* got segment - now find specified token-key pair in that dictionary */ /* got segment - now find specified token-key pair in that dictionary */
for (ptr_key = (ompi_keytable_t*)ompi_list_get_first(&seg->keytable); for (ptr_key = (mca_gpr_keytable_t*)ompi_list_get_first(&seg->keytable);
ptr_key != (ompi_keytable_t*)ompi_list_get_end(&seg->keytable); ptr_key != (mca_gpr_keytable_t*)ompi_list_get_end(&seg->keytable);
ptr_key = (ompi_keytable_t*)ompi_list_get_next(ptr_key)) { ptr_key = (mca_gpr_keytable_t*)ompi_list_get_next(ptr_key)) {
if (0 == strcmp(token, ptr_key->token)) { if (0 == strcmp(token, ptr_key->token)) {
return(ptr_key); return(ptr_key);
} }
@ -93,18 +93,18 @@ ompi_keytable_t *ompi_registry_finddictentry(char *segment, char *token)
} }
mca_gpr_replica_key_t ompi_registry_getkey(char *segment, char *token) mca_gpr_replica_key_t gpr_replica_get_key(char *segment, char *token)
{ {
ompi_keytable_t *ptr_key; mca_gpr_keytable_t *ptr_key;
/* find registry segment */ /* find registry segment */
ptr_key = ompi_registry_finddictentry(segment, NULL); ptr_key = gpr_replica_find_dict_entry(segment, NULL);
if (NULL != ptr_key) { if (NULL != ptr_key) {
if (NULL == token) { /* only want segment key */ if (NULL == token) { /* only want segment key */
return(ptr_key->key); return(ptr_key->key);
} }
/* if token specified, find the dictionary entry that matches token */ /* if token specified, find the dictionary entry that matches token */
ptr_key = ompi_registry_finddictentry(segment, token); ptr_key = gpr_replica_find_dict_entry(segment, token);
if (NULL != ptr_key) { if (NULL != ptr_key) {
return(ptr_key->key); return(ptr_key->key);
} }
@ -114,10 +114,10 @@ mca_gpr_replica_key_t ompi_registry_getkey(char *segment, char *token)
} }
mca_gpr_relica_key_t gpr_replica_definekey(char *segment, char *token) mca_gpr_replica_key_t gpr_replica_define_key(char *segment, char *token)
{ {
ompi_registry_segment_t *seg; mca_gpr_registry_segment_t *seg;
ompi_keytable_t *ptr_seg, *ptr_key, *new; mca_gpr_keytable_t *ptr_seg, *ptr_key, *new;
/* protect against errors */ /* protect against errors */
if (NULL == segment) { if (NULL == segment) {
@ -126,48 +126,48 @@ mca_gpr_relica_key_t gpr_replica_definekey(char *segment, char *token)
/* if token is NULL, then this is defining a segment name. Check dictionary to ensure uniqueness */ /* if token is NULL, then this is defining a segment name. Check dictionary to ensure uniqueness */
if (NULL == token) { if (NULL == token) {
for (ptr_seg = (ompi_keytable_t*)ompi_list_get_first(&ompi_registry.segment_dict); for (ptr_seg = (mca_gpr_keytable_t*)ompi_list_get_first(&mca_gpr_replica_head.segment_dict);
ptr_seg != (ompi_keytable_t*)ompi_list_get_end(&ompi_registry.segment_dict); ptr_seg != (mca_gpr_keytable_t*)ompi_list_get_end(&mca_gpr_replica_head.segment_dict);
ptr_seg = (ompi_keytable_t*)ompi_list_get_next(ptr_seg)) { ptr_seg = (mca_gpr_keytable_t*)ompi_list_get_next(ptr_seg)) {
if (0 == strcmp(segment, ptr_seg->token)) { if (0 == strcmp(segment, ptr_seg->token)) {
return(0); return(0);
} }
} }
/* okay, name is not previously taken. Define a key value for it and return */ /* okay, name is not previously taken. Define a key value for it and return */
new = OBJ_NEW(ompi_keytable_t); new = OBJ_NEW(mca_gpr_keytable_t);
new->token = strdup(segment); new->token = strdup(segment);
if (0 == ompi_list_get_size(&ompi_registry.freekeys)) { /* no keys waiting for reuse */ if (0 == ompi_list_get_size(&mca_gpr_replica_head.freekeys)) { /* no keys waiting for reuse */
ompi_registry.lastkey++; mca_gpr_replica_head.lastkey++;
new->key = ompi_registry.lastkey; new->key = mca_gpr_replica_head.lastkey;
} else { } else {
ptr_key = (ompi_keytable_t*)ompi_list_remove_first(&ompi_registry.freekeys); ptr_key = (mca_gpr_keytable_t*)ompi_list_remove_first(&mca_gpr_replica_head.freekeys);
new->key = ptr_key->key; new->key = ptr_key->key;
} }
ompi_list_append(&ompi_registry.segment_dict, &new->item); ompi_list_append(&mca_gpr_replica_head.segment_dict, &new->item);
return(new->key); return(new->key);
} }
/* okay, token is specified */ /* okay, token is specified */
/* search the registry segments to find which one is being referenced */ /* search the registry segments to find which one is being referenced */
seg = ompi_registry_findseg(segment); seg = gpr_replica_find_seg(segment);
if (NULL != seg) { if (NULL != seg) {
/* using that segment, check dictionary to ensure uniqueness */ /* using that segment, check dictionary to ensure uniqueness */
for (ptr_key = (ompi_keytable_t*)ompi_list_get_first(&seg->keytable); for (ptr_key = (mca_gpr_keytable_t*)ompi_list_get_first(&seg->keytable);
ptr_key != (ompi_keytable_t*)ompi_list_get_end(&seg->keytable); ptr_key != (mca_gpr_keytable_t*)ompi_list_get_end(&seg->keytable);
ptr_key = (ompi_keytable_t*)ompi_list_get_next(ptr_key)) { ptr_key = (mca_gpr_keytable_t*)ompi_list_get_next(ptr_key)) {
if (0 == strcmp(token, ptr_key->token)) { if (0 == strcmp(token, ptr_key->token)) {
return(0); /* already taken, report error */ return(0); /* already taken, report error */
} }
} }
/* okay, token is unique - create dictionary entry */ /* okay, token is unique - create dictionary entry */
new = OBJ_NEW(ompi_keytable_t); new = OBJ_NEW(mca_gpr_keytable_t);
new->token = strdup(token); new->token = strdup(token);
if (0 == ompi_list_get_size(&seg->freekeys)) { /* no keys waiting for reuse */ if (0 == ompi_list_get_size(&seg->freekeys)) { /* no keys waiting for reuse */
seg->lastkey++; seg->lastkey++;
new->key = seg->lastkey; new->key = seg->lastkey;
} else { } else {
ptr_key = (ompi_keytable_t*)ompi_list_remove_first(&seg->freekeys); ptr_key = (mca_gpr_keytable_t*)ompi_list_remove_first(&seg->freekeys);
new->key = ptr_key->key; new->key = ptr_key->key;
} }
ompi_list_append(&seg->keytable, &new->item); ompi_list_append(&seg->keytable, &new->item);
@ -177,12 +177,11 @@ mca_gpr_relica_key_t gpr_replica_definekey(char *segment, char *token)
return(0); return(0);
} }
int ompi_registry_deletekey(char *segment, char *token) int gpr_replica_delete_key(char *segment, char *token)
{ {
ompi_registry_segment_t *seg; mca_gpr_registry_segment_t *seg;
ompi_registry_core_t *reg, *prev; mca_gpr_registry_core_t *reg, *prev;
ompi_keytable_t *ptr_seg, *ptr_key, *new, *regkey; mca_gpr_keytable_t *ptr_seg, *ptr_key, *new, *regkey;
ompi_subscribe_list_t *subscriber;
/* protect ourselves against errors */ /* protect ourselves against errors */
if (NULL == segment) { if (NULL == segment) {
@ -190,13 +189,14 @@ int ompi_registry_deletekey(char *segment, char *token)
} }
/* find the segment */ /* find the segment */
seg = ompi_registry_findseg(segment); seg = gpr_replica_find_seg(segment);
if (NULL != seg) { if (NULL != seg) {
/* if specified token is NULL, then this is deleting a segment name.*/ /* if specified token is NULL, then this is deleting a segment name.*/
if (NULL == token) { if (NULL == token) {
/* empty the segment's registry */ /* empty the segment's registry */
while (0 < ompi_list_get_size(&seg->reg_list)) { while (0 < ompi_list_get_size(&seg->registry_entries)) {
ompi_list_remove_last(&seg->reg_list); ompi_list_remove_last(&seg->registry_entries);
} }
/* empty the segment's dictionary */ /* empty the segment's dictionary */
while (0 < ompi_list_get_size(&seg->keytable)) { while (0 < ompi_list_get_size(&seg->keytable)) {
@ -207,38 +207,32 @@ int ompi_registry_deletekey(char *segment, char *token)
ompi_list_remove_last(&seg->freekeys); ompi_list_remove_last(&seg->freekeys);
} }
/* now remove segment from global registry */ /* now remove segment from global registry */
ompi_list_remove_item(&ompi_registry.registry, &seg->item); ompi_list_remove_item(&mca_gpr_replica_head.registry, &seg->item);
/* add key to global registry's freekey list */ /* add key to global registry's freekey list */
new = OBJ_NEW(ompi_keytable_t); new = OBJ_NEW(mca_gpr_keytable_t);
new->token = NULL; new->token = NULL;
new->key = ptr_seg->key; new->key = ptr_seg->key;
ompi_list_append(&ompi_registry.freekeys, &new->item); ompi_list_append(&mca_gpr_replica_head.freekeys, &new->item);
/* NEED TO RE-FIND PTR_SEG */ /* NEED TO RE-FIND PTR_SEG */
/* now remove the dictionary entry from the global registry dictionary*/ /* now remove the dictionary entry from the global registry dictionary*/
ompi_list_remove_item(&ompi_registry.segment_dict, &ptr_seg->item); ompi_list_remove_item(&mca_gpr_replica_head.segment_dict, &ptr_seg->item);
return(OMPI_SUCCESS); return(OMPI_SUCCESS);
} else { /* token not null, so need to find dictionary element to delete */ } else { /* token not null, so need to find dictionary element to delete */
ptr_key = ompi_registry_finddictentry(segment, token); ptr_key = gpr_replica_find_dict_entry(segment, token);
if (NULL != ptr_key) { if (NULL != ptr_key) {
/* found key in dictionary */ /* found key in dictionary */
/* need to search this segment's registry to find all instances of key - then delete them */ /* need to search this segment's registry to find all instances of key - then delete them */
for (reg = (ompi_registry_core_t*)ompi_list_get_first(&seg->reg_list); for (reg = (mca_gpr_registry_core_t*)ompi_list_get_first(&seg->registry_entries);
reg != (ompi_registry_core_t*)ompi_list_get_end(&seg->reg_list); reg != (mca_gpr_registry_core_t*)ompi_list_get_end(&seg->registry_entries);
reg = (ompi_registry_core_t*)ompi_list_get_next(reg)) { reg = (mca_gpr_registry_core_t*)ompi_list_get_next(reg)) {
/* check the subscriber list */
for (subscriber = (ompi_subscribe_list_t*)ompi_list_get_first(&reg->subscriber);
(subscriber != (ompi_subscribe_list_t*)ompi_list_get_end(&reg->subscriber)
&& (subscriber->id != ptr_key->key));
subscriber = (ompi_subscribe_list_t*)ompi_list_get_next(subscriber));
if (subscriber != (ompi_subscribe_list_t*)ompi_list_get_end(&reg->subscriber)) {
ompi_list_remove_item(&reg->subscriber, &subscriber->item);
}
/* check the key list */ /* check the key list */
for (regkey = (ompi_keytable_t*)ompi_list_get_first(&reg->keys); for (regkey = (mca_gpr_keytable_t*)ompi_list_get_first(&reg->keys);
(regkey != (ompi_keytable_t*)ompi_list_get_end(&reg->keys)) (regkey != (mca_gpr_keytable_t*)ompi_list_get_end(&reg->keys))
&& (regkey->key != ptr_key->key); && (regkey->key != ptr_key->key);
regkey = (ompi_keytable_t*)ompi_list_get_next(regkey)); regkey = (mca_gpr_keytable_t*)ompi_list_get_next(regkey));
if (regkey != (ompi_keytable_t*)ompi_list_get_end(&reg->keys)) { if (regkey != (mca_gpr_keytable_t*)ompi_list_get_end(&reg->keys)) {
ompi_list_remove_item(&reg->keys, &regkey->item); ompi_list_remove_item(&reg->keys, &regkey->item);
} }
/* if this was the last key, then remove the registry entry itself */ /* if this was the last key, then remove the registry entry itself */
@ -246,16 +240,18 @@ int ompi_registry_deletekey(char *segment, char *token)
while (0 < ompi_list_get_size(&reg->subscriber)) { while (0 < ompi_list_get_size(&reg->subscriber)) {
ompi_list_remove_last(&reg->subscriber); ompi_list_remove_last(&reg->subscriber);
} }
prev = (ompi_registry_core_t*)ompi_list_get_prev(reg); prev = (mca_gpr_registry_core_t*)ompi_list_get_prev(reg);
ompi_list_remove_item(&seg->reg_list, &reg->item); ompi_list_remove_item(&seg->registry_entries, &reg->item);
reg = prev; reg = prev;
} }
} }
/* add key to this segment's freekey list */ /* add key to this segment's freekey list */
new = OBJ_NEW(ompi_keytable_t); new = OBJ_NEW(mca_gpr_keytable_t);
new->token = NULL; new->token = NULL;
new->key = ptr_key->key; new->key = ptr_key->key;
ompi_list_append(&seg->freekeys, &new->item); ompi_list_append(&seg->freekeys, &new->item);
/* now remove the dictionary entry from the segment's dictionary */ /* now remove the dictionary entry from the segment's dictionary */
ompi_list_remove_item(&seg->keytable, &ptr_key->item); ompi_list_remove_item(&seg->keytable, &ptr_key->item);
return(OMPI_SUCCESS); return(OMPI_SUCCESS);

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

@ -18,7 +18,7 @@
* @retval key Unsigned long integer value corresponding to the specified token within the specified segment. * @retval key Unsigned long integer value corresponding to the specified token within the specified segment.
* @retval -1 Indicates that the segment and/or token could not be found. * @retval -1 Indicates that the segment and/or token could not be found.
*/ */
mca_gpr_replica_key_t gpr_replica_getkey(char *segment, char *token); mca_gpr_replica_key_t gpr_replica_get_key(char *segment, char *token);
/** Add a token to a segment's dictionary. /** Add a token to a segment's dictionary.
* The gpr_replica_definekey() function allows the addition of a new definition to * The gpr_replica_definekey() function allows the addition of a new definition to
@ -33,7 +33,7 @@ mca_gpr_replica_key_t gpr_replica_getkey(char *segment, char *token);
* @retval key Unsigned long integer value corresponding to the specified token within the specified segment. * @retval key Unsigned long integer value corresponding to the specified token within the specified segment.
* @retval -1 Indicates that the entry could not be created. * @retval -1 Indicates that the entry could not be created.
*/ */
mca_gpr_replica_key_t gpr_replica_definekey(char *segment, char *token); mca_gpr_replica_key_t gpr_replica_define_key(char *segment, char *token);
/** Delete a token from a segment's dictionary. /** Delete a token from a segment's dictionary.
* The gpr_replica_deletekey() function allows the removal of a definition from the * The gpr_replica_deletekey() function allows the removal of a definition from the
@ -51,7 +51,7 @@ mca_gpr_replica_key_t gpr_replica_definekey(char *segment, char *token);
* @retval OMPI_ERROR Indicates that the operation failed - most likely caused by specifying * @retval OMPI_ERROR Indicates that the operation failed - most likely caused by specifying
* a token that did not exist within the specified segment, or a non-existent segment. * a token that did not exist within the specified segment, or a non-existent segment.
*/ */
int gpr_replica_deletekey(char *segment, char *token); int gpr_replica_delete_key(char *segment, char *token);
/** Find a requested registry segment. /** Find a requested registry segment.
* The gpr_replica_findseq() function finds the registry segment corresponding to * The gpr_replica_findseq() function finds the registry segment corresponding to
@ -62,5 +62,7 @@ int gpr_replica_deletekey(char *segment, char *token);
* @retval *seg Pointer to the segment * @retval *seg Pointer to the segment
* @retval NULL Indicates that the specified segment could not be found * @retval NULL Indicates that the specified segment could not be found
*/ */
ompi_registry_segment_t *gpr_replica_findseg(char *segment); mca_gpr_registry_segment_t *gpr_replica_find_seg(char *segment);
mca_gpr_keytable_t *gpr_replica_find_dict_entry(char *segment, char *token);