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

* rename ompi_hash_table opal_hash_table

Просмотр исходного кода 
This commit was SVN r6324.
Этот коммит содержится в:
Brian Barrett 2005-07-03 16:52:32 +00:00
родитель 764a9314db
Коммит 9f0c969bb4
39 изменённых файлов: 295 добавлений и 295 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

66
ompi/attribute/attribute.c
Просмотреть файл

@ -366,10 +366,10 @@ static void attribute_value_construct(attribute_value_t *item);
static void ompi_attrkey_item_construct(ompi_attrkey_item_t *item);
static void ompi_attrkey_item_destruct(ompi_attrkey_item_t *item);
static int set_value(ompi_attribute_type_t type, void *object,
ompi_hash_table_t **keyhash, int key,
opal_hash_table_t **keyhash, int key,
attribute_value_t *new_attr,
bool predefined, bool need_lock);
static int get_value(ompi_hash_table_t *keyhash, int key,
static int get_value(opal_hash_table_t *keyhash, int key,
attribute_value_t **attribute, int *flag);
static void *translate_to_c(attribute_value_t *val);
static MPI_Fint translate_to_fortran_mpi1(attribute_value_t *val);
@ -398,7 +398,7 @@ static OBJ_CLASS_INSTANCE(ompi_attrkey_item_t,
* Static variables
*/
static ompi_hash_table_t *keyval_hash;
static opal_hash_table_t *keyval_hash;
static ompi_bitmap_t *key_bitmap;
static unsigned int int_pos = 12345;
@ -443,7 +443,7 @@ ompi_attrkey_item_destruct(ompi_attrkey_item_t *item)
/* Remove the key entry from the hash and free the key */
OMPI_THREAD_LOCK(&alock);
ompi_hash_table_remove_value_uint32(keyval_hash, item->key);
opal_hash_table_remove_value_uint32(keyval_hash, item->key);
FREE_KEY(item->key);
OMPI_THREAD_UNLOCK(&alock);
}
@ -460,7 +460,7 @@ int ompi_attr_init(void)
void *bogus = (void*) 1;
MPI_Fint *p = (MPI_Fint*) &bogus;
keyval_hash = OBJ_NEW(ompi_hash_table_t);
keyval_hash = OBJ_NEW(opal_hash_table_t);
if (NULL == keyval_hash) {
return MPI_ERR_SYSRESOURCE;
}
@ -476,7 +476,7 @@ int ompi_attr_init(void)
}
}
if (OMPI_SUCCESS != (ret = ompi_hash_table_init(keyval_hash,
if (OMPI_SUCCESS != (ret = opal_hash_table_init(keyval_hash,
ATTR_TABLE_SIZE))) {
return ret;
}
@ -527,7 +527,7 @@ int ompi_attr_create_keyval(ompi_attribute_type_t type,
OMPI_THREAD_LOCK(&alock);
ret = CREATE_KEY(key);
if (OMPI_SUCCESS == ret) {
ret = ompi_hash_table_set_value_uint32(keyval_hash, *key, attr);
ret = opal_hash_table_set_value_uint32(keyval_hash, *key, attr);
}
OMPI_THREAD_UNLOCK(&alock);
if (OMPI_SUCCESS != ret) {
@ -564,7 +564,7 @@ int ompi_attr_free_keyval(ompi_attribute_type_t type, int *key,
/* Find the key-value pair */
OMPI_THREAD_LOCK(&alock);
ret = ompi_hash_table_get_value_uint32(keyval_hash, *key,
ret = opal_hash_table_get_value_uint32(keyval_hash, *key,
(void **) &key_item);
OMPI_THREAD_UNLOCK(&alock);
@ -589,7 +589,7 @@ int ompi_attr_free_keyval(ompi_attribute_type_t type, int *key,
int ompi_attr_delete(ompi_attribute_type_t type, void *object,
ompi_hash_table_t *keyhash, int key,
opal_hash_table_t *keyhash, int key,
bool predefined, bool need_lock)
{
ompi_attrkey_item_t *key_item;
@ -614,7 +614,7 @@ int ompi_attr_delete(ompi_attribute_type_t type, void *object,
/* Check if the key is valid in the master keyval hash */
ret = ompi_hash_table_get_value_uint32(keyval_hash, key,
ret = opal_hash_table_get_value_uint32(keyval_hash, key,
(void **) &key_item);
if ((OMPI_SUCCESS != ret) || (NULL == key_item) ||
@ -635,7 +635,7 @@ int ompi_attr_delete(ompi_attribute_type_t type, void *object,
yes, then delete the attribute and key entry from the object's key
hash */
ret = ompi_hash_table_get_value_uint32(keyhash, key, (void**) &attr);
ret = opal_hash_table_get_value_uint32(keyhash, key, (void**) &attr);
if (OMPI_SUCCESS == ret) {
switch (type) {
case COMM_ATTR:
@ -658,7 +658,7 @@ int ompi_attr_delete(ompi_attribute_type_t type, void *object,
}
OBJ_RELEASE(attr);
ret = ompi_hash_table_remove_value_uint32(keyhash, key);
ret = opal_hash_table_remove_value_uint32(keyhash, key);
if (OMPI_SUCCESS != ret) {
goto exit;
}
@ -684,7 +684,7 @@ int ompi_attr_delete(ompi_attribute_type_t type, void *object,
* attribute.
*/
int ompi_attr_set_c(ompi_attribute_type_t type, void *object,
ompi_hash_table_t **keyhash,
opal_hash_table_t **keyhash,
int key, void *attribute, bool predefined, bool need_lock)
{
attribute_value_t *new_attr = OBJ_NEW(attribute_value_t);
@ -704,7 +704,7 @@ int ompi_attr_set_c(ompi_attribute_type_t type, void *object,
* an attribute.
*/
int ompi_attr_set_fortran_mpi1(ompi_attribute_type_t type, void *object,
ompi_hash_table_t **keyhash,
opal_hash_table_t **keyhash,
int key, MPI_Fint attribute,
bool predefined, bool need_lock)
{
@ -726,7 +726,7 @@ int ompi_attr_set_fortran_mpi1(ompi_attribute_type_t type, void *object,
* an attribute.
*/
int ompi_attr_set_fortran_mpi2(ompi_attribute_type_t type, void *object,
ompi_hash_table_t **keyhash,
opal_hash_table_t **keyhash,
int key, MPI_Aint attribute,
bool predefined, bool need_lock)
{
@ -746,7 +746,7 @@ int ompi_attr_set_fortran_mpi2(ompi_attribute_type_t type, void *object,
* Front-end function called by the C MPI API functions to get
* attributes.
*/
int ompi_attr_get_c(ompi_hash_table_t *keyhash, int key,
int ompi_attr_get_c(opal_hash_table_t *keyhash, int key,
void **attribute, int *flag)
{
attribute_value_t *val;
@ -765,7 +765,7 @@ int ompi_attr_get_c(ompi_hash_table_t *keyhash, int key,
* Front-end function called by the Fortran MPI-1 API functions to get
* attributes.
*/
int ompi_attr_get_fortran_mpi1(ompi_hash_table_t *keyhash, int key,
int ompi_attr_get_fortran_mpi1(opal_hash_table_t *keyhash, int key,
MPI_Fint *attribute, int *flag)
{
attribute_value_t *val;
@ -784,7 +784,7 @@ int ompi_attr_get_fortran_mpi1(ompi_hash_table_t *keyhash, int key,
* Front-end function called by the Fortran MPI-2 API functions to get
* attributes.
*/
int ompi_attr_get_fortran_mpi2(ompi_hash_table_t *keyhash, int key,
int ompi_attr_get_fortran_mpi2(opal_hash_table_t *keyhash, int key,
MPI_Aint *attribute, int *flag)
{
attribute_value_t *val;
@ -803,8 +803,8 @@ int ompi_attr_get_fortran_mpi2(ompi_hash_table_t *keyhash, int key,
* Copy all the attributes from one MPI object to another
*/
int ompi_attr_copy_all(ompi_attribute_type_t type, void *old_object,
void *new_object, ompi_hash_table_t *oldkeyhash,
ompi_hash_table_t *newkeyhash)
void *new_object, opal_hash_table_t *oldkeyhash,
opal_hash_table_t *newkeyhash)
{
int ret;
int err;
@ -833,7 +833,7 @@ int ompi_attr_copy_all(ompi_attribute_type_t type, void *old_object,
OMPI_THREAD_LOCK(&alock);
/* Get the first key-attr in the object's key hash */
ret = ompi_hash_table_get_first_key_uint32(oldkeyhash, &key,
ret = opal_hash_table_get_first_key_uint32(oldkeyhash, &key,
(void **) &old_attr,
&node);
@ -845,7 +845,7 @@ int ompi_attr_copy_all(ompi_attribute_type_t type, void *old_object,
/* Get the attr_item in the main keyval hash - so that we know
what the copy_attr_fn is */
err = ompi_hash_table_get_value_uint32(keyval_hash, key,
err = opal_hash_table_get_value_uint32(keyval_hash, key,
(void **) &hash_value);
new_attr = OBJ_NEW(attribute_value_t);
@ -893,7 +893,7 @@ int ompi_attr_copy_all(ompi_attribute_type_t type, void *old_object,
OBJ_RELEASE(new_attr);
}
ret = ompi_hash_table_get_next_key_uint32(oldkeyhash, &key,
ret = opal_hash_table_get_next_key_uint32(oldkeyhash, &key,
(void **) &old_attr,
in_node, &node);
}
@ -909,7 +909,7 @@ int ompi_attr_copy_all(ompi_attribute_type_t type, void *old_object,
* Delete all the attributes on an MPI object
*/
int ompi_attr_delete_all(ompi_attribute_type_t type, void *object,
ompi_hash_table_t *keyhash)
opal_hash_table_t *keyhash)
{
int key_ret, del_ret;
uint32_t key, oldkey;
@ -934,7 +934,7 @@ int ompi_attr_delete_all(ompi_attribute_type_t type, void *object,
OMPI_THREAD_LOCK(&alock);
/* Get the first key in local object's key hash */
key_ret = ompi_hash_table_get_first_key_uint32(keyhash,
key_ret = opal_hash_table_get_first_key_uint32(keyhash,
&key, &old_attr,
&node);
del_ret = OMPI_SUCCESS;
@ -948,7 +948,7 @@ int ompi_attr_delete_all(ompi_attribute_type_t type, void *object,
/* Move to the next node */
key_ret = ompi_hash_table_get_next_key_uint32(keyhash,
key_ret = opal_hash_table_get_next_key_uint32(keyhash,
&key, &old_attr,
in_node, &node);
/* Now delete this attribute */
@ -968,7 +968,7 @@ int ompi_attr_delete_all(ompi_attribute_type_t type, void *object,
* Back-end function to set an attribute on an MPI object
*/
static int set_value(ompi_attribute_type_t type, void *object,
ompi_hash_table_t **keyhash, int key,
opal_hash_table_t **keyhash, int key,
attribute_value_t *new_attr,
bool predefined, bool need_lock)
{
@ -995,7 +995,7 @@ static int set_value(ompi_attribute_type_t type, void *object,
if (need_lock) {
OMPI_THREAD_LOCK(&alock);
}
ret = ompi_hash_table_get_value_uint32(keyval_hash, key,
ret = opal_hash_table_get_value_uint32(keyval_hash, key,
(void **) &key_item);
/* If key not found */
@ -1018,7 +1018,7 @@ static int set_value(ompi_attribute_type_t type, void *object,
/* Now see if the key is present in the object's key hash. If so,
delete the old attribute value. */
ret = ompi_hash_table_get_value_uint32(*keyhash, key, (void**) &old_attr);
ret = opal_hash_table_get_value_uint32(*keyhash, key, (void**) &old_attr);
if (OMPI_SUCCESS == ret) {
switch (type) {
case COMM_ATTR:
@ -1042,7 +1042,7 @@ static int set_value(ompi_attribute_type_t type, void *object,
OBJ_RELEASE(old_attr);
}
ret = ompi_hash_table_set_value_uint32(*keyhash, key, new_attr);
ret = opal_hash_table_set_value_uint32(*keyhash, key, new_attr);
if (need_lock) {
OMPI_THREAD_UNLOCK(&alock);
@ -1067,7 +1067,7 @@ static int set_value(ompi_attribute_type_t type, void *object,
* in small, standalone functions that are called from several
* different places.
*/
static int get_value(ompi_hash_table_t *keyhash, int key,
static int get_value(opal_hash_table_t *keyhash, int key,
attribute_value_t **attribute, int *flag)
{
int ret;
@ -1081,7 +1081,7 @@ static int get_value(ompi_hash_table_t *keyhash, int key,
*flag = 0;
OMPI_THREAD_LOCK(&alock);
ret = ompi_hash_table_get_value_uint32(keyval_hash, key,
ret = opal_hash_table_get_value_uint32(keyval_hash, key,
(void**) &key_item);
if (OMPI_ERR_NOT_FOUND == ret) {
@ -1097,7 +1097,7 @@ static int get_value(ompi_hash_table_t *keyhash, int key,
return OMPI_SUCCESS;
}
ret = ompi_hash_table_get_value_uint32(keyhash, key, &attr);
ret = opal_hash_table_get_value_uint32(keyhash, key, &attr);
OMPI_THREAD_UNLOCK(&alock);
if (OMPI_SUCCESS == ret) {
*attribute = attr;

28
ompi/attribute/attribute.h
Просмотреть файл

@ -30,7 +30,7 @@
#include "include/constants.h"
#include "opal/class/opal_object.h"
#include "class/ompi_bitmap.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#include "mca/gpr/gpr_types.h"
#define ATTR_HASH_SIZE 10
@ -167,14 +167,14 @@ typedef struct ompi_attrkey_item_t ompi_attrkey_item_t;
*/
static inline
int ompi_attr_hash_init(ompi_hash_table_t **keyhash)
int ompi_attr_hash_init(opal_hash_table_t **keyhash)
{
*keyhash = OBJ_NEW(ompi_hash_table_t);
*keyhash = OBJ_NEW(opal_hash_table_t);
if (NULL == keyhash) {
fprintf(stderr, "Error while creating the local attribute list\n");
return MPI_ERR_SYSRESOURCE;
}
if (OMPI_SUCCESS != ompi_hash_table_init(*keyhash, ATTR_HASH_SIZE)) {
if (OMPI_SUCCESS != opal_hash_table_init(*keyhash, ATTR_HASH_SIZE)) {
return MPI_ERR_SYSRESOURCE;
}
@ -274,7 +274,7 @@ int ompi_attr_free_keyval(ompi_attribute_type_t type, int *key,
* (read: better) this way.
*/
int ompi_attr_set_c(ompi_attribute_type_t type, void *object,
ompi_hash_table_t **keyhash,
opal_hash_table_t **keyhash,
int key, void *attribute, bool predefined, bool need_lock);
/**
@ -311,7 +311,7 @@ int ompi_attr_set_c(ompi_attribute_type_t type, void *object,
* (read: better) this way.
*/
int ompi_attr_set_fortran_mpi1(ompi_attribute_type_t type, void *object,
ompi_hash_table_t **keyhash,
opal_hash_table_t **keyhash,
int key, MPI_Fint attribute,
bool predefined, bool need_lock);
@ -349,7 +349,7 @@ int ompi_attr_set_fortran_mpi1(ompi_attribute_type_t type, void *object,
* (read: better) this way.
*/
int ompi_attr_set_fortran_mpi2(ompi_attribute_type_t type, void *object,
ompi_hash_table_t **keyhash,
opal_hash_table_t **keyhash,
int key, MPI_Aint attribute,
bool predefined, bool need_lock);
@ -375,7 +375,7 @@ int ompi_attr_set_fortran_mpi2(ompi_attribute_type_t type, void *object,
* (read: better) this way.
*/
int ompi_attr_get_c(ompi_hash_table_t *keyhash, int key,
int ompi_attr_get_c(opal_hash_table_t *keyhash, int key,
void **attribute, int *flag);
@ -402,7 +402,7 @@ int ompi_attr_get_c(ompi_hash_table_t *keyhash, int key,
* (read: better) this way.
*/
int ompi_attr_get_fortran_mpi1(ompi_hash_table_t *keyhash, int key,
int ompi_attr_get_fortran_mpi1(opal_hash_table_t *keyhash, int key,
MPI_Fint *attribute, int *flag);
@ -429,7 +429,7 @@ int ompi_attr_get_fortran_mpi1(ompi_hash_table_t *keyhash, int key,
* (read: better) this way.
*/
int ompi_attr_get_fortran_mpi2(ompi_hash_table_t *keyhash, int key,
int ompi_attr_get_fortran_mpi2(opal_hash_table_t *keyhash, int key,
MPI_Aint *attribute, int *flag);
@ -451,7 +451,7 @@ int ompi_attr_get_fortran_mpi2(ompi_hash_table_t *keyhash, int key,
*/
int ompi_attr_delete(ompi_attribute_type_t type, void *object,
ompi_hash_table_t *keyhash , int key,
opal_hash_table_t *keyhash , int key,
bool predefined, bool need_lock);
@ -469,8 +469,8 @@ int ompi_attr_delete(ompi_attribute_type_t type, void *object,
*/
int ompi_attr_copy_all(ompi_attribute_type_t type, void *old_object,
void *new_object, ompi_hash_table_t *oldkeyhash,
ompi_hash_table_t *newkeyhash);
void *new_object, opal_hash_table_t *oldkeyhash,
opal_hash_table_t *newkeyhash);
/**
@ -484,7 +484,7 @@ int ompi_attr_copy_all(ompi_attribute_type_t type, void *old_object,
*/
int ompi_attr_delete_all(ompi_attribute_type_t type, void *object,
ompi_hash_table_t *keyhash);
opal_hash_table_t *keyhash);
/**

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

@ -82,7 +82,7 @@ int ompi_comm_set ( ompi_communicator_t *newcomm,
ompi_proc_t **local_procs,
int remote_size,
ompi_proc_t **remote_procs,
ompi_hash_table_t *attr,
opal_hash_table_t *attr,
ompi_errhandler_t *errh,
mca_base_component_t *topocomponent )
{

6
ompi/communicator/communicator.h
Просмотреть файл

@ -18,7 +18,7 @@
#define OMPI_COMMUNICATOR_H
#include "opal/class/opal_object.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#include "errhandler/errhandler.h"
#include "threads/mutex.h"
@ -102,7 +102,7 @@ struct ompi_communicator_t {
ompi_group_t *c_remote_group;
/* Attributes */
ompi_hash_table_t *c_keyhash;
opal_hash_table_t *c_keyhash;
/**< inscribing cube dimension */
int c_cube_dim;
@ -342,7 +342,7 @@ struct ompi_communicator_t {
ompi_proc_t **local_procs,
int remote_size,
ompi_proc_t **remote_procs,
ompi_hash_table_t *attr,
opal_hash_table_t *attr,
ompi_errhandler_t *errh,
mca_base_component_t *topocomponent );
/**

4
ompi/datatype/datatype.h
Просмотреть файл

@ -36,7 +36,7 @@
#include <string.h>
#include "include/constants.h"
#include "opal/class/opal_object.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#include "class/ompi_pointer_array.h"
#include "mpi.h"
#if defined(c_plusplus) || defined(__cplusplus)
@ -101,7 +101,7 @@ typedef struct ompi_datatype_t {
uint64_t bdt_used; /**< which basic datatypes are used in the data description */
/* Attribute fields */
ompi_hash_table_t *d_keyhash;
opal_hash_table_t *d_keyhash;
int32_t d_f_to_c_index;
char name[MPI_MAX_OBJECT_NAME];
dt_type_desc_t desc; /**< the data description */

2
ompi/mca/btl/gm/btl_gm_proc.c
Просмотреть файл

@ -16,7 +16,7 @@
#include "ompi_config.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#include "mca/pml/base/pml_base_module_exchange.h"
#include "btl_gm.h"

2
ompi/mca/btl/mvapi/btl_mvapi_proc.c
Просмотреть файл

@ -16,7 +16,7 @@
#include "ompi_config.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#include "mca/pml/base/pml_base_module_exchange.h"
#include "btl_mvapi.h"

2
ompi/mca/btl/openib/btl_openib_proc.c
Просмотреть файл

@ -16,7 +16,7 @@
#include "ompi_config.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#include "mca/pml/base/pml_base_module_exchange.h"
#include "btl_openib.h"

2
ompi/mca/btl/template/btl_template_proc.c
Просмотреть файл

@ -16,7 +16,7 @@
#include "ompi_config.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#include "mca/pml/base/pml_base_module_exchange.h"
#include "btl_template.h"

2
ompi/mca/pml/base/pml_base_module_exchange.c
Просмотреть файл

@ -16,7 +16,7 @@
#include "ompi_config.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#include "threads/condition.h"
#include "util/output.h"
#include "util/proc_info.h"

2
ompi/mca/ptl/elan/src/ptl_elan_proc.c
Просмотреть файл

@ -19,7 +19,7 @@
#include <string.h>
#include "include/sys/atomic.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#include "mca/pml/base/pml_base_module_exchange.h"
#include "ptl_elan.h"
#include "ptl_elan_peer.h"

2
ompi/mca/ptl/gm/ptl_gm_proc.c
Просмотреть файл

@ -23,7 +23,7 @@
#include <string.h>
#include "include/sys/atomic.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#include "mca/pml/base/pml_base_module_exchange.h"
#include "ptl_gm.h"
#include "ptl_gm_peer.h"

2
ompi/mca/ptl/mx/ptl_mx.h
Просмотреть файл

@ -45,7 +45,7 @@ struct mca_ptl_mx_component_t {
struct mca_ptl_mx_module_t** mx_ptls; /**< array of available PTL moduless */
ompi_free_list_t mx_send_frags; /**< free list of mx send fragments */
ompi_free_list_t mx_recv_frags; /**< free list of mx recv fragments */
ompi_hash_table_t mx_procs; /**< hash table of procs */
opal_hash_table_t mx_procs; /**< hash table of procs */
opal_list_t mx_pending_acks; /**< queue of pending sends */
ompi_mutex_t mx_lock; /**< lock for accessing module state */
};

6
ompi/mca/ptl/mx/ptl_mx_component.c
Просмотреть файл

@ -98,8 +98,8 @@ int mca_ptl_mx_component_open(void)
OBJ_CONSTRUCT(&mca_ptl_mx_component.mx_lock, ompi_mutex_t);
OBJ_CONSTRUCT(&mca_ptl_mx_component.mx_send_frags, ompi_free_list_t);
OBJ_CONSTRUCT(&mca_ptl_mx_component.mx_recv_frags, ompi_free_list_t);
OBJ_CONSTRUCT(&mca_ptl_mx_component.mx_procs, ompi_hash_table_t);
OBJ_CONSTRUCT(&mca_ptl_mx_component.mx_pending_acks, ompi_hash_table_t);
OBJ_CONSTRUCT(&mca_ptl_mx_component.mx_procs, opal_hash_table_t);
OBJ_CONSTRUCT(&mca_ptl_mx_component.mx_pending_acks, opal_hash_table_t);
/* register MX module parameters */
mca_ptl_mx_component.mx_filter =
@ -190,7 +190,7 @@ mca_ptl_base_module_t** mca_ptl_mx_component_init(
NULL); /* use default allocator */
/* intialize process hash table */
ompi_hash_table_init(&mca_ptl_mx_component.mx_procs, 256);
opal_hash_table_init(&mca_ptl_mx_component.mx_procs, 256);
/* initialize mx ptls */
if(OMPI_SUCCESS != mca_ptl_mx_module_init())

8
ompi/mca/ptl/mx/ptl_mx_proc.c
Просмотреть файл

@ -60,7 +60,7 @@ void mca_ptl_mx_proc_destruct(mca_ptl_mx_proc_t* proc)
{
/* remove from list of all proc instances */
OMPI_THREAD_LOCK(&mca_ptl_mx_component.mx_lock);
ompi_hash_table_remove_proc(&mca_ptl_mx_component.mx_procs, &proc->proc_name);
opal_hash_table_remove_proc(&mca_ptl_mx_component.mx_procs, &proc->proc_name);
OMPI_THREAD_UNLOCK(&mca_ptl_mx_component.mx_lock);
/* release resources */
@ -83,7 +83,7 @@ mca_ptl_mx_proc_t* mca_ptl_mx_proc_create(ompi_proc_t* ompi_proc)
mca_ptl_mx_proc_t* ptl_proc;
OMPI_THREAD_LOCK(&mca_ptl_mx_component.mx_lock);
ptl_proc = (mca_ptl_mx_proc_t*)ompi_hash_table_get_proc(
ptl_proc = (mca_ptl_mx_proc_t*)opal_hash_table_get_proc(
&mca_ptl_mx_component.mx_procs, &ompi_proc->proc_name);
if(NULL != ptl_proc) {
OMPI_THREAD_UNLOCK(&mca_ptl_mx_component.mx_lock);
@ -97,7 +97,7 @@ mca_ptl_mx_proc_t* mca_ptl_mx_proc_create(ompi_proc_t* ompi_proc)
ptl_proc->proc_name = ompi_proc->proc_name;
/* add to hash table of all proc instance */
ompi_hash_table_set_proc(
opal_hash_table_set_proc(
&mca_ptl_mx_component.mx_procs,
&ptl_proc->proc_name,
ptl_proc);
@ -139,7 +139,7 @@ mca_ptl_mx_proc_t* mca_ptl_mx_proc_lookup(const ompi_process_name_t *name)
{
mca_ptl_mx_proc_t* proc;
OMPI_THREAD_LOCK(&mca_ptl_mx_component.mx_lock);
proc = (mca_ptl_mx_proc_t*)ompi_hash_table_get_proc(
proc = (mca_ptl_mx_proc_t*)opal_hash_table_get_proc(
&mca_ptl_mx_component.mx_procs, name);
OMPI_THREAD_UNLOCK(&mca_ptl_mx_component.mx_lock);
return proc;

2
ompi/mca/ptl/tcp/ptl_tcp.h
Просмотреть файл

@ -59,7 +59,7 @@ struct mca_ptl_tcp_component_t {
size_t tcp_frag_size; /**< buffer limit for the TCP PTL */
ompi_free_list_t tcp_send_frags; /**< free list of tcp send fragments */
ompi_free_list_t tcp_recv_frags; /**< free list of tcp recv fragments */
ompi_hash_table_t tcp_procs; /**< hash table of tcp proc structures */
opal_hash_table_t tcp_procs; /**< hash table of tcp proc structures */
opal_list_t tcp_pending_acks; /**< list of pending acks - retry as sends complete */
opal_list_t tcp_events; /**< list of pending events */
struct mca_ptl_tcp_proc_t* tcp_local; /**< the tcp proc instance corresponding to the local process */

6
ompi/mca/ptl/tcp/ptl_tcp_component.c
Просмотреть файл

@ -178,12 +178,12 @@ int mca_ptl_tcp_component_open(void)
/* initialize objects */
OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_lock, ompi_mutex_t);
OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_procs, ompi_hash_table_t);
OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_procs, opal_hash_table_t);
OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_pending_acks, opal_list_t);
OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_events, opal_list_t);
OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_send_frags, ompi_free_list_t);
OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_recv_frags, ompi_free_list_t);
ompi_hash_table_init(&mca_ptl_tcp_component.tcp_procs, 256);
opal_hash_table_init(&mca_ptl_tcp_component.tcp_procs, 256);
/* register TCP module parameters */
mca_ptl_tcp_component.tcp_if_include =
@ -538,7 +538,7 @@ int mca_ptl_tcp_component_control(int param, void* value, size_t size)
case MCA_PTL_ENABLE:
if(*(int*)value) {
ompi_event_add(&mca_ptl_tcp_component.tcp_recv_event, 0);
if(ompi_hash_table_get_size(&mca_ptl_tcp_component.tcp_procs) > 0) {
if(opal_hash_table_get_size(&mca_ptl_tcp_component.tcp_procs) > 0) {
ompi_progress_events(OMPI_EVLOOP_NONBLOCK);
}
} else {

8
ompi/mca/ptl/tcp/ptl_tcp_proc.c
Просмотреть файл

@ -62,7 +62,7 @@ void mca_ptl_tcp_proc_destruct(mca_ptl_tcp_proc_t* proc)
{
/* remove from list of all proc instances */
OMPI_THREAD_LOCK(&mca_ptl_tcp_component.tcp_lock);
ompi_hash_table_remove_proc(&mca_ptl_tcp_component.tcp_procs, &proc->proc_name);
opal_hash_table_remove_proc(&mca_ptl_tcp_component.tcp_procs, &proc->proc_name);
OMPI_THREAD_UNLOCK(&mca_ptl_tcp_component.tcp_lock);
/* release resources */
@ -86,7 +86,7 @@ mca_ptl_tcp_proc_t* mca_ptl_tcp_proc_create(ompi_proc_t* ompi_proc)
mca_ptl_tcp_proc_t* ptl_proc;
OMPI_THREAD_LOCK(&mca_ptl_tcp_component.tcp_lock);
ptl_proc = (mca_ptl_tcp_proc_t*)ompi_hash_table_get_proc(
ptl_proc = (mca_ptl_tcp_proc_t*)opal_hash_table_get_proc(
&mca_ptl_tcp_component.tcp_procs, &ompi_proc->proc_name);
if(NULL != ptl_proc) {
OMPI_THREAD_UNLOCK(&mca_ptl_tcp_component.tcp_lock);
@ -100,7 +100,7 @@ mca_ptl_tcp_proc_t* mca_ptl_tcp_proc_create(ompi_proc_t* ompi_proc)
ptl_proc->proc_name = ompi_proc->proc_name;
/* add to hash table of all proc instance */
ompi_hash_table_set_proc(
opal_hash_table_set_proc(
&mca_ptl_tcp_component.tcp_procs,
&ptl_proc->proc_name,
ptl_proc);
@ -143,7 +143,7 @@ mca_ptl_tcp_proc_t* mca_ptl_tcp_proc_lookup(const orte_process_name_t *name)
{
mca_ptl_tcp_proc_t* proc;
OMPI_THREAD_LOCK(&mca_ptl_tcp_component.tcp_lock);
proc = (mca_ptl_tcp_proc_t*)ompi_hash_table_get_proc(
proc = (mca_ptl_tcp_proc_t*)opal_hash_table_get_proc(
&mca_ptl_tcp_component.tcp_procs, name);
OMPI_THREAD_UNLOCK(&mca_ptl_tcp_component.tcp_lock);
return proc;

4
ompi/win/win.h
Просмотреть файл

@ -21,7 +21,7 @@
#include "mpi.h"
#include "errhandler/errhandler.h"
#include "opal/class/opal_object.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#if defined(c_plusplus) || defined(__cplusplus)
extern "C" {
#endif
@ -35,7 +35,7 @@ struct ompi_win_t {
/* Attributes */
ompi_hash_table_t *w_keyhash;
opal_hash_table_t *w_keyhash;
/* index in Fortran <-> C translation array */

4
opal/class/Makefile.am
Просмотреть файл

@ -23,7 +23,7 @@ noinst_LTLIBRARIES = libclass.la
headers = \
opal_free_list.h \
ompi_hash_table.h \
opal_hash_table.h \
opal_list.h \
opal_object.h \
opal_value_array.h
@ -31,7 +31,7 @@ headers = \
libclass_la_SOURCES = \
$(headers) \
opal_free_list.c \
ompi_hash_table.c \
opal_hash_table.c \
opal_list.c \
opal_object.c \
opal_value_array.c

222
opal/class/ompi_hash_table.c → opal/class/opal_hash_table.c
Просмотреть файл

@ -22,27 +22,27 @@
#include "include/constants.h"
#include "util/output.h"
#include "opal/class/opal_list.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
/*
* ompi_hash_table_t
* opal_hash_table_t
*/
#define HASH_MULTIPLIER 31
static void ompi_hash_table_construct(ompi_hash_table_t* ht);
static void ompi_hash_table_destruct(ompi_hash_table_t* ht);
static void opal_hash_table_construct(opal_hash_table_t* ht);
static void opal_hash_table_destruct(opal_hash_table_t* ht);
OBJ_CLASS_INSTANCE(
ompi_hash_table_t,
opal_hash_table_t,
opal_object_t,
ompi_hash_table_construct,
ompi_hash_table_destruct
opal_hash_table_construct,
opal_hash_table_destruct
);
static void ompi_hash_table_construct(ompi_hash_table_t* ht)
static void opal_hash_table_construct(opal_hash_table_t* ht)
{
OBJ_CONSTRUCT(&ht->ht_nodes, opal_list_t);
ht->ht_table = NULL;
@ -51,10 +51,10 @@ static void ompi_hash_table_construct(ompi_hash_table_t* ht)
}
static void ompi_hash_table_destruct(ompi_hash_table_t* ht)
static void opal_hash_table_destruct(opal_hash_table_t* ht)
{
size_t i;
ompi_hash_table_remove_all(ht);
opal_hash_table_remove_all(ht);
for(i=0; i<ht->ht_table_size; i++) {
OBJ_DESTRUCT(ht->ht_table+i);
}
@ -65,7 +65,7 @@ static void ompi_hash_table_destruct(ompi_hash_table_t* ht)
}
int ompi_hash_table_init(ompi_hash_table_t* ht, size_t table_size)
int opal_hash_table_init(opal_hash_table_t* ht, size_t table_size)
{
size_t i;
size_t power2 = 1;
@ -88,7 +88,7 @@ int ompi_hash_table_init(ompi_hash_table_t* ht, size_t table_size)
return OMPI_SUCCESS;
}
int ompi_hash_table_remove_all(ompi_hash_table_t* ht)
int opal_hash_table_remove_all(opal_hash_table_t* ht)
{
size_t i;
for(i=0; i<ht->ht_table_size; i++) {
@ -110,39 +110,39 @@ int ompi_hash_table_remove_all(ompi_hash_table_t* ht)
/***************************************************************************/
/*
* ompi_uint32_hash_node_t
* opal_uint32_hash_node_t
*/
struct ompi_uint32_hash_node_t
struct opal_uint32_hash_node_t
{
opal_list_item_t super;
uint32_t hn_key;
void *hn_value;
};
typedef struct ompi_uint32_hash_node_t ompi_uint32_hash_node_t;
typedef struct opal_uint32_hash_node_t opal_uint32_hash_node_t;
static OBJ_CLASS_INSTANCE(ompi_uint32_hash_node_t,
static OBJ_CLASS_INSTANCE(opal_uint32_hash_node_t,
opal_list_item_t,
NULL,
NULL);
int ompi_hash_table_get_value_uint32(ompi_hash_table_t* ht, uint32_t key,
int opal_hash_table_get_value_uint32(opal_hash_table_t* ht, uint32_t key,
void **ptr)
{
opal_list_t* list = ht->ht_table + (key & ht->ht_mask);
ompi_uint32_hash_node_t *node;
opal_uint32_hash_node_t *node;
#if OMPI_ENABLE_DEBUG
if(ht->ht_table_size == 0) {
ompi_output(0, "ompi_hash_table_get_value_uint32:"
"ompi_hash_table_init() has not been called");
ompi_output(0, "opal_hash_table_get_value_uint32:"
"opal_hash_table_init() has not been called");
return OMPI_ERROR;
}
#endif
for(node = (ompi_uint32_hash_node_t*)opal_list_get_first(list);
node != (ompi_uint32_hash_node_t*)opal_list_get_end(list);
node = (ompi_uint32_hash_node_t*)opal_list_get_next(node)) {
for(node = (opal_uint32_hash_node_t*)opal_list_get_first(list);
node != (opal_uint32_hash_node_t*)opal_list_get_end(list);
node = (opal_uint32_hash_node_t*)opal_list_get_next(node)) {
if (node->hn_key == key) {
*ptr = node->hn_value;
return OMPI_SUCCESS;
@ -152,31 +152,31 @@ int ompi_hash_table_get_value_uint32(ompi_hash_table_t* ht, uint32_t key,
}
int ompi_hash_table_set_value_uint32(ompi_hash_table_t* ht,
int opal_hash_table_set_value_uint32(opal_hash_table_t* ht,
uint32_t key, void* value)
{
opal_list_t* list = ht->ht_table + (key & ht->ht_mask);
ompi_uint32_hash_node_t *node;
opal_uint32_hash_node_t *node;
#if OMPI_ENABLE_DEBUG
if(ht->ht_table_size == 0) {
ompi_output(0, "ompi_hash_table_set_value_uint32:"
"ompi_hash_table_init() has not been called");
ompi_output(0, "opal_hash_table_set_value_uint32:"
"opal_hash_table_init() has not been called");
return OMPI_ERR_BAD_PARAM;
}
#endif
for(node = (ompi_uint32_hash_node_t*)opal_list_get_first(list);
node != (ompi_uint32_hash_node_t*)opal_list_get_end(list);
node = (ompi_uint32_hash_node_t*)opal_list_get_next(node)) {
for(node = (opal_uint32_hash_node_t*)opal_list_get_first(list);
node != (opal_uint32_hash_node_t*)opal_list_get_end(list);
node = (opal_uint32_hash_node_t*)opal_list_get_next(node)) {
if (node->hn_key == key) {
node->hn_value = value;
return OMPI_SUCCESS;
}
}
node = (ompi_uint32_hash_node_t*)opal_list_remove_first(&ht->ht_nodes);
node = (opal_uint32_hash_node_t*)opal_list_remove_first(&ht->ht_nodes);
if(NULL == node) {
node = OBJ_NEW(ompi_uint32_hash_node_t);
node = OBJ_NEW(opal_uint32_hash_node_t);
if(NULL == node)
return OMPI_ERR_OUT_OF_RESOURCE;
}
@ -188,21 +188,21 @@ int ompi_hash_table_set_value_uint32(ompi_hash_table_t* ht,
}
int ompi_hash_table_remove_value_uint32(ompi_hash_table_t* ht, uint32_t key)
int opal_hash_table_remove_value_uint32(opal_hash_table_t* ht, uint32_t key)
{
opal_list_t* list = ht->ht_table + (key & ht->ht_mask);
ompi_uint32_hash_node_t *node;
opal_uint32_hash_node_t *node;
#if OMPI_ENABLE_DEBUG
if(ht->ht_table_size == 0) {
ompi_output(0, "ompi_hash_table_remove_value_uint32:"
"ompi_hash_table_init() has not been called");
ompi_output(0, "opal_hash_table_remove_value_uint32:"
"opal_hash_table_init() has not been called");
return OMPI_ERR_BAD_PARAM;
}
#endif
for(node = (ompi_uint32_hash_node_t*)opal_list_get_first(list);
node != (ompi_uint32_hash_node_t*)opal_list_get_end(list);
node = (ompi_uint32_hash_node_t*)opal_list_get_next(node)) {
for(node = (opal_uint32_hash_node_t*)opal_list_get_first(list);
node != (opal_uint32_hash_node_t*)opal_list_get_end(list);
node = (opal_uint32_hash_node_t*)opal_list_get_next(node)) {
if (node->hn_key == key) {
opal_list_remove_item(list, (opal_list_item_t*)node);
opal_list_append(&ht->ht_nodes, (opal_list_item_t*)node);
@ -216,39 +216,39 @@ int ompi_hash_table_remove_value_uint32(ompi_hash_table_t* ht, uint32_t key)
/***************************************************************************/
/*
* ompi_uint64_hash_node_t
* opal_uint64_hash_node_t
*/
struct ompi_uint64_hash_node_t
struct opal_uint64_hash_node_t
{
opal_list_item_t super;
uint64_t hn_key;
void* hn_value;
};
typedef struct ompi_uint64_hash_node_t ompi_uint64_hash_node_t;
typedef struct opal_uint64_hash_node_t opal_uint64_hash_node_t;
static OBJ_CLASS_INSTANCE(ompi_uint64_hash_node_t,
static OBJ_CLASS_INSTANCE(opal_uint64_hash_node_t,
opal_list_item_t,
NULL,
NULL);
int ompi_hash_table_get_value_uint64(ompi_hash_table_t* ht, uint64_t key,
int opal_hash_table_get_value_uint64(opal_hash_table_t* ht, uint64_t key,
void **ptr)
{
opal_list_t* list = ht->ht_table + (key & ht->ht_mask);
ompi_uint64_hash_node_t *node;
opal_uint64_hash_node_t *node;
#if OMPI_ENABLE_DEBUG
if(ht->ht_table_size == 0) {
ompi_output(0, "ompi_hash_table_get_value_uint64:"
"ompi_hash_table_init() has not been called");
ompi_output(0, "opal_hash_table_get_value_uint64:"
"opal_hash_table_init() has not been called");
return OMPI_ERROR;
}
#endif
for(node = (ompi_uint64_hash_node_t*)opal_list_get_first(list);
node != (ompi_uint64_hash_node_t*)opal_list_get_end(list);
node = (ompi_uint64_hash_node_t*)opal_list_get_next(node)) {
for(node = (opal_uint64_hash_node_t*)opal_list_get_first(list);
node != (opal_uint64_hash_node_t*)opal_list_get_end(list);
node = (opal_uint64_hash_node_t*)opal_list_get_next(node)) {
if (node->hn_key == key) {
*ptr = node->hn_value;
return OMPI_SUCCESS;
@ -258,31 +258,31 @@ int ompi_hash_table_get_value_uint64(ompi_hash_table_t* ht, uint64_t key,
}
int ompi_hash_table_set_value_uint64(ompi_hash_table_t* ht,
int opal_hash_table_set_value_uint64(opal_hash_table_t* ht,
uint64_t key, void* value)
{
opal_list_t* list = ht->ht_table + (key & ht->ht_mask);
ompi_uint64_hash_node_t *node;
opal_uint64_hash_node_t *node;
#if OMPI_ENABLE_DEBUG
if(ht->ht_table_size == 0) {
ompi_output(0, "ompi_hash_table_set_value_uint64:"
"ompi_hash_table_init() has not been called");
ompi_output(0, "opal_hash_table_set_value_uint64:"
"opal_hash_table_init() has not been called");
return OMPI_ERR_BAD_PARAM;
}
#endif
for(node = (ompi_uint64_hash_node_t*)opal_list_get_first(list);
node != (ompi_uint64_hash_node_t*)opal_list_get_end(list);
node = (ompi_uint64_hash_node_t*)opal_list_get_next(node)) {
for(node = (opal_uint64_hash_node_t*)opal_list_get_first(list);
node != (opal_uint64_hash_node_t*)opal_list_get_end(list);
node = (opal_uint64_hash_node_t*)opal_list_get_next(node)) {
if (node->hn_key == key) {
node->hn_value = value;
return OMPI_SUCCESS;
}
}
node = (ompi_uint64_hash_node_t*)opal_list_remove_first(&ht->ht_nodes);
node = (opal_uint64_hash_node_t*)opal_list_remove_first(&ht->ht_nodes);
if(NULL == node) {
node = OBJ_NEW(ompi_uint64_hash_node_t);
node = OBJ_NEW(opal_uint64_hash_node_t);
if(NULL == node) {
return OMPI_ERR_OUT_OF_RESOURCE;
}
@ -295,21 +295,21 @@ int ompi_hash_table_set_value_uint64(ompi_hash_table_t* ht,
}
int ompi_hash_table_remove_value_uint64(ompi_hash_table_t* ht, uint64_t key)
int opal_hash_table_remove_value_uint64(opal_hash_table_t* ht, uint64_t key)
{
opal_list_t* list = ht->ht_table + (key & ht->ht_mask);
ompi_uint64_hash_node_t *node;
opal_uint64_hash_node_t *node;
#if OMPI_ENABLE_DEBUG
if(ht->ht_table_size == 0) {
ompi_output(0, "ompi_hash_table_remove_value_uint64:"
"ompi_hash_table_init() has not been called");
ompi_output(0, "opal_hash_table_remove_value_uint64:"
"opal_hash_table_init() has not been called");
return OMPI_ERR_BAD_PARAM;
}
#endif
for(node = (ompi_uint64_hash_node_t*)opal_list_get_first(list);
node != (ompi_uint64_hash_node_t*)opal_list_get_end(list);
node = (ompi_uint64_hash_node_t*)opal_list_get_next(node)) {
for(node = (opal_uint64_hash_node_t*)opal_list_get_first(list);
node != (opal_uint64_hash_node_t*)opal_list_get_end(list);
node = (opal_uint64_hash_node_t*)opal_list_get_next(node)) {
if (node->hn_key == key) {
opal_list_remove_item(list, (opal_list_item_t*)node);
opal_list_append(&ht->ht_nodes, (opal_list_item_t*)node);
@ -323,36 +323,36 @@ int ompi_hash_table_remove_value_uint64(ompi_hash_table_t* ht, uint64_t key)
/***************************************************************************/
/*
* ompi_ptr_hash_node_t
* opal_ptr_hash_node_t
*/
struct ompi_ptr_hash_node_t
struct opal_ptr_hash_node_t
{
opal_list_item_t super;
void* hn_key;
size_t hn_key_size;
void* hn_value;
};
typedef struct ompi_ptr_hash_node_t ompi_ptr_hash_node_t;
typedef struct opal_ptr_hash_node_t opal_ptr_hash_node_t;
static void ompi_ptr_hash_node_construct(ompi_ptr_hash_node_t* hn)
static void opal_ptr_hash_node_construct(opal_ptr_hash_node_t* hn)
{
hn->hn_key_size = 0;
hn->hn_key = NULL;
hn->hn_value = NULL;
}
static void ompi_ptr_hash_node_destruct(ompi_ptr_hash_node_t* hn)
static void opal_ptr_hash_node_destruct(opal_ptr_hash_node_t* hn)
{
if(NULL != hn->hn_key) {
free(hn->hn_key);
}
}
static OBJ_CLASS_INSTANCE(ompi_ptr_hash_node_t,
static OBJ_CLASS_INSTANCE(opal_ptr_hash_node_t,
opal_list_item_t,
ompi_ptr_hash_node_construct,
ompi_ptr_hash_node_destruct);
opal_ptr_hash_node_construct,
opal_ptr_hash_node_destruct);
static inline uint32_t ompi_hash_value(size_t mask, const void *key,
@ -368,23 +368,23 @@ static inline uint32_t ompi_hash_value(size_t mask, const void *key,
return (h & mask);
}
int ompi_hash_table_get_value_ptr(ompi_hash_table_t* ht, const void* key,
int opal_hash_table_get_value_ptr(opal_hash_table_t* ht, const void* key,
size_t key_size, void **ptr)
{
opal_list_t* list = ht->ht_table + ompi_hash_value(ht->ht_mask, key,
key_size);
ompi_ptr_hash_node_t *node;
opal_ptr_hash_node_t *node;
#if OMPI_ENABLE_DEBUG
if(ht->ht_table_size == 0) {
ompi_output(0, "ompi_hash_table_get_value_ptr:"
"ompi_hash_table_init() has not been called");
ompi_output(0, "opal_hash_table_get_value_ptr:"
"opal_hash_table_init() has not been called");
return OMPI_ERROR;
}
#endif
for(node = (ompi_ptr_hash_node_t*)opal_list_get_first(list);
node != (ompi_ptr_hash_node_t*)opal_list_get_end(list);
node = (ompi_ptr_hash_node_t*)opal_list_get_next(node)) {
for(node = (opal_ptr_hash_node_t*)opal_list_get_first(list);
node != (opal_ptr_hash_node_t*)opal_list_get_end(list);
node = (opal_ptr_hash_node_t*)opal_list_get_next(node)) {
if (node->hn_key_size == key_size &&
memcmp(node->hn_key, key, key_size) == 0) {
*ptr = node->hn_value;
@ -395,23 +395,23 @@ int ompi_hash_table_get_value_ptr(ompi_hash_table_t* ht, const void* key,
}
int ompi_hash_table_set_value_ptr(ompi_hash_table_t* ht, const void* key,
int opal_hash_table_set_value_ptr(opal_hash_table_t* ht, const void* key,
size_t key_size, void* value)
{
opal_list_t* list = ht->ht_table + ompi_hash_value(ht->ht_mask, key,
key_size);
ompi_ptr_hash_node_t *node;
opal_ptr_hash_node_t *node;
#if OMPI_ENABLE_DEBUG
if(ht->ht_table_size == 0) {
ompi_output(0, "ompi_hash_table_set_value_ptr:"
"ompi_hash_table_init() has not been called");
ompi_output(0, "opal_hash_table_set_value_ptr:"
"opal_hash_table_init() has not been called");
return OMPI_ERR_BAD_PARAM;
}
#endif
for(node = (ompi_ptr_hash_node_t*)opal_list_get_first(list);
node != (ompi_ptr_hash_node_t*)opal_list_get_end(list);
node = (ompi_ptr_hash_node_t*)opal_list_get_next(node)) {
for(node = (opal_ptr_hash_node_t*)opal_list_get_first(list);
node != (opal_ptr_hash_node_t*)opal_list_get_end(list);
node = (opal_ptr_hash_node_t*)opal_list_get_next(node)) {
if (node->hn_key_size == key_size &&
memcmp(node->hn_key, key, key_size) == 0) {
node->hn_value = value;
@ -419,9 +419,9 @@ int ompi_hash_table_set_value_ptr(ompi_hash_table_t* ht, const void* key,
}
}
node = (ompi_ptr_hash_node_t*)opal_list_remove_first(&ht->ht_nodes);
node = (opal_ptr_hash_node_t*)opal_list_remove_first(&ht->ht_nodes);
if(NULL == node) {
node = OBJ_NEW(ompi_ptr_hash_node_t);
node = OBJ_NEW(opal_ptr_hash_node_t);
if(NULL == node) {
return OMPI_ERR_OUT_OF_RESOURCE;
}
@ -436,23 +436,23 @@ int ompi_hash_table_set_value_ptr(ompi_hash_table_t* ht, const void* key,
}
int ompi_hash_table_remove_value_ptr(ompi_hash_table_t* ht,
int opal_hash_table_remove_value_ptr(opal_hash_table_t* ht,
const void* key, size_t key_size)
{
opal_list_t* list = ht->ht_table + ompi_hash_value(ht->ht_mask,
key, key_size);
ompi_ptr_hash_node_t *node;
opal_ptr_hash_node_t *node;
#if OMPI_ENABLE_DEBUG
if(ht->ht_table_size == 0) {
ompi_output(0, "ompi_hash_table_remove_value_ptr: "
"ompi_hash_table_init() has not been called");
ompi_output(0, "opal_hash_table_remove_value_ptr: "
"opal_hash_table_init() has not been called");
return OMPI_ERR_BAD_PARAM;
}
#endif
for(node = (ompi_ptr_hash_node_t*)opal_list_get_first(list);
node != (ompi_ptr_hash_node_t*)opal_list_get_end(list);
node = (ompi_ptr_hash_node_t*)opal_list_get_next(node)) {
for(node = (opal_ptr_hash_node_t*)opal_list_get_first(list);
node != (opal_ptr_hash_node_t*)opal_list_get_end(list);
node = (opal_ptr_hash_node_t*)opal_list_get_next(node)) {
if (node->hn_key_size == key_size &&
memcmp(node->hn_key, key, key_size) == 0) {
free(node->hn_key);
@ -469,18 +469,18 @@ int ompi_hash_table_remove_value_ptr(ompi_hash_table_t* ht,
int
ompi_hash_table_get_first_key_uint32(ompi_hash_table_t *ht, uint32_t *key,
opal_hash_table_get_first_key_uint32(opal_hash_table_t *ht, uint32_t *key,
void **value, void **node)
{
size_t i;
ompi_uint32_hash_node_t *list_node;
opal_uint32_hash_node_t *list_node;
/* Go through all the lists and return the first element off the
first non-empty list */
for (i = 0; i < ht->ht_table_size; ++i) {
if (opal_list_get_size(ht->ht_table + i) > 0) {
list_node = (ompi_uint32_hash_node_t*)
list_node = (opal_uint32_hash_node_t*)
opal_list_get_first(ht->ht_table + i);
*node = list_node;
*key = list_node->hn_key;
@ -496,19 +496,19 @@ ompi_hash_table_get_first_key_uint32(ompi_hash_table_t *ht, uint32_t *key,
int
ompi_hash_table_get_next_key_uint32(ompi_hash_table_t *ht, uint32_t *key,
opal_hash_table_get_next_key_uint32(opal_hash_table_t *ht, uint32_t *key,
void **value, void *in_node,
void **out_node)
{
size_t i;
opal_list_t *list;
opal_list_item_t *item;
ompi_uint32_hash_node_t *next;
opal_uint32_hash_node_t *next;
/* Try to simply get the next value in the list. If there isn't
one, find the next non-empty list and take the first value */
next = (ompi_uint32_hash_node_t*) in_node;
next = (opal_uint32_hash_node_t*) in_node;
list = ht->ht_table + (next->hn_key & ht->ht_mask);
item = opal_list_get_next(next);
if (opal_list_get_end(list) == item) {
@ -532,7 +532,7 @@ ompi_hash_table_get_next_key_uint32(ompi_hash_table_t *ht, uint32_t *key,
typecasting) */
*out_node = (void *) item;
next = (ompi_uint32_hash_node_t *) *out_node;
next = (opal_uint32_hash_node_t *) *out_node;
*key = next->hn_key;
*value = next->hn_value;
@ -541,18 +541,18 @@ ompi_hash_table_get_next_key_uint32(ompi_hash_table_t *ht, uint32_t *key,
int
ompi_hash_table_get_first_key_uint64(ompi_hash_table_t *ht, uint64_t *key,
opal_hash_table_get_first_key_uint64(opal_hash_table_t *ht, uint64_t *key,
void **value, void **node)
{
size_t i;
ompi_uint64_hash_node_t *list_node;
opal_uint64_hash_node_t *list_node;
/* Go through all the lists and return the first element off the
first non-empty list */
for (i = 0; i < ht->ht_table_size; ++i) {
if (opal_list_get_size(ht->ht_table + i) > 0) {
list_node = (ompi_uint64_hash_node_t*)
list_node = (opal_uint64_hash_node_t*)
opal_list_get_first(ht->ht_table + i);
*node = list_node;
*key = list_node->hn_key;
@ -568,19 +568,19 @@ ompi_hash_table_get_first_key_uint64(ompi_hash_table_t *ht, uint64_t *key,
int
ompi_hash_table_get_next_key_uint64(ompi_hash_table_t *ht, uint64_t *key,
opal_hash_table_get_next_key_uint64(opal_hash_table_t *ht, uint64_t *key,
void **value, void *in_node,
void **out_node)
{
size_t i;
opal_list_t *list;
opal_list_item_t *item;
ompi_uint64_hash_node_t *next;
opal_uint64_hash_node_t *next;
/* Try to simply get the next value in the list. If there isn't
one, find the next non-empty list and take the first value */
next = (ompi_uint64_hash_node_t*) in_node;
next = (opal_uint64_hash_node_t*) in_node;
list = ht->ht_table + (next->hn_key & ht->ht_mask);
item = opal_list_get_next(next);
if (opal_list_get_end(list) == item) {
@ -604,7 +604,7 @@ ompi_hash_table_get_next_key_uint64(ompi_hash_table_t *ht, uint64_t *key,
typecasting) */
*out_node = (void *) item;
next = (ompi_uint64_hash_node_t *) *out_node;
next = (opal_uint64_hash_node_t *) *out_node;
*key = next->hn_key;
*value = next->hn_value;

44
opal/class/ompi_hash_table.h → opal/class/opal_hash_table.h
Просмотреть файл

@ -23,8 +23,8 @@
* concurrently.
*/
#ifndef OMPI_HASH_TABLE_H
#define OMPI_HASH_TABLE_H
#ifndef OPAL_HASH_TABLE_H
#define OPAL_HASH_TABLE_H
#include "ompi_config.h"
#include "include/types.h"
@ -34,10 +34,10 @@
extern "C" {
#endif
OMPI_DECLSPEC extern opal_class_t ompi_hash_table_t_class;
OMPI_DECLSPEC extern opal_class_t opal_hash_table_t_class;
struct ompi_hash_table_t
struct opal_hash_table_t
{
opal_object_t super; /**< subclass of opal_object_t */
opal_list_t ht_nodes; /**< free list of hash nodes */
@ -46,7 +46,7 @@ struct ompi_hash_table_t
size_t ht_size; /**< number of values on table */
size_t ht_mask;
};
typedef struct ompi_hash_table_t ompi_hash_table_t;
typedef struct opal_hash_table_t opal_hash_table_t;
@ -61,7 +61,7 @@ typedef struct ompi_hash_table_t ompi_hash_table_t;
*
*/
OMPI_DECLSPEC int ompi_hash_table_init(ompi_hash_table_t* ht, size_t table_size);
OMPI_DECLSPEC int opal_hash_table_init(opal_hash_table_t* ht, size_t table_size);
/**
@ -72,7 +72,7 @@ OMPI_DECLSPEC int ompi_hash_table_init(ompi_hash_table_t* ht, size_t table_size)
*
*/
static inline size_t ompi_hash_table_get_size(ompi_hash_table_t *ht)
static inline size_t opal_hash_table_get_size(opal_hash_table_t *ht)
{
return ht->ht_size;
}
@ -85,7 +85,7 @@ static inline size_t ompi_hash_table_get_size(ompi_hash_table_t *ht)
*
*/
OMPI_DECLSPEC int ompi_hash_table_remove_all(ompi_hash_table_t *ht);
OMPI_DECLSPEC int opal_hash_table_remove_all(opal_hash_table_t *ht);
/**
* Retrieve value via uint32_t key.
@ -100,7 +100,7 @@ OMPI_DECLSPEC int ompi_hash_table_remove_all(ompi_hash_table_t *ht);
*
*/
OMPI_DECLSPEC int ompi_hash_table_get_value_uint32(ompi_hash_table_t* table, uint32_t key,
OMPI_DECLSPEC int opal_hash_table_get_value_uint32(opal_hash_table_t* table, uint32_t key,
void** ptr);
/**
@ -113,7 +113,7 @@ OMPI_DECLSPEC int ompi_hash_table_get_value_uint32(ompi_hash_table_t* table, uin
*
*/
OMPI_DECLSPEC int ompi_hash_table_set_value_uint32(ompi_hash_table_t* table, uint32_t key, void* value);
OMPI_DECLSPEC int opal_hash_table_set_value_uint32(opal_hash_table_t* table, uint32_t key, void* value);
/**
* Remove value based on uint32_t key.
@ -124,7 +124,7 @@ OMPI_DECLSPEC int ompi_hash_table_set_value_uint32(ompi_hash_table_t* table, uin
*
*/
OMPI_DECLSPEC int ompi_hash_table_remove_value_uint32(ompi_hash_table_t* table, uint32_t key);
OMPI_DECLSPEC int opal_hash_table_remove_value_uint32(opal_hash_table_t* table, uint32_t key);
/**
* Retrieve value via uint64_t key.
@ -139,7 +139,7 @@ OMPI_DECLSPEC int ompi_hash_table_remove_value_uint32(ompi_hash_table_t* table,
*
*/
OMPI_DECLSPEC int ompi_hash_table_get_value_uint64(ompi_hash_table_t *table, uint64_t key,
OMPI_DECLSPEC int opal_hash_table_get_value_uint64(opal_hash_table_t *table, uint64_t key,
void **ptr);
/**
@ -152,7 +152,7 @@ OMPI_DECLSPEC int ompi_hash_table_get_value_uint64(ompi_hash_table_t *table, uin
*
*/
OMPI_DECLSPEC int ompi_hash_table_set_value_uint64(ompi_hash_table_t *table, uint64_t key, void* value);
OMPI_DECLSPEC int opal_hash_table_set_value_uint64(opal_hash_table_t *table, uint64_t key, void* value);
/**
* Remove value based on uint64_t key.
@ -163,7 +163,7 @@ OMPI_DECLSPEC int ompi_hash_table_set_value_uint64(ompi_hash_table_t *table, uin
*
*/
OMPI_DECLSPEC int ompi_hash_table_remove_value_uint64(ompi_hash_table_t *table, uint64_t key);
OMPI_DECLSPEC int opal_hash_table_remove_value_uint64(opal_hash_table_t *table, uint64_t key);
/**
* Retrieve value via arbitrary length binary key.
@ -178,7 +178,7 @@ OMPI_DECLSPEC int ompi_hash_table_remove_value_uint64(ompi_hash_table_t *table,
*
*/
OMPI_DECLSPEC int ompi_hash_table_get_value_ptr(ompi_hash_table_t *table, const void* key,
OMPI_DECLSPEC int opal_hash_table_get_value_ptr(opal_hash_table_t *table, const void* key,
size_t keylen, void **ptr);
/**
@ -191,7 +191,7 @@ OMPI_DECLSPEC int ompi_hash_table_get_value_ptr(ompi_hash_table_t *table, const
*
*/
OMPI_DECLSPEC int ompi_hash_table_set_value_ptr(ompi_hash_table_t *table, const void* key, size_t keylen, void* value);
OMPI_DECLSPEC int opal_hash_table_set_value_ptr(opal_hash_table_t *table, const void* key, size_t keylen, void* value);
/**
* Remove value based on arbitrary length binary key.
@ -202,7 +202,7 @@ OMPI_DECLSPEC int ompi_hash_table_set_value_ptr(ompi_hash_table_t *table, const
*
*/
OMPI_DECLSPEC int ompi_hash_table_remove_value_ptr(ompi_hash_table_t *table, const void* key, size_t keylen);
OMPI_DECLSPEC int opal_hash_table_remove_value_ptr(opal_hash_table_t *table, const void* key, size_t keylen);
/** The following functions are only for allowing iterating through
@ -227,7 +227,7 @@ OMPI_DECLSPEC int ompi_hash_table_remove_value_ptr(ompi_hash_table_t *table, con
*
*/
OMPI_DECLSPEC int ompi_hash_table_get_first_key_uint32(ompi_hash_table_t *table, uint32_t *key,
OMPI_DECLSPEC int opal_hash_table_get_first_key_uint32(opal_hash_table_t *table, uint32_t *key,
void **value, void **node);
@ -245,7 +245,7 @@ OMPI_DECLSPEC int ompi_hash_table_get_first_key_uint32(ompi_hash_table_t *table,
*
*/
OMPI_DECLSPEC int ompi_hash_table_get_next_key_uint32(ompi_hash_table_t *table, uint32_t *key,
OMPI_DECLSPEC int opal_hash_table_get_next_key_uint32(opal_hash_table_t *table, uint32_t *key,
void **value, void *in_node,
void **out_node);
@ -263,7 +263,7 @@ OMPI_DECLSPEC int ompi_hash_table_get_next_key_uint32(ompi_hash_table_t *table,
*
*/
OMPI_DECLSPEC int ompi_hash_table_get_first_key_uint64(ompi_hash_table_t *table, uint64_t *key,
OMPI_DECLSPEC int opal_hash_table_get_first_key_uint64(opal_hash_table_t *table, uint64_t *key,
void **value, void **node);
@ -281,7 +281,7 @@ OMPI_DECLSPEC int ompi_hash_table_get_first_key_uint64(ompi_hash_table_t *table,
*
*/
OMPI_DECLSPEC int ompi_hash_table_get_next_key_uint64(ompi_hash_table_t *table, uint64_t *key,
OMPI_DECLSPEC int opal_hash_table_get_next_key_uint64(opal_hash_table_t *table, uint64_t *key,
void **value, void *in_node,
void **out_node);
@ -291,4 +291,4 @@ OMPI_DECLSPEC int ompi_hash_table_get_next_key_uint64(ompi_hash_table_t *table,
#endif
#endif /* OMPI_HASH_TABLE_H */
#endif /* OPAL_HASH_TABLE_H */

14
opal/mca/base/mca_base_param.c
Просмотреть файл

@ -23,7 +23,7 @@
#include "mpi.h"
#include "include/constants.h"
#include "opal/class/opal_value_array.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#if 0
/* JMS commented out for now -- see lookup_keyvals() below for an
explanation */
@ -66,7 +66,7 @@ static int param_register(const char *type_name, const char *component_name,
mca_base_param_storage_t *file_value,
mca_base_param_storage_t *override_value);
static bool param_lookup(size_t index, mca_base_param_storage_t *storage,
ompi_hash_table_t *attrs);
opal_hash_table_t *attrs);
static bool param_set_override(size_t index,
mca_base_param_storage_t *storage,
mca_base_param_type_t type);
@ -74,7 +74,7 @@ static bool lookup_override(mca_base_param_t *param,
mca_base_param_storage_t *storage);
static bool lookup_keyvals(mca_base_param_t *param,
mca_base_param_storage_t *storage,
ompi_hash_table_t *attrs);
opal_hash_table_t *attrs);
static bool lookup_env(mca_base_param_t *param,
mca_base_param_storage_t *storage);
static bool lookup_file(mca_base_param_t *param,
@ -237,7 +237,7 @@ int mca_base_param_lookup_int(int index, int *value)
/*
* Look up an integer MCA parameter, including in attributes
*/
int mca_base_param_kv_lookup_int(int index, ompi_hash_table_t *attrs,
int mca_base_param_kv_lookup_int(int index, opal_hash_table_t *attrs,
int *value)
{
mca_base_param_storage_t storage;
@ -282,7 +282,7 @@ int mca_base_param_lookup_string(int index, char **value)
/*
* Look up a string MCA parameter, including in attributes.
*/
int mca_base_param_kv_lookup_string(int index, ompi_hash_table_t *attrs,
int mca_base_param_kv_lookup_string(int index, opal_hash_table_t *attrs,
char **value)
{
mca_base_param_storage_t storage;
@ -987,7 +987,7 @@ static bool param_set_override(size_t index,
* Lookup a parameter in multiple places
*/
static bool param_lookup(size_t index, mca_base_param_storage_t *storage,
ompi_hash_table_t *attrs)
opal_hash_table_t *attrs)
{
size_t size;
mca_base_param_t *array;
@ -1077,7 +1077,7 @@ static bool lookup_override(mca_base_param_t *param,
*/
static bool lookup_keyvals(mca_base_param_t *param,
mca_base_param_storage_t *storage,
ompi_hash_table_t *attrs)
opal_hash_table_t *attrs)
{
#if 1
/* JMS: Comment this out for now, because it drags in all of

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

@ -60,7 +60,7 @@
#include "opal/class/opal_value_array.h"
#include "opal/class/opal_list.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
/**
* The types of MCA parameters.
@ -272,7 +272,7 @@ extern "C" {
* called first to associate a keyval with the index.
*/
OMPI_DECLSPEC int mca_base_param_kv_lookup_int(int index,
struct ompi_hash_table_t *attrs,
struct opal_hash_table_t *attrs,
int *value);
/**
@ -320,7 +320,7 @@ extern "C" {
* have been called first to associate a keyval with the index.
*/
OMPI_DECLSPEC int mca_base_param_kv_lookup_string(int index,
struct ompi_hash_table_t *attrs,
struct opal_hash_table_t *attrs,
char **value);
/**

2
opal/mca/base/mca_base_param_internal.h
Просмотреть файл

@ -34,7 +34,7 @@
#include "opal/class/opal_object.h"
#include "opal/class/opal_list.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#include "mca/base/mca_base_param.h"
/**

22
orte/class/ompi_proc_table.c
Просмотреть файл

@ -43,7 +43,7 @@ static OBJ_CLASS_INSTANCE(
NULL);
void* ompi_hash_table_get_proc(ompi_hash_table_t* ht,
void* opal_hash_table_get_proc(opal_hash_table_t* ht,
const orte_process_name_t* proc)
{
uint32_t key = (proc->cellid << 24) + (proc->jobid << 16) + proc->vpid;
@ -52,8 +52,8 @@ void* ompi_hash_table_get_proc(ompi_hash_table_t* ht,
#if OMPI_ENABLE_DEBUG
if(ht->ht_table_size == 0) {
ompi_output(0, "ompi_hash_table_get_proc:"
"ompi_hash_table_init() has not been called");
ompi_output(0, "opal_hash_table_get_proc:"
"opal_hash_table_init() has not been called");
return NULL;
}
#endif
@ -68,8 +68,8 @@ void* ompi_hash_table_get_proc(ompi_hash_table_t* ht,
}
int ompi_hash_table_set_proc(
ompi_hash_table_t* ht,
int opal_hash_table_set_proc(
opal_hash_table_t* ht,
const orte_process_name_t* proc,
void* value)
{
@ -79,8 +79,8 @@ int ompi_hash_table_set_proc(
#if OMPI_ENABLE_DEBUG
if(ht->ht_table_size == 0) {
ompi_output(0, "ompi_hash_table_set_value_proc:"
"ompi_hash_table_init() has not been called");
ompi_output(0, "opal_hash_table_set_value_proc:"
"opal_hash_table_init() has not been called");
return OMPI_ERR_BAD_PARAM;
}
#endif
@ -107,8 +107,8 @@ int ompi_hash_table_set_proc(
}
int ompi_hash_table_remove_proc(
ompi_hash_table_t* ht,
int opal_hash_table_remove_proc(
opal_hash_table_t* ht,
const orte_process_name_t* proc)
{
uint32_t key = (proc->cellid << 24) + (proc->jobid << 16) + proc->vpid;
@ -117,8 +117,8 @@ int ompi_hash_table_remove_proc(
#if OMPI_ENABLE_DEBUG
if(ht->ht_table_size == 0) {
ompi_output(0, "ompi_hash_table_remove_value_proc:"
"ompi_hash_table_init() has not been called");
ompi_output(0, "opal_hash_table_remove_value_proc:"
"opal_hash_table_init() has not been called");
return OMPI_ERR_BAD_PARAM;
}
#endif

14
orte/class/ompi_proc_table.h
Просмотреть файл

@ -23,7 +23,7 @@
#ifndef OMPI_PROC_TABLE_H
#define OMPI_PROC_TABLE_H
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#include "mca/ns/ns_types.h"
#if defined(c_plusplus) || defined(__cplusplus)
@ -40,8 +40,8 @@ extern "C" {
*
*/
OMPI_DECLSPEC void *ompi_hash_table_get_proc(
ompi_hash_table_t* table,
OMPI_DECLSPEC void *opal_hash_table_get_proc(
opal_hash_table_t* table,
const orte_process_name_t* key);
/**
@ -54,8 +54,8 @@ OMPI_DECLSPEC void *ompi_hash_table_get_proc(
*
*/
OMPI_DECLSPEC int ompi_hash_table_set_proc(
ompi_hash_table_t* table,
OMPI_DECLSPEC int opal_hash_table_set_proc(
opal_hash_table_t* table,
const orte_process_name_t*,
void* value);
@ -68,8 +68,8 @@ OMPI_DECLSPEC int ompi_hash_table_set_proc(
*
*/
OMPI_DECLSPEC int ompi_hash_table_remove_proc(
ompi_hash_table_t* table,
OMPI_DECLSPEC int opal_hash_table_remove_proc(
opal_hash_table_t* table,
const orte_process_name_t* key);

4
orte/mca/iof/svc/iof_svc_proxy.c
Просмотреть файл

@ -207,10 +207,10 @@ static void orte_iof_svc_proxy_ack(
if (orte_ns.compare(pub->pub_mask,&pub->pub_name,src) == 0 ||
orte_ns.compare(ORTE_NS_CMP_ALL,&pub->pub_proxy,src) == 0) {
value.uval = hdr->msg_seq + hdr->msg_len;
ompi_hash_table_set_proc(&fwd->fwd_seq,
opal_hash_table_set_proc(&fwd->fwd_seq,
&hdr->msg_src, &value.vval);
} else {
value.vval = ompi_hash_table_get_proc(&fwd->fwd_seq,
value.vval = opal_hash_table_get_proc(&fwd->fwd_seq,
&hdr->msg_src);
if(value.uval < seq_min) {
seq_min = value.uval;

4
orte/mca/iof/svc/iof_svc_sub.c
Просмотреть файл

@ -211,8 +211,8 @@ int orte_iof_svc_sub_forward(
static void orte_iof_svc_fwd_construct(orte_iof_svc_fwd_t* fwd)
{
fwd->fwd_pub = NULL;
OBJ_CONSTRUCT(&fwd->fwd_seq, ompi_hash_table_t);
ompi_hash_table_init(&fwd->fwd_seq, 256);
OBJ_CONSTRUCT(&fwd->fwd_seq, opal_hash_table_t);
opal_hash_table_init(&fwd->fwd_seq, 256);
}
static void orte_iof_svc_fwd_destruct(orte_iof_svc_fwd_t* fwd)

2
orte/mca/iof/svc/iof_svc_sub.h
Просмотреть файл

@ -14,7 +14,7 @@
struct orte_iof_svc_fwd_t {
opal_list_item_t super;
orte_iof_svc_pub_t* fwd_pub;
ompi_hash_table_t fwd_seq;
opal_hash_table_t fwd_seq;
};
typedef struct orte_iof_svc_fwd_t orte_iof_svc_fwd_t;

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

@ -177,8 +177,8 @@ int mca_oob_tcp_component_open(void)
OBJ_CONSTRUCT(&mca_oob_tcp_component.tcp_subscriptions, opal_list_t);
OBJ_CONSTRUCT(&mca_oob_tcp_component.tcp_peer_list, opal_list_t);
OBJ_CONSTRUCT(&mca_oob_tcp_component.tcp_peers, ompi_hash_table_t);
OBJ_CONSTRUCT(&mca_oob_tcp_component.tcp_peer_names, ompi_hash_table_t);
OBJ_CONSTRUCT(&mca_oob_tcp_component.tcp_peers, opal_hash_table_t);
OBJ_CONSTRUCT(&mca_oob_tcp_component.tcp_peer_names, opal_hash_table_t);
OBJ_CONSTRUCT(&mca_oob_tcp_component.tcp_peer_free, opal_free_list_t);
OBJ_CONSTRUCT(&mca_oob_tcp_component.tcp_msgs, opal_free_list_t);
OBJ_CONSTRUCT(&mca_oob_tcp_component.tcp_lock, ompi_mutex_t);
@ -496,8 +496,8 @@ mca_oob_t* mca_oob_tcp_component_init(int* priority)
return NULL;
/* initialize data structures */
ompi_hash_table_init(&mca_oob_tcp_component.tcp_peers, 128);
ompi_hash_table_init(&mca_oob_tcp_component.tcp_peer_names, 128);
opal_hash_table_init(&mca_oob_tcp_component.tcp_peers, 128);
opal_hash_table_init(&mca_oob_tcp_component.tcp_peer_names, 128);
opal_free_list_init(&mca_oob_tcp_component.tcp_peer_free,
sizeof(mca_oob_tcp_peer_t),
@ -582,7 +582,7 @@ void mca_oob_tcp_registry_callback(
}
/* check for existing cache entry */
existing = (mca_oob_tcp_addr_t *)ompi_hash_table_get_proc(
existing = (mca_oob_tcp_addr_t *)opal_hash_table_get_proc(
&mca_oob_tcp_component.tcp_peer_names, &addr->addr_name);
if(NULL != existing) {
/* TSW - need to update existing entry */
@ -591,8 +591,8 @@ void mca_oob_tcp_registry_callback(
}
/* insert into cache and notify peer */
ompi_hash_table_set_proc(&mca_oob_tcp_component.tcp_peer_names, &addr->addr_name, addr);
peer = (mca_oob_tcp_peer_t *)ompi_hash_table_get_proc(
opal_hash_table_set_proc(&mca_oob_tcp_component.tcp_peer_names, &addr->addr_name, addr);
peer = (mca_oob_tcp_peer_t *)opal_hash_table_get_proc(
&mca_oob_tcp_component.tcp_peers, &addr->addr_name);
if(NULL != peer)
mca_oob_tcp_peer_resolved(peer, addr);
@ -616,7 +616,7 @@ int mca_oob_tcp_resolve(mca_oob_tcp_peer_t* peer)
/* if the address is already cached - simply return it */
OMPI_THREAD_LOCK(&mca_oob_tcp_component.tcp_lock);
addr = (mca_oob_tcp_addr_t *)ompi_hash_table_get_proc(&mca_oob_tcp_component.tcp_peer_names,
addr = (mca_oob_tcp_addr_t *)opal_hash_table_get_proc(&mca_oob_tcp_component.tcp_peer_names,
&peer->peer_name);
if(NULL != addr) {
OMPI_THREAD_UNLOCK(&mca_oob_tcp_component.tcp_lock);
@ -1125,14 +1125,14 @@ int mca_oob_tcp_set_addr(const orte_process_name_t* name, const char* uri)
return rc;
OMPI_THREAD_LOCK(&mca_oob_tcp_component.tcp_lock);
addr = (mca_oob_tcp_addr_t*)ompi_hash_table_get_proc(&mca_oob_tcp_component.tcp_peer_names, name);
addr = (mca_oob_tcp_addr_t*)opal_hash_table_get_proc(&mca_oob_tcp_component.tcp_peer_names, name);
if(NULL == addr) {
addr = OBJ_NEW(mca_oob_tcp_addr_t);
addr->addr_name = *name;
ompi_hash_table_set_proc(&mca_oob_tcp_component.tcp_peer_names, &addr->addr_name, addr);
opal_hash_table_set_proc(&mca_oob_tcp_component.tcp_peer_names, &addr->addr_name, addr);
}
rc = mca_oob_tcp_addr_insert(addr, &inaddr);
peer = (mca_oob_tcp_peer_t *)ompi_hash_table_get_proc(
peer = (mca_oob_tcp_peer_t *)opal_hash_table_get_proc(
&mca_oob_tcp_component.tcp_peers, &addr->addr_name);
if(NULL != peer) {
mca_oob_tcp_peer_resolved(peer, addr);

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

@ -26,7 +26,7 @@
#include "mca/base/base.h"
#include "mca/ns/ns_types.h"
#include "opal/class/opal_free_list.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
#include "event/event.h"
#include "threads/mutex.h"
#include "threads/condition.h"
@ -249,8 +249,8 @@ struct mca_oob_tcp_component_t {
unsigned short tcp_listen_port; /**< listen port */
opal_list_t tcp_subscriptions; /**< list of registry subscriptions */
opal_list_t tcp_peer_list; /**< list of peers sorted in mru order */
ompi_hash_table_t tcp_peers; /**< peers sorted by name */
ompi_hash_table_t tcp_peer_names; /**< cache of peer contact info sorted by name */
opal_hash_table_t tcp_peers; /**< peers sorted by name */
opal_hash_table_t tcp_peer_names; /**< cache of peer contact info sorted by name */
opal_free_list_t tcp_peer_free; /**< free list of peers */
int tcp_peer_limit; /**< max size of tcp peer cache */
int tcp_peer_retries; /**< max number of retries before declaring peer gone */

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

@ -351,9 +351,9 @@ static void mca_oob_tcp_msg_ident(mca_oob_tcp_msg_t* msg, mca_oob_tcp_peer_t* pe
OMPI_THREAD_LOCK(&mca_oob_tcp_component.tcp_lock);
if (orte_ns.compare(ORTE_NS_CMP_ALL, &peer->peer_name, &src) != 0) {
ompi_hash_table_remove_proc(&mca_oob_tcp_component.tcp_peers, &peer->peer_name);
opal_hash_table_remove_proc(&mca_oob_tcp_component.tcp_peers, &peer->peer_name);
peer->peer_name = src;
ompi_hash_table_set_proc(&mca_oob_tcp_component.tcp_peers, &peer->peer_name, peer);
opal_hash_table_set_proc(&mca_oob_tcp_component.tcp_peers, &peer->peer_name, peer);
}
OMPI_THREAD_UNLOCK(&mca_oob_tcp_component.tcp_lock);
}

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

@ -192,7 +192,7 @@ mca_oob_tcp_peer_t * mca_oob_tcp_peer_lookup(const orte_process_name_t* name)
}
OMPI_THREAD_LOCK(&mca_oob_tcp_component.tcp_lock);
peer = (mca_oob_tcp_peer_t*)ompi_hash_table_get_proc(
peer = (mca_oob_tcp_peer_t*)opal_hash_table_get_proc(
&mca_oob_tcp_component.tcp_peers, name);
if(NULL != peer && memcmp(&peer->peer_name,name,sizeof(peer->peer_name)) == 0) {
OMPI_THREAD_UNLOCK(&mca_oob_tcp_component.tcp_lock);
@ -227,7 +227,7 @@ mca_oob_tcp_peer_t * mca_oob_tcp_peer_lookup(const orte_process_name_t* name)
peer->peer_retries = 0;
/* add to lookup table */
if(OMPI_SUCCESS != ompi_hash_table_set_proc(&mca_oob_tcp_component.tcp_peers,
if(OMPI_SUCCESS != opal_hash_table_set_proc(&mca_oob_tcp_component.tcp_peers,
&peer->peer_name, peer)) {
MCA_OOB_TCP_PEER_RETURN(peer);
OMPI_THREAD_UNLOCK(&mca_oob_tcp_component.tcp_lock);

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

@ -91,7 +91,7 @@ OBJ_CLASS_DECLARATION(mca_oob_tcp_peer_t);
#define MCA_OOB_TCP_PEER_RETURN(peer) \
{ \
mca_oob_tcp_peer_shutdown(peer); \
ompi_hash_table_remove_proc(&mca_oob_tcp_component.tcp_peers, &peer->peer_name); \
opal_hash_table_remove_proc(&mca_oob_tcp_component.tcp_peers, &peer->peer_name); \
OPAL_FREE_LIST_RETURN(&mca_oob_tcp_component.tcp_peer_free, (opal_list_item_t*)peer); \
}

Двоичные данные
test/Unit-Test-Status.xls
Просмотреть файл

Двоичный файл не отображается.

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

@ -22,7 +22,7 @@ check_PROGRAMS = \
ompi_bitmap \
ompi_circular_buffer_fifo \
ompi_fifo \
ompi_hash_table \
opal_hash_table \
opal_list \
opal_value_array \
ompi_pointer_array \
@ -56,11 +56,11 @@ opal_list_LDADD = \
$(top_builddir)/test/support/libsupport.a
opal_list_DEPENDENCIES = $(opal_list_LDADD)
ompi_hash_table_SOURCES = ompi_hash_table.c
ompi_hash_table_LDADD = \
opal_hash_table_SOURCES = opal_hash_table.c
opal_hash_table_LDADD = \
$(top_builddir)/src/libmpi.la \
$(top_builddir)/test/support/libsupport.a
ompi_hash_table_DEPENDENCIES = $(ompi_hash_table_LDADD)
opal_hash_table_DEPENDENCIES = $(opal_hash_table_LDADD)
ompi_pointer_array_SOURCES = ompi_pointer_array.c
ompi_pointer_array_LDADD = \

46
test/class/ompi_hash_table.c
Просмотреть файл

@ -21,7 +21,7 @@
#include <string.h>
#include "support.h"
#include "opal/class/opal_object.h"
#include "class/ompi_hash_table.h"
#include "class/opal_hash_table.h"
static FILE *error_out=NULL;
@ -62,63 +62,63 @@ typedef union {
void *vvalue;
} value_t;
static void validate_table(ompi_hash_table_t *table, char *keys[], int is_numeric_keys)
static void validate_table(opal_hash_table_t *table, char *keys[], int is_numeric_keys)
{
int j, ret;
value_t value;
for ( j = 0; keys[j]; j += 2) {
if ( 1 == is_numeric_keys ) {
ret = ompi_hash_table_get_value_uint32(table, atoi(keys[j]),
ret = opal_hash_table_get_value_uint32(table, atoi(keys[j]),
(void**) &value.uvalue);
} else {
ret = ompi_hash_table_get_value_ptr(table, keys[j],
ret = opal_hash_table_get_value_ptr(table, keys[j],
strlen(keys[j]),
&value.vvalue);
}
test_verify_str(keys[j+1], value.vvalue);
}
test_verify_int(j/2, ompi_hash_table_get_size(table));
test_verify_int(j/2, opal_hash_table_get_size(table));
}
static void test_htable(ompi_hash_table_t *table)
static void test_htable(opal_hash_table_t *table)
{
int j;
fprintf(error_out, "\nTesting integer keys...\n");
for ( j = 0; num_keys[j]; j += 2)
{
ompi_hash_table_set_value_uint32(table, atoi(num_keys[j]), num_keys[j+1]);
opal_hash_table_set_value_uint32(table, atoi(num_keys[j]), num_keys[j+1]);
}
validate_table(table, num_keys, 1);
/* remove all values for next test */
ompi_hash_table_remove_all(table);
test_verify_int(0, ompi_hash_table_get_size(table));
opal_hash_table_remove_all(table);
test_verify_int(0, opal_hash_table_get_size(table));
fprintf(error_out, "\nTesting string keys...\n");
for ( j = 0; str_keys[j]; j += 2)
{
ompi_hash_table_set_value_ptr(table, str_keys[j], strlen(str_keys[j]), str_keys[j+1]);
opal_hash_table_set_value_ptr(table, str_keys[j], strlen(str_keys[j]), str_keys[j+1]);
}
validate_table(table, str_keys, 0);
/* remove all values for next test */
ompi_hash_table_remove_all(table);
test_verify_int(0, ompi_hash_table_get_size(table));
opal_hash_table_remove_all(table);
test_verify_int(0, opal_hash_table_get_size(table));
fprintf(error_out, "\nTesting collision resolution...\n");
/* All of the string keys in keys array should
have the same hash value. */
for ( j = 0; perm_keys[j]; j += 2)
{
ompi_hash_table_set_value_ptr(table, perm_keys[j], strlen(perm_keys[j]), perm_keys[j+1]);
opal_hash_table_set_value_ptr(table, perm_keys[j], strlen(perm_keys[j]), perm_keys[j+1]);
}
validate_table(table, perm_keys, 0);
/* remove all values for next test */
ompi_hash_table_remove_all(table);
test_verify_int(0, ompi_hash_table_get_size(table));
opal_hash_table_remove_all(table);
test_verify_int(0, opal_hash_table_get_size(table));
fprintf(error_out, "\n\n");
}
@ -126,16 +126,16 @@ static void test_htable(ompi_hash_table_t *table)
static void test_dynamic(void)
{
ompi_hash_table_t *table;
opal_hash_table_t *table;
table = OBJ_NEW(ompi_hash_table_t);
table = OBJ_NEW(opal_hash_table_t);
if ( NULL == table )
{
fprintf(error_out, "Error: Unable to create hash table.\n");
exit(-1);
}
fprintf(error_out, "Testing with dynamically created table...\n");
ompi_hash_table_init(table, 4);
opal_hash_table_init(table, 4);
test_htable(table);
OBJ_RELEASE(table);
@ -144,10 +144,10 @@ static void test_dynamic(void)
static void test_static(void)
{
ompi_hash_table_t table;
opal_hash_table_t table;
OBJ_CONSTRUCT(&table, ompi_hash_table_t);
ompi_hash_table_init(&table, 128);
OBJ_CONSTRUCT(&table, opal_hash_table_t);
opal_hash_table_init(&table, 128);
fprintf(error_out, "Testing with statically created table...\n");
test_htable(&table);
@ -159,12 +159,12 @@ static void test_static(void)
int main(int argc, char **argv)
{
/* local variables */
test_init("ompi_hash_table_t");
test_init("opal_hash_table_t");
#ifdef STANDALONE
error_out = stderr;
#else
error_out = fopen( "./ompi_hash_table_test_out.txt", "w" );
error_out = fopen( "./opal_hash_table_test_out.txt", "w" );
if( error_out == NULL ) error_out = stderr;
#endif

4
vcproj/ompi/ompi.vcproj
Просмотреть файл

@ -167,10 +167,10 @@
RelativePath="..\..\src\class\ompi_free_list.h">
</File>
<File
RelativePath="..\..\src\class\ompi_hash_table.c">
RelativePath="..\..\src\class\opal_hash_table.c">
</File>
<File
RelativePath="..\..\src\class\ompi_hash_table.h">
RelativePath="..\..\src\class\opal_hash_table.h">
</File>
<File
RelativePath="..\..\src\class\opal_list.c">