file/file.c
info/info.c group/mpi_group_init.c communicator/comm_init.c communicator/comm.c This commit was SVN r3199.
Этот коммит содержится в:
Prabhanjan Kambadur
родитель
d48aa34dec
Коммит
d9e0ad22f4
@ -68,7 +68,7 @@ int ompi_free_list_grow(ompi_free_list_t* flist, size_t num_elements)
|
||||
if (NULL != flist->fl_mpool)
|
||||
ptr = (unsigned char*)flist->fl_mpool->mpool_alloc(num_elements * flist->fl_elem_size, 0);
|
||||
else
|
||||
ptr = malloc(num_elements * flist->fl_elem_size);
|
||||
ptr = (unsigned char *)malloc(num_elements * flist->fl_elem_size);
|
||||
if(NULL == ptr)
|
||||
return OMPI_ERR_TEMP_OUT_OF_RESOURCE;
|
||||
|
||||
|
||||
@ -66,7 +66,7 @@ int ompi_hash_table_init(ompi_hash_table_t* ht, size_t table_size)
|
||||
}
|
||||
|
||||
ht->ht_mask = power2-1;
|
||||
ht->ht_table = malloc(power2 * sizeof(ompi_list_t));
|
||||
ht->ht_table = (ompi_list_t *)malloc(power2 * sizeof(ompi_list_t));
|
||||
if(NULL == ht->ht_table) {
|
||||
return OMPI_ERR_OUT_OF_RESOURCE;
|
||||
}
|
||||
@ -348,7 +348,7 @@ static inline uint32_t ompi_hash_value(size_t mask, const void *key,
|
||||
const unsigned char *p;
|
||||
|
||||
h = 0;
|
||||
p = key;
|
||||
p = (const unsigned char *)key;
|
||||
for (i = 0; i < keysize; i++, p++)
|
||||
h = HASH_MULTIPLIER*h + *p;
|
||||
return (h & mask);
|
||||
@ -516,7 +516,7 @@ ompi_hash_table_get_next_key_uint32(ompi_hash_table_t *ht, uint32_t *key,
|
||||
/* We found it. Save the values (use "next" to avoid some
|
||||
typecasting) */
|
||||
|
||||
next = *out_node = (void *) item;
|
||||
next = (ompi_uint32_hash_node_t *)*out_node = (void *) item;
|
||||
*key = next->hn_key;
|
||||
*value = next->hn_value;
|
||||
|
||||
@ -587,7 +587,7 @@ ompi_hash_table_get_next_key_uint64(ompi_hash_table_t *ht, uint64_t *key,
|
||||
/* We found it. Save the values (use "next" to avoid some
|
||||
typecasting) */
|
||||
|
||||
next = *out_node = (void *) item;
|
||||
next = (ompi_uint64_hash_node_t *)*out_node = (void *) item;
|
||||
*key = next->hn_key;
|
||||
*value = next->hn_value;
|
||||
|
||||
|
||||
@ -37,45 +37,45 @@ ompi_class_t ompi_object_t_class = {
|
||||
/*
|
||||
* Lazy initialization of class descriptor.
|
||||
*/
|
||||
void ompi_class_initialize(ompi_class_t *class)
|
||||
void ompi_class_initialize(ompi_class_t *cls)
|
||||
{
|
||||
ompi_class_t *c;
|
||||
int i;
|
||||
|
||||
assert(class);
|
||||
assert(0 == class->cls_initialized);
|
||||
assert(cls);
|
||||
assert(0 == cls->cls_initialized);
|
||||
|
||||
/*
|
||||
* First calculate depth of class hierarchy
|
||||
*/
|
||||
|
||||
class->cls_depth = 0;
|
||||
for (c = class; c; c = c->cls_parent) {
|
||||
class->cls_depth += 1;
|
||||
cls->cls_depth = 0;
|
||||
for (c = cls; c; c = c->cls_parent) {
|
||||
cls->cls_depth += 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Allocate arrays for hierarchy of constructors and destructors
|
||||
*/
|
||||
|
||||
class->cls_construct_array = malloc(class->cls_depth *
|
||||
cls->cls_construct_array = (void (**)(ompi_object_t*))malloc(cls->cls_depth *
|
||||
sizeof(ompi_construct_t));
|
||||
if (NULL == class->cls_construct_array) {
|
||||
if (NULL == cls->cls_construct_array) {
|
||||
perror("Out of memory");
|
||||
}
|
||||
|
||||
class->cls_destruct_array = malloc(class->cls_depth *
|
||||
cls->cls_destruct_array = (void (**)(ompi_object_t*))malloc(cls->cls_depth *
|
||||
sizeof(ompi_destruct_t));
|
||||
if (NULL == class->cls_destruct_array) {
|
||||
if (NULL == cls->cls_destruct_array) {
|
||||
perror("Out of memory");
|
||||
}
|
||||
|
||||
c = class;
|
||||
for (i = 0; i < class->cls_depth; i++) {
|
||||
class->cls_construct_array[i] = c->cls_construct;
|
||||
class->cls_destruct_array[i] = c->cls_destruct;
|
||||
c = cls;
|
||||
for (i = 0; i < cls->cls_depth; i++) {
|
||||
cls->cls_construct_array[i] = c->cls_construct;
|
||||
cls->cls_destruct_array[i] = c->cls_destruct;
|
||||
c = c->cls_parent;
|
||||
}
|
||||
|
||||
class->cls_initialized = 1;
|
||||
cls->cls_initialized = 1;
|
||||
}
|
||||
|
||||
@ -91,7 +91,7 @@ size_t ompi_pointer_array_add(ompi_pointer_array_t *table, void *ptr)
|
||||
ompi_output(0,"ompi_pointer_array_add: INIT: table %p\n", table);
|
||||
}
|
||||
|
||||
p = malloc(TABLE_INIT * sizeof(void *));
|
||||
p = (void **)malloc(TABLE_INIT * sizeof(void *));
|
||||
if (p == NULL) {
|
||||
OMPI_THREAD_UNLOCK(&(table->lock));
|
||||
return OMPI_ERROR;
|
||||
@ -115,7 +115,7 @@ size_t ompi_pointer_array_add(ompi_pointer_array_t *table, void *ptr)
|
||||
table, table->size, table->size * TABLE_GROW);
|
||||
}
|
||||
|
||||
p = realloc(table->addr, TABLE_GROW * table->size * sizeof(void *));
|
||||
p = (void **)realloc(table->addr, TABLE_GROW * table->size * sizeof(void *));
|
||||
if (p == NULL) {
|
||||
OMPI_THREAD_UNLOCK(&(table->lock));
|
||||
return OMPI_ERROR;
|
||||
@ -203,7 +203,7 @@ int ompi_pointer_array_set_item(ompi_pointer_array_t *table, size_t index,
|
||||
return OMPI_ERROR;
|
||||
}
|
||||
table->number_free += new_size - table->size;
|
||||
table->addr = p;
|
||||
table->addr = (void **) p;
|
||||
for (i = table->size; i < new_size; i++) {
|
||||
table->addr[i] = NULL;
|
||||
}
|
||||
@ -323,7 +323,7 @@ int ompi_pointer_array_test_and_set_item (ompi_pointer_array_t *table, size_t in
|
||||
return OMPI_ERROR;
|
||||
}
|
||||
table->number_free += new_size - table->size;
|
||||
table->addr = p;
|
||||
table->addr = (void **)p;
|
||||
for (i = table->size; i < new_size; i++) {
|
||||
table->addr[i] = NULL;
|
||||
}
|
||||
|
||||
@ -43,7 +43,7 @@ int ompi_value_array_set_size(ompi_value_array_t* array, size_t size)
|
||||
if(size > array->array_alloc_size) {
|
||||
while(array->array_alloc_size < size)
|
||||
array->array_alloc_size <<= 1;
|
||||
array->array_items = realloc(array->array_items,
|
||||
array->array_items = (unsigned char *)realloc(array->array_items,
|
||||
array->array_alloc_size * array->array_item_sizeof);
|
||||
if (NULL == array->array_items)
|
||||
return OMPI_ERR_OUT_OF_RESOURCE;
|
||||
|
||||
@ -136,7 +136,7 @@ int ompi_comm_set ( ompi_communicator_t *newcomm,
|
||||
*/
|
||||
|
||||
/* allocate the data for the common good */
|
||||
newcomm->c_topo_comm = malloc(sizeof(mca_topo_base_comm_t));
|
||||
newcomm->c_topo_comm = (mca_topo_base_comm_t *)malloc(sizeof(mca_topo_base_comm_t));
|
||||
|
||||
if (NULL == newcomm->c_topo_comm) {
|
||||
OBJ_RELEASE(newcomm);
|
||||
@ -989,7 +989,7 @@ int ompi_topo_create (ompi_communicator_t *old_comm,
|
||||
new_comm = OBJ_NEW (ompi_communicator_t);
|
||||
|
||||
/* allocate the data for the common good */
|
||||
new_comm->c_topo_comm = malloc(sizeof(mca_topo_base_comm_t));
|
||||
new_comm->c_topo_comm = (mca_topo_base_comm_t *)malloc(sizeof(mca_topo_base_comm_t));
|
||||
|
||||
if (NULL == new_comm->c_topo_comm) {
|
||||
OBJ_RELEASE(new_comm);
|
||||
@ -1016,7 +1016,7 @@ int ompi_topo_create (ompi_communicator_t *old_comm,
|
||||
|
||||
new_comm->c_topo_comm->mtc_coords = NULL;
|
||||
|
||||
new_comm->c_topo_comm->mtc_dims_or_index = malloc (sizeof(int) * ndims_or_nnodes);
|
||||
new_comm->c_topo_comm->mtc_dims_or_index = (int *)malloc (sizeof(int) * ndims_or_nnodes);
|
||||
if (NULL == new_comm->c_topo_comm->mtc_dims_or_index) {
|
||||
ompi_comm_free (&new_comm);
|
||||
*comm_topo = new_comm;
|
||||
@ -1050,7 +1050,7 @@ int ompi_topo_create (ompi_communicator_t *old_comm,
|
||||
* structure. The base component functions are free to change
|
||||
* it as they deem fit */
|
||||
|
||||
new_comm->c_topo_comm->mtc_periods_or_edges =
|
||||
new_comm->c_topo_comm->mtc_periods_or_edges = (int *)
|
||||
malloc (sizeof(int) * dims_or_index[ndims_or_nnodes - 1]);
|
||||
if (NULL == new_comm->c_topo_comm->mtc_periods_or_edges) {
|
||||
ompi_comm_free (&new_comm);
|
||||
@ -1061,7 +1061,7 @@ int ompi_topo_create (ompi_communicator_t *old_comm,
|
||||
periods_or_edges, dims_or_index[ndims_or_nnodes - 1]
|
||||
* sizeof(int));
|
||||
|
||||
new_comm->c_topo_comm->mtc_coords = malloc (sizeof(int) * ndims_or_nnodes);
|
||||
new_comm->c_topo_comm->mtc_coords = (int *)malloc (sizeof(int) * ndims_or_nnodes);
|
||||
if (NULL == new_comm->c_topo_comm->mtc_coords) {
|
||||
ompi_comm_free (&new_comm);
|
||||
*comm_topo = new_comm;
|
||||
@ -1089,7 +1089,7 @@ int ompi_topo_create (ompi_communicator_t *old_comm,
|
||||
* structure. The base component functions are free to change
|
||||
* it as they deem fit */
|
||||
|
||||
new_comm->c_topo_comm->mtc_periods_or_edges =
|
||||
new_comm->c_topo_comm->mtc_periods_or_edges = (int *)
|
||||
malloc (sizeof(int) * dims_or_index[ndims_or_nnodes-1]);
|
||||
if (NULL == new_comm->c_topo_comm->mtc_periods_or_edges) {
|
||||
ompi_comm_free (&new_comm);
|
||||
@ -1247,7 +1247,7 @@ static int ompi_comm_copy_topo (ompi_communicator_t *oldcomm,
|
||||
newcomm->c_topo_comm->mtc_ndims_or_nnodes = oldcomm->c_topo_comm->mtc_ndims_or_nnodes;
|
||||
newcomm->c_topo_comm->mtc_reorder = oldcomm->c_topo_comm->mtc_reorder;
|
||||
|
||||
newcomm->c_topo_comm->mtc_dims_or_index = malloc(sizeof(int)*
|
||||
newcomm->c_topo_comm->mtc_dims_or_index = (int *)malloc(sizeof(int)*
|
||||
newcomm->c_topo_comm->mtc_ndims_or_nnodes);
|
||||
|
||||
if (NULL == newcomm->c_topo_comm->mtc_dims_or_index) {
|
||||
@ -1258,7 +1258,7 @@ static int ompi_comm_copy_topo (ompi_communicator_t *oldcomm,
|
||||
oldcomm->c_topo_comm->mtc_dims_or_index ,
|
||||
newcomm->c_topo_comm->mtc_ndims_or_nnodes * sizeof(int));
|
||||
|
||||
newcomm->c_topo_comm->mtc_periods_or_edges =
|
||||
newcomm->c_topo_comm->mtc_periods_or_edges = (int *)
|
||||
malloc (sizeof(int)*index);
|
||||
if (NULL == newcomm->c_topo_comm->mtc_periods_or_edges) {
|
||||
return OMPI_ERROR;
|
||||
@ -1269,7 +1269,7 @@ static int ompi_comm_copy_topo (ompi_communicator_t *oldcomm,
|
||||
sizeof(int) * index );
|
||||
|
||||
if (OMPI_COMM_IS_CART(oldcomm)) {
|
||||
newcomm->c_topo_comm->mtc_coords = malloc(sizeof(int)*
|
||||
newcomm->c_topo_comm->mtc_coords = (int *)malloc(sizeof(int)*
|
||||
newcomm->c_topo_comm->mtc_ndims_or_nnodes);
|
||||
|
||||
if (NULL == newcomm->c_topo_comm->mtc_coords) {
|
||||
|
||||
@ -202,11 +202,11 @@ int ompi_comm_finalize(void)
|
||||
/* Check whether we have some communicators left */
|
||||
max = ompi_pointer_array_get_size(&ompi_mpi_communicators);
|
||||
for ( i=3; i<max; i++ ) {
|
||||
comm = ompi_pointer_array_get_item(&ompi_mpi_communicators, i);
|
||||
comm = (ompi_communicator_t *)ompi_pointer_array_get_item(&ompi_mpi_communicators, i);
|
||||
if ( NULL != comm ) {
|
||||
/* Communicator has not been freed before finalize */
|
||||
OBJ_RELEASE(comm);
|
||||
comm=ompi_pointer_array_get_item(&ompi_mpi_communicators, i);
|
||||
comm=(ompi_communicator_t *)ompi_pointer_array_get_item(&ompi_mpi_communicators, i);
|
||||
if ( NULL != comm ) {
|
||||
/* Still here ? */
|
||||
if ( ompi_debug_show_handle_leaks && !(OMPI_COMM_IS_FREED(comm)) ){
|
||||
|
||||
@ -89,221 +89,221 @@ int ompi_errclass_init (void)
|
||||
* it in the pointer-array.
|
||||
*/
|
||||
OBJ_CONSTRUCT(&ompi_errclass_success, ompi_errclass_t);
|
||||
ompi_errclass_success.class = MPI_SUCCESS;
|
||||
ompi_errclass_success.cls = MPI_SUCCESS;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_SUCCESS, &ompi_errclass_success);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_buffer, ompi_errclass_t);
|
||||
ompi_errclass_buffer.class = MPI_ERR_BUFFER;
|
||||
ompi_errclass_buffer.cls = MPI_ERR_BUFFER;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_BUFFER, &ompi_errclass_buffer);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_count, ompi_errclass_t);
|
||||
ompi_errclass_count.class = MPI_ERR_COUNT;
|
||||
ompi_errclass_count.cls = MPI_ERR_COUNT;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_COUNT, &ompi_errclass_count);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_type, ompi_errclass_t);
|
||||
ompi_errclass_type.class = MPI_ERR_TYPE;
|
||||
ompi_errclass_type.cls = MPI_ERR_TYPE;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_TYPE, &ompi_errclass_type);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_tag, ompi_errclass_t);
|
||||
ompi_errclass_tag.class = MPI_ERR_TAG;
|
||||
ompi_errclass_tag.cls = MPI_ERR_TAG;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_TAG, &ompi_errclass_tag);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_comm, ompi_errclass_t);
|
||||
ompi_errclass_comm.class = MPI_ERR_COMM;
|
||||
ompi_errclass_comm.cls = MPI_ERR_COMM;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_COMM, &ompi_errclass_comm);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_rank, ompi_errclass_t);
|
||||
ompi_errclass_rank.class = MPI_ERR_RANK;
|
||||
ompi_errclass_rank.cls = MPI_ERR_RANK;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_RANK, &ompi_errclass_rank);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_request, ompi_errclass_t);
|
||||
ompi_errclass_request.class = MPI_ERR_REQUEST;
|
||||
ompi_errclass_request.cls = MPI_ERR_REQUEST;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_REQUEST, &ompi_errclass_request);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_root, ompi_errclass_t);
|
||||
ompi_errclass_root.class = MPI_ERR_ROOT;
|
||||
ompi_errclass_root.cls = MPI_ERR_ROOT;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_ROOT, &ompi_errclass_root);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_group, ompi_errclass_t);
|
||||
ompi_errclass_group.class = MPI_ERR_GROUP;
|
||||
ompi_errclass_group.cls = MPI_ERR_GROUP;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_GROUP, &ompi_errclass_group);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_op, ompi_errclass_t);
|
||||
ompi_errclass_op.class = MPI_ERR_OP;
|
||||
ompi_errclass_op.cls = MPI_ERR_OP;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_OP, &ompi_errclass_op);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_topology, ompi_errclass_t);
|
||||
ompi_errclass_topology.class = MPI_ERR_TOPOLOGY;
|
||||
ompi_errclass_topology.cls = MPI_ERR_TOPOLOGY;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_TOPOLOGY, &ompi_errclass_topology);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_dims, ompi_errclass_t);
|
||||
ompi_errclass_dims.class = MPI_ERR_DIMS;
|
||||
ompi_errclass_dims.cls = MPI_ERR_DIMS;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_DIMS, &ompi_errclass_dims);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_arg, ompi_errclass_t);
|
||||
ompi_errclass_arg.class = MPI_ERR_ARG;
|
||||
ompi_errclass_arg.cls = MPI_ERR_ARG;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_ARG, &ompi_errclass_arg);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_unknown, ompi_errclass_t);
|
||||
ompi_errclass_unknown.class = MPI_ERR_UNKNOWN;
|
||||
ompi_errclass_unknown.cls = MPI_ERR_UNKNOWN;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_UNKNOWN, &ompi_errclass_unknown);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_truncate, ompi_errclass_t);
|
||||
ompi_errclass_truncate.class = MPI_ERR_TRUNCATE;
|
||||
ompi_errclass_truncate.cls = MPI_ERR_TRUNCATE;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_TRUNCATE, &ompi_errclass_truncate);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_other, ompi_errclass_t);
|
||||
ompi_errclass_other.class = MPI_ERR_OTHER;
|
||||
ompi_errclass_other.cls = MPI_ERR_OTHER;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_OTHER, &ompi_errclass_other);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_intern, ompi_errclass_t);
|
||||
ompi_errclass_intern.class = MPI_ERR_INTERN;
|
||||
ompi_errclass_intern.cls = MPI_ERR_INTERN;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_INTERN, &ompi_errclass_intern);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_in_status, ompi_errclass_t);
|
||||
ompi_errclass_in_status.class = MPI_ERR_IN_STATUS;
|
||||
ompi_errclass_in_status.cls = MPI_ERR_IN_STATUS;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_IN_STATUS, &ompi_errclass_in_status);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_pending, ompi_errclass_t);
|
||||
ompi_errclass_pending.class = MPI_ERR_PENDING;
|
||||
ompi_errclass_pending.cls = MPI_ERR_PENDING;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_PENDING, &ompi_errclass_pending);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_access, ompi_errclass_t);
|
||||
ompi_errclass_access.class = MPI_ERR_ACCESS;
|
||||
ompi_errclass_access.cls = MPI_ERR_ACCESS;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_ACCESS, &ompi_errclass_access);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_amode, ompi_errclass_t);
|
||||
ompi_errclass_amode.class = MPI_ERR_AMODE;
|
||||
ompi_errclass_amode.cls = MPI_ERR_AMODE;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_AMODE, &ompi_errclass_amode);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_assert, ompi_errclass_t);
|
||||
ompi_errclass_assert.class = MPI_ERR_ASSERT;
|
||||
ompi_errclass_assert.cls = MPI_ERR_ASSERT;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_ASSERT, &ompi_errclass_assert);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_bad_file, ompi_errclass_t);
|
||||
ompi_errclass_bad_file.class = MPI_ERR_BAD_FILE;
|
||||
ompi_errclass_bad_file.cls = MPI_ERR_BAD_FILE;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_BAD_FILE, &ompi_errclass_bad_file);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_base, ompi_errclass_t);
|
||||
ompi_errclass_base.class = MPI_ERR_BASE;
|
||||
ompi_errclass_base.cls = MPI_ERR_BASE;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_BASE, &ompi_errclass_base);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_conversion, ompi_errclass_t);
|
||||
ompi_errclass_conversion.class = MPI_ERR_CONVERSION;
|
||||
ompi_errclass_conversion.cls = MPI_ERR_CONVERSION;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_CONVERSION, &ompi_errclass_conversion);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_disp, ompi_errclass_t);
|
||||
ompi_errclass_disp.class = MPI_ERR_DISP;
|
||||
ompi_errclass_disp.cls = MPI_ERR_DISP;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_DISP, &ompi_errclass_disp);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_dup_datarep, ompi_errclass_t);
|
||||
ompi_errclass_dup_datarep.class = MPI_ERR_DUP_DATAREP;
|
||||
ompi_errclass_dup_datarep.cls = MPI_ERR_DUP_DATAREP;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_DUP_DATAREP, &ompi_errclass_dup_datarep);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_file_exists, ompi_errclass_t);
|
||||
ompi_errclass_file_exists.class = MPI_ERR_FILE_EXISTS;
|
||||
ompi_errclass_file_exists.cls = MPI_ERR_FILE_EXISTS;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_FILE_EXISTS, &ompi_errclass_file_exists);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_file_in_use, ompi_errclass_t);
|
||||
ompi_errclass_file_in_use.class = MPI_ERR_FILE_IN_USE;
|
||||
ompi_errclass_file_in_use.cls = MPI_ERR_FILE_IN_USE;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_FILE_IN_USE, &ompi_errclass_file_in_use);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_file, ompi_errclass_t);
|
||||
ompi_errclass_file.class = MPI_ERR_FILE;
|
||||
ompi_errclass_file.cls = MPI_ERR_FILE;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_FILE, &ompi_errclass_file);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_info_key, ompi_errclass_t);
|
||||
ompi_errclass_info_key.class = MPI_ERR_INFO_KEY;
|
||||
ompi_errclass_info_key.cls = MPI_ERR_INFO_KEY;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_INFO_KEY, &ompi_errclass_info_key);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_info_nokey, ompi_errclass_t);
|
||||
ompi_errclass_info_nokey.class = MPI_ERR_INFO_NOKEY;
|
||||
ompi_errclass_info_nokey.cls = MPI_ERR_INFO_NOKEY;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_INFO_NOKEY, &ompi_errclass_info_nokey);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_info_value, ompi_errclass_t);
|
||||
ompi_errclass_info_value.class = MPI_ERR_INFO_VALUE;
|
||||
ompi_errclass_info_value.cls = MPI_ERR_INFO_VALUE;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_INFO_VALUE, &ompi_errclass_info_value);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_info, ompi_errclass_t);
|
||||
ompi_errclass_info.class = MPI_ERR_INFO;
|
||||
ompi_errclass_info.cls = MPI_ERR_INFO;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_INFO, &ompi_errclass_info);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_io, ompi_errclass_t);
|
||||
ompi_errclass_io.class = MPI_ERR_IO;
|
||||
ompi_errclass_io.cls = MPI_ERR_IO;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_IO, &ompi_errclass_io);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_keyval, ompi_errclass_t);
|
||||
ompi_errclass_keyval.class = MPI_ERR_KEYVAL;
|
||||
ompi_errclass_keyval.cls = MPI_ERR_KEYVAL;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_KEYVAL, &ompi_errclass_keyval);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_locktype, ompi_errclass_t);
|
||||
ompi_errclass_locktype.class = MPI_ERR_LOCKTYPE;
|
||||
ompi_errclass_locktype.cls = MPI_ERR_LOCKTYPE;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_LOCKTYPE, &ompi_errclass_locktype);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_name, ompi_errclass_t);
|
||||
ompi_errclass_name.class = MPI_ERR_NAME;
|
||||
ompi_errclass_name.cls = MPI_ERR_NAME;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_NAME, &ompi_errclass_name);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_no_mem, ompi_errclass_t);
|
||||
ompi_errclass_no_mem.class = MPI_ERR_NO_MEM;
|
||||
ompi_errclass_no_mem.cls = MPI_ERR_NO_MEM;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_NO_MEM, &ompi_errclass_no_mem);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_not_same, ompi_errclass_t);
|
||||
ompi_errclass_not_same.class = MPI_ERR_NOT_SAME;
|
||||
ompi_errclass_not_same.cls = MPI_ERR_NOT_SAME;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_NOT_SAME, &ompi_errclass_not_same);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_no_space, ompi_errclass_t);
|
||||
ompi_errclass_no_space.class = MPI_ERR_NO_SPACE;
|
||||
ompi_errclass_no_space.cls = MPI_ERR_NO_SPACE;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_NO_SPACE, &ompi_errclass_no_space);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_no_such_file, ompi_errclass_t);
|
||||
ompi_errclass_no_such_file.class = MPI_ERR_NO_SUCH_FILE;
|
||||
ompi_errclass_no_such_file.cls = MPI_ERR_NO_SUCH_FILE;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_NO_SUCH_FILE, &ompi_errclass_no_such_file);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_port, ompi_errclass_t);
|
||||
ompi_errclass_port.class = MPI_ERR_PORT;
|
||||
ompi_errclass_port.cls = MPI_ERR_PORT;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_PORT, &ompi_errclass_port);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_quota, ompi_errclass_t);
|
||||
ompi_errclass_quota.class = MPI_ERR_QUOTA;
|
||||
ompi_errclass_quota.cls = MPI_ERR_QUOTA;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_QUOTA, &ompi_errclass_quota);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_read_only, ompi_errclass_t);
|
||||
ompi_errclass_read_only.class = MPI_ERR_READ_ONLY;
|
||||
ompi_errclass_read_only.cls = MPI_ERR_READ_ONLY;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_READ_ONLY, &ompi_errclass_read_only);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_rma_conflict, ompi_errclass_t);
|
||||
ompi_errclass_rma_conflict.class = MPI_ERR_RMA_CONFLICT;
|
||||
ompi_errclass_rma_conflict.cls = MPI_ERR_RMA_CONFLICT;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_RMA_CONFLICT, &ompi_errclass_rma_conflict);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_rma_sync, ompi_errclass_t);
|
||||
ompi_errclass_rma_sync.class = MPI_ERR_RMA_SYNC;
|
||||
ompi_errclass_rma_sync.cls = MPI_ERR_RMA_SYNC;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_RMA_SYNC, &ompi_errclass_rma_sync);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_service, ompi_errclass_t);
|
||||
ompi_errclass_service.class = MPI_ERR_SERVICE;
|
||||
ompi_errclass_service.cls = MPI_ERR_SERVICE;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_SERVICE, &ompi_errclass_service);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_size, ompi_errclass_t);
|
||||
ompi_errclass_size.class = MPI_ERR_SIZE;
|
||||
ompi_errclass_size.cls = MPI_ERR_SIZE;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_SIZE, &ompi_errclass_size);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_spawn, ompi_errclass_t);
|
||||
ompi_errclass_spawn.class = MPI_ERR_SPAWN;
|
||||
ompi_errclass_spawn.cls = MPI_ERR_SPAWN;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_SPAWN, &ompi_errclass_spawn);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_unsupported_datarep, ompi_errclass_t);
|
||||
ompi_errclass_unsupported_datarep.class = MPI_ERR_UNSUPPORTED_DATAREP;
|
||||
ompi_errclass_unsupported_datarep.cls = MPI_ERR_UNSUPPORTED_DATAREP;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_UNSUPPORTED_DATAREP,
|
||||
&ompi_errclass_unsupported_datarep);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_unsupported_operation, ompi_errclass_t);
|
||||
ompi_errclass_unsupported_operation.class = MPI_ERR_UNSUPPORTED_OPERATION;
|
||||
ompi_errclass_unsupported_operation.cls = MPI_ERR_UNSUPPORTED_OPERATION;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_UNSUPPORTED_OPERATION,
|
||||
&ompi_errclass_unsupported_operation);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_errclass_win, ompi_errclass_t);
|
||||
ompi_errclass_win.class = MPI_ERR_WIN;
|
||||
ompi_errclass_win.cls = MPI_ERR_WIN;
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, MPI_ERR_WIN, &ompi_errclass_win);
|
||||
|
||||
ompi_errclass_lastused=MPI_ERR_WIN+1;
|
||||
@ -320,7 +320,7 @@ int ompi_errclass_finalize(void)
|
||||
/*
|
||||
* Release user defined error classes
|
||||
*/
|
||||
errc = ompi_pointer_array_get_item(&ompi_errclasses, i);
|
||||
errc = (ompi_errclass_t *)ompi_pointer_array_get_item(&ompi_errclasses, i);
|
||||
OBJ_RELEASE (errc);
|
||||
}
|
||||
|
||||
@ -388,21 +388,21 @@ int ompi_errclass_add(void)
|
||||
ompi_errclass_t *newerrclass;
|
||||
|
||||
newerrclass = OBJ_NEW(ompi_errclass_t);
|
||||
newerrclass->class = ompi_errclass_lastused;
|
||||
newerrclass->cls = ompi_errclass_lastused;
|
||||
ompi_errclass_lastused++;
|
||||
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, newerrclass->class, newerrclass);
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, newerrclass->cls, newerrclass);
|
||||
return OMPI_SUCCESS;
|
||||
}
|
||||
|
||||
static void ompi_errclass_construct(ompi_errclass_t *errclass)
|
||||
{
|
||||
errclass->class = MPI_UNDEFINED;
|
||||
errclass->cls = MPI_UNDEFINED;
|
||||
return;
|
||||
}
|
||||
|
||||
static void ompi_errclass_destruct(ompi_errclass_t *errclass)
|
||||
{
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, errclass->class, NULL);
|
||||
ompi_pointer_array_set_item(&ompi_errclasses, errclass->cls, NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -19,7 +19,7 @@
|
||||
*/
|
||||
struct ompi_errclass_t {
|
||||
ompi_object_t super;
|
||||
int class;
|
||||
int cls;
|
||||
};
|
||||
typedef struct ompi_errclass_t ompi_errclass_t;
|
||||
|
||||
|
||||
@ -87,315 +87,315 @@ int ompi_mpi_errcode_init (void)
|
||||
it in the pointer-array. */
|
||||
OBJ_CONSTRUCT(&ompi_success, ompi_mpi_errcode_t);
|
||||
ompi_success.code = MPI_SUCCESS;
|
||||
ompi_success.class = MPI_SUCCESS;
|
||||
ompi_success.cls = MPI_SUCCESS;
|
||||
strcpy(ompi_success.errstring, "MPI_SUCCESS: no errors");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_SUCCESS, &ompi_success);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_buffer, ompi_mpi_errcode_t);
|
||||
ompi_err_buffer.code = MPI_ERR_BUFFER;
|
||||
ompi_err_buffer.class = MPI_ERR_BUFFER;
|
||||
ompi_err_buffer.cls = MPI_ERR_BUFFER;
|
||||
strcpy(ompi_err_buffer.errstring, "MPI_ERR_BUFFER: invalid buffer pointer");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_BUFFER, &ompi_err_buffer);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_count, ompi_mpi_errcode_t);
|
||||
ompi_err_count.code = MPI_ERR_COUNT;
|
||||
ompi_err_count.class = MPI_ERR_COUNT;
|
||||
ompi_err_count.cls = MPI_ERR_COUNT;
|
||||
strcpy(ompi_err_count.errstring, "MPI_ERR_COUNT: invalid count argument");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_COUNT, &ompi_err_count);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_type, ompi_mpi_errcode_t);
|
||||
ompi_err_type.code = MPI_ERR_TYPE;
|
||||
ompi_err_type.class = MPI_ERR_TYPE;
|
||||
ompi_err_type.cls = MPI_ERR_TYPE;
|
||||
strcpy(ompi_err_type.errstring, "MPI_ERR_TYPE: invalid datatype");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_TYPE, &ompi_err_type);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_tag, ompi_mpi_errcode_t);
|
||||
ompi_err_tag.code = MPI_ERR_TAG;
|
||||
ompi_err_tag.class = MPI_ERR_TAG;
|
||||
ompi_err_tag.cls = MPI_ERR_TAG;
|
||||
strcpy(ompi_err_tag.errstring, "MPI_ERR_TAG: invalid tag");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_TAG, &ompi_err_tag);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_comm, ompi_mpi_errcode_t);
|
||||
ompi_err_comm.code = MPI_ERR_COMM;
|
||||
ompi_err_comm.class = MPI_ERR_COMM;
|
||||
ompi_err_comm.cls = MPI_ERR_COMM;
|
||||
strcpy(ompi_err_comm.errstring, "MPI_ERR_COMM: invalid communicator");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_COMM, &ompi_err_comm);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_rank, ompi_mpi_errcode_t);
|
||||
ompi_err_rank.code = MPI_ERR_RANK;
|
||||
ompi_err_rank.class = MPI_ERR_RANK;
|
||||
ompi_err_rank.cls = MPI_ERR_RANK;
|
||||
strcpy(ompi_err_rank.errstring, "MPI_ERR_RANK: invalid rank");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_RANK, &ompi_err_rank);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_request, ompi_mpi_errcode_t);
|
||||
ompi_err_request.code = MPI_ERR_REQUEST;
|
||||
ompi_err_request.class = MPI_ERR_REQUEST;
|
||||
ompi_err_request.cls = MPI_ERR_REQUEST;
|
||||
strcpy(ompi_err_request.errstring, "MPI_ERR_REQUEST: invalid request");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_REQUEST, &ompi_err_request);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_root, ompi_mpi_errcode_t);
|
||||
ompi_err_root.code = MPI_ERR_ROOT;
|
||||
ompi_err_root.class = MPI_ERR_ROOT;
|
||||
ompi_err_root.cls = MPI_ERR_ROOT;
|
||||
strcpy(ompi_err_root.errstring, "MPI_ERR_ROOT: invalid root");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_ROOT, &ompi_err_root);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_group, ompi_mpi_errcode_t);
|
||||
ompi_err_group.code = MPI_ERR_GROUP;
|
||||
ompi_err_group.class = MPI_ERR_GROUP;
|
||||
ompi_err_group.cls = MPI_ERR_GROUP;
|
||||
strcpy(ompi_err_group.errstring, "MPI_ERR_GROUP: invalid group");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_GROUP, &ompi_err_group);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_op, ompi_mpi_errcode_t);
|
||||
ompi_err_op.code = MPI_ERR_OP;
|
||||
ompi_err_op.class = MPI_ERR_OP;
|
||||
ompi_err_op.cls = MPI_ERR_OP;
|
||||
strcpy(ompi_err_op.errstring, "MPI_ERR_OP: invalid reduce operation");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_OP, &ompi_err_op);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_topology, ompi_mpi_errcode_t);
|
||||
ompi_err_topology.code = MPI_ERR_TOPOLOGY;
|
||||
ompi_err_topology.class = MPI_ERR_TOPOLOGY;
|
||||
ompi_err_topology.cls = MPI_ERR_TOPOLOGY;
|
||||
strcpy(ompi_err_topology.errstring, "MPI_ERR_TOPOLOGY: invalid communicator topology");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_TOPOLOGY, &ompi_err_topology);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_dims, ompi_mpi_errcode_t);
|
||||
ompi_err_dims.code = MPI_ERR_DIMS;
|
||||
ompi_err_dims.class = MPI_ERR_DIMS;
|
||||
ompi_err_dims.cls = MPI_ERR_DIMS;
|
||||
strcpy(ompi_err_dims.errstring, "MPI_ERR_DIMS: invalid topology dimension");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_DIMS, &ompi_err_dims);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_arg, ompi_mpi_errcode_t);
|
||||
ompi_err_arg.code = MPI_ERR_ARG;
|
||||
ompi_err_arg.class = MPI_ERR_ARG;
|
||||
ompi_err_arg.cls = MPI_ERR_ARG;
|
||||
strcpy(ompi_err_arg.errstring, "MPI_ERR_ARG: invalid argument of some other kind");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_ARG, &ompi_err_arg);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_unknown, ompi_mpi_errcode_t);
|
||||
ompi_err_unknown.code = MPI_ERR_UNKNOWN;
|
||||
ompi_err_unknown.class = MPI_ERR_UNKNOWN;
|
||||
ompi_err_unknown.cls = MPI_ERR_UNKNOWN;
|
||||
strcpy(ompi_err_unknown.errstring, "MPI_ERR_UNKNOWN: unknown error");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_UNKNOWN, &ompi_err_unknown);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_truncate, ompi_mpi_errcode_t);
|
||||
ompi_err_truncate.code = MPI_ERR_TRUNCATE;
|
||||
ompi_err_truncate.class = MPI_ERR_TRUNCATE;
|
||||
ompi_err_truncate.cls = MPI_ERR_TRUNCATE;
|
||||
strcpy(ompi_err_truncate.errstring, "MPI_ERR_TRUNCATE: message truncated");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_TRUNCATE, &ompi_err_truncate);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_other, ompi_mpi_errcode_t);
|
||||
ompi_err_other.code = MPI_ERR_OTHER;
|
||||
ompi_err_other.class = MPI_ERR_OTHER;
|
||||
ompi_err_other.cls = MPI_ERR_OTHER;
|
||||
strcpy(ompi_err_other.errstring, "MPI_ERR_OTHER: known error not in list");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_OTHER, &ompi_err_other);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_intern, ompi_mpi_errcode_t);
|
||||
ompi_err_intern.code = MPI_ERR_INTERN;
|
||||
ompi_err_intern.class = MPI_ERR_INTERN;
|
||||
ompi_err_intern.cls = MPI_ERR_INTERN;
|
||||
strcpy(ompi_err_intern.errstring, "MPI_ERR_INTERN: internal error");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_INTERN, &ompi_err_intern);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_in_status, ompi_mpi_errcode_t);
|
||||
ompi_err_in_status.code = MPI_ERR_IN_STATUS;
|
||||
ompi_err_in_status.class = MPI_ERR_IN_STATUS;
|
||||
ompi_err_in_status.cls = MPI_ERR_IN_STATUS;
|
||||
strcpy(ompi_err_in_status.errstring, "MPI_ERR_IN_STATUS: error code in status");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_IN_STATUS, &ompi_err_in_status);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_pending, ompi_mpi_errcode_t);
|
||||
ompi_err_pending.code = MPI_ERR_PENDING;
|
||||
ompi_err_pending.class = MPI_ERR_PENDING;
|
||||
ompi_err_pending.cls = MPI_ERR_PENDING;
|
||||
strcpy(ompi_err_pending.errstring, "MPI_ERR_PENDING: pending request");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_PENDING, &ompi_err_pending);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_access, ompi_mpi_errcode_t);
|
||||
ompi_err_access.code = MPI_ERR_ACCESS;
|
||||
ompi_err_access.class = MPI_ERR_ACCESS;
|
||||
ompi_err_access.cls = MPI_ERR_ACCESS;
|
||||
strcpy(ompi_err_access.errstring, "MPI_ERR_ACCESS: invalid access mode");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_ACCESS, &ompi_err_access);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_amode, ompi_mpi_errcode_t);
|
||||
ompi_err_amode.code = MPI_ERR_AMODE;
|
||||
ompi_err_amode.class = MPI_ERR_AMODE;
|
||||
ompi_err_amode.cls = MPI_ERR_AMODE;
|
||||
strcpy(ompi_err_amode.errstring, "MPI_ERR_AMODE: invalid amode argument");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_AMODE, &ompi_err_amode);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_assert, ompi_mpi_errcode_t);
|
||||
ompi_err_assert.code = MPI_ERR_ASSERT;
|
||||
ompi_err_assert.class = MPI_ERR_ASSERT;
|
||||
ompi_err_assert.cls = MPI_ERR_ASSERT;
|
||||
strcpy(ompi_err_assert.errstring, "MPI_ERR_ASSERT: invalid assert argument");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_ASSERT, &ompi_err_assert);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_bad_file, ompi_mpi_errcode_t);
|
||||
ompi_err_bad_file.code = MPI_ERR_BAD_FILE;
|
||||
ompi_err_bad_file.class = MPI_ERR_BAD_FILE;
|
||||
ompi_err_bad_file.cls = MPI_ERR_BAD_FILE;
|
||||
strcpy(ompi_err_bad_file.errstring, "MPI_ERR_BAD_FILE: bad file");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_BAD_FILE, &ompi_err_bad_file);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_base, ompi_mpi_errcode_t);
|
||||
ompi_err_base.code = MPI_ERR_BASE;
|
||||
ompi_err_base.class = MPI_ERR_BASE;
|
||||
ompi_err_base.cls = MPI_ERR_BASE;
|
||||
strcpy(ompi_err_base.errstring, "MPI_ERR_BASE: invalid base");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_BASE, &ompi_err_base);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_conversion, ompi_mpi_errcode_t);
|
||||
ompi_err_conversion.code = MPI_ERR_CONVERSION;
|
||||
ompi_err_conversion.class = MPI_ERR_CONVERSION;
|
||||
ompi_err_conversion.cls = MPI_ERR_CONVERSION;
|
||||
strcpy(ompi_err_conversion.errstring, "MPI_ERR_CONVERSION: error in data conversion");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_CONVERSION, &ompi_err_conversion);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_disp, ompi_mpi_errcode_t);
|
||||
ompi_err_disp.code = MPI_ERR_DISP;
|
||||
ompi_err_disp.class = MPI_ERR_DISP;
|
||||
ompi_err_disp.cls = MPI_ERR_DISP;
|
||||
strcpy(ompi_err_disp.errstring, "MPI_ERR_DISP: invalid displacement");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_DISP, &ompi_err_disp);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_dup_datarep, ompi_mpi_errcode_t);
|
||||
ompi_err_dup_datarep.code = MPI_ERR_DUP_DATAREP;
|
||||
ompi_err_dup_datarep.class = MPI_ERR_DUP_DATAREP;
|
||||
ompi_err_dup_datarep.cls = MPI_ERR_DUP_DATAREP;
|
||||
strcpy(ompi_err_dup_datarep.errstring,
|
||||
"MPI_ERR_DUP_DATAREP: error while duplicating data representation");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_DUP_DATAREP, &ompi_err_dup_datarep);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_file_exists, ompi_mpi_errcode_t);
|
||||
ompi_err_file_exists.code = MPI_ERR_FILE_EXISTS;
|
||||
ompi_err_file_exists.class = MPI_ERR_FILE_EXISTS;
|
||||
ompi_err_file_exists.cls = MPI_ERR_FILE_EXISTS;
|
||||
strcpy(ompi_err_file_exists.errstring, "MPI_ERR_FILE_EXISTS: file exists alreay");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_FILE_EXISTS, &ompi_err_file_exists);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_file_in_use, ompi_mpi_errcode_t);
|
||||
ompi_err_file_in_use.code = MPI_ERR_FILE_IN_USE;
|
||||
ompi_err_file_in_use.class = MPI_ERR_FILE_IN_USE;
|
||||
ompi_err_file_in_use.cls = MPI_ERR_FILE_IN_USE;
|
||||
strcpy(ompi_err_file_in_use.errstring, "MPI_ERR_FILE_IN_USE: file already in use");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_FILE_IN_USE, &ompi_err_file_in_use);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_file, ompi_mpi_errcode_t);
|
||||
ompi_err_file.code = MPI_ERR_FILE;
|
||||
ompi_err_file.class = MPI_ERR_FILE;
|
||||
ompi_err_file.cls = MPI_ERR_FILE;
|
||||
strcpy(ompi_err_file.errstring, "MPI_ERR_FILE: invalid file");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_FILE, &ompi_err_file);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_info_key, ompi_mpi_errcode_t);
|
||||
ompi_err_info_key.code = MPI_ERR_INFO_KEY;
|
||||
ompi_err_info_key.class = MPI_ERR_INFO_KEY;
|
||||
ompi_err_info_key.cls = MPI_ERR_INFO_KEY;
|
||||
strcpy(ompi_err_info_key.errstring, "MPI_ERR_INFO_KEY: invalid key argument for info object");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_INFO_KEY, &ompi_err_info_key);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_info_nokey, ompi_mpi_errcode_t);
|
||||
ompi_err_info_nokey.code = MPI_ERR_INFO_NOKEY;
|
||||
ompi_err_info_nokey.class = MPI_ERR_INFO_NOKEY;
|
||||
ompi_err_info_nokey.cls = MPI_ERR_INFO_NOKEY;
|
||||
strcpy(ompi_err_info_nokey.errstring, "MPI_ERR_INFO_NOKEY: unknown key for given info object");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_INFO_NOKEY, &ompi_err_info_nokey);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_info_value, ompi_mpi_errcode_t);
|
||||
ompi_err_info_value.code = MPI_ERR_INFO_VALUE;
|
||||
ompi_err_info_value.class = MPI_ERR_INFO_VALUE;
|
||||
ompi_err_info_value.cls = MPI_ERR_INFO_VALUE;
|
||||
strcpy(ompi_err_info_value.errstring,
|
||||
"MPI_ERR_INFO_VALUE: invalid value argument for info object");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_INFO_VALUE, &ompi_err_info_value);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_info, ompi_mpi_errcode_t);
|
||||
ompi_err_info.code = MPI_ERR_INFO;
|
||||
ompi_err_info.class = MPI_ERR_INFO;
|
||||
ompi_err_info.cls = MPI_ERR_INFO;
|
||||
strcpy(ompi_err_info.errstring, "MPI_ERR_INFO: invalid info object");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_INFO, &ompi_err_info);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_io, ompi_mpi_errcode_t);
|
||||
ompi_err_io.code = MPI_ERR_IO;
|
||||
ompi_err_io.class = MPI_ERR_IO;
|
||||
ompi_err_io.cls = MPI_ERR_IO;
|
||||
strcpy(ompi_err_io.errstring, "MPI_ERR_IO: input/output error");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_IO, &ompi_err_io);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_keyval, ompi_mpi_errcode_t);
|
||||
ompi_err_keyval.code = MPI_ERR_KEYVAL;
|
||||
ompi_err_keyval.class = MPI_ERR_KEYVAL;
|
||||
ompi_err_keyval.cls = MPI_ERR_KEYVAL;
|
||||
strcpy(ompi_err_keyval.errstring, "MPI_ERR_KEYVAL: invalid key value");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_KEYVAL, &ompi_err_keyval);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_locktype, ompi_mpi_errcode_t);
|
||||
ompi_err_locktype.code = MPI_ERR_LOCKTYPE;
|
||||
ompi_err_locktype.class = MPI_ERR_LOCKTYPE;
|
||||
ompi_err_locktype.cls = MPI_ERR_LOCKTYPE;
|
||||
strcpy(ompi_err_locktype.errstring, "MPI_ERR_LOCKTYPE: invalid lock");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_LOCKTYPE, &ompi_err_locktype);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_name, ompi_mpi_errcode_t);
|
||||
ompi_err_name.code = MPI_ERR_NAME;
|
||||
ompi_err_name.class = MPI_ERR_NAME;
|
||||
ompi_err_name.cls = MPI_ERR_NAME;
|
||||
strcpy(ompi_err_name.errstring, "MPI_ERR_NAME: invalid name argument");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_NAME, &ompi_err_name);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_no_mem, ompi_mpi_errcode_t);
|
||||
ompi_err_no_mem.code = MPI_ERR_NO_MEM;
|
||||
ompi_err_no_mem.class = MPI_ERR_NO_MEM;
|
||||
ompi_err_no_mem.cls = MPI_ERR_NO_MEM;
|
||||
strcpy(ompi_err_no_mem.errstring, "MPI_ERR_NO_MEM: out of memory");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_NO_MEM, &ompi_err_no_mem);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_not_same, ompi_mpi_errcode_t);
|
||||
ompi_err_not_same.code = MPI_ERR_NOT_SAME;
|
||||
ompi_err_not_same.class = MPI_ERR_NOT_SAME;
|
||||
ompi_err_not_same.cls = MPI_ERR_NOT_SAME;
|
||||
strcpy(ompi_err_not_same.errstring, "MPI_ERR_NOT_SAME: objects are not identical");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_NOT_SAME, &ompi_err_not_same);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_no_space, ompi_mpi_errcode_t);
|
||||
ompi_err_no_space.code = MPI_ERR_NO_SPACE;
|
||||
ompi_err_no_space.class = MPI_ERR_NO_SPACE;
|
||||
ompi_err_no_space.cls = MPI_ERR_NO_SPACE;
|
||||
strcpy(ompi_err_no_space.errstring, "MPI_ERR_NO_SPACE: no space left on device");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_NO_SPACE, &ompi_err_no_space);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_no_such_file, ompi_mpi_errcode_t);
|
||||
ompi_err_no_such_file.code = MPI_ERR_NO_SUCH_FILE;
|
||||
ompi_err_no_such_file.class = MPI_ERR_NO_SUCH_FILE;
|
||||
ompi_err_no_such_file.cls = MPI_ERR_NO_SUCH_FILE;
|
||||
strcpy(ompi_err_no_such_file.errstring, "MPI_ERR_NO_SUCH_FILE: no such file or directory");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_NO_SUCH_FILE, &ompi_err_no_such_file);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_port, ompi_mpi_errcode_t);
|
||||
ompi_err_port.code = MPI_ERR_PORT;
|
||||
ompi_err_port.class = MPI_ERR_PORT;
|
||||
ompi_err_port.cls = MPI_ERR_PORT;
|
||||
strcpy(ompi_err_port.errstring, "MPI_ERR_PORT: MPI_ERR_PORT: invalid port");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_PORT, &ompi_err_port);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_quota, ompi_mpi_errcode_t);
|
||||
ompi_err_quota.code = MPI_ERR_QUOTA;
|
||||
ompi_err_quota.class = MPI_ERR_QUOTA;
|
||||
ompi_err_quota.cls = MPI_ERR_QUOTA;
|
||||
strcpy(ompi_err_quota.errstring, "MPI_ERR_QUOTA: out of quota");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_QUOTA, &ompi_err_quota);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_read_only, ompi_mpi_errcode_t);
|
||||
ompi_err_read_only.code = MPI_ERR_READ_ONLY;
|
||||
ompi_err_read_only.class = MPI_ERR_READ_ONLY;
|
||||
ompi_err_read_only.cls = MPI_ERR_READ_ONLY;
|
||||
strcpy(ompi_err_read_only.errstring, "MPI_ERR_READ_ONLY: file is read only");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_READ_ONLY, &ompi_err_read_only);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_rma_conflict, ompi_mpi_errcode_t);
|
||||
ompi_err_rma_conflict.code = MPI_ERR_RMA_CONFLICT;
|
||||
ompi_err_rma_conflict.class = MPI_ERR_RMA_CONFLICT;
|
||||
ompi_err_rma_conflict.cls = MPI_ERR_RMA_CONFLICT;
|
||||
strcpy(ompi_err_rma_conflict.errstring, "MPI_ERR_RMA_CONFLICT: rma conflict during operation");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_RMA_CONFLICT, &ompi_err_rma_conflict);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_rma_sync, ompi_mpi_errcode_t);
|
||||
ompi_err_rma_sync.code = MPI_ERR_RMA_SYNC;
|
||||
ompi_err_rma_sync.class = MPI_ERR_RMA_SYNC;
|
||||
ompi_err_rma_sync.cls = MPI_ERR_RMA_SYNC;
|
||||
strcpy(ompi_err_rma_sync.errstring, "MPI_ERR_RMA_SYNC: error while executing rma sync");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_RMA_SYNC, &ompi_err_rma_sync);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_service, ompi_mpi_errcode_t);
|
||||
ompi_err_service.code = MPI_ERR_SERVICE;
|
||||
ompi_err_service.class = MPI_ERR_SERVICE;
|
||||
ompi_err_service.cls = MPI_ERR_SERVICE;
|
||||
strcpy(ompi_err_service.errstring, "MPI_ERR_SERVICE: unknown service name");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_SERVICE, &ompi_err_service);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_size, ompi_mpi_errcode_t);
|
||||
ompi_err_size.code = MPI_ERR_SIZE;
|
||||
ompi_err_size.class = MPI_ERR_SIZE;
|
||||
ompi_err_size.cls = MPI_ERR_SIZE;
|
||||
strcpy(ompi_err_size.errstring, "MPI_ERR_SIZE: invalid size");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_SIZE, &ompi_err_size);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_spawn, ompi_mpi_errcode_t);
|
||||
ompi_err_spawn.code = MPI_ERR_SPAWN;
|
||||
ompi_err_spawn.class = MPI_ERR_SPAWN;
|
||||
ompi_err_spawn.cls = MPI_ERR_SPAWN;
|
||||
strcpy(ompi_err_spawn.errstring, "MPI_ERR_SPAWN: could not spawn processes");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_SPAWN, &ompi_err_spawn);
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_unsupported_datarep, ompi_mpi_errcode_t);
|
||||
ompi_err_unsupported_datarep.code = MPI_ERR_UNSUPPORTED_DATAREP;
|
||||
ompi_err_unsupported_datarep.class = MPI_ERR_UNSUPPORTED_DATAREP;
|
||||
ompi_err_unsupported_datarep.cls = MPI_ERR_UNSUPPORTED_DATAREP;
|
||||
strcpy(ompi_err_unsupported_datarep.errstring,
|
||||
"MPI_ERR_UNSUPPORTED_DATAREP: requested data representation not supported");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_UNSUPPORTED_DATAREP,
|
||||
@ -403,7 +403,7 @@ int ompi_mpi_errcode_init (void)
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_unsupported_operation, ompi_mpi_errcode_t);
|
||||
ompi_err_unsupported_operation.code = MPI_ERR_UNSUPPORTED_OPERATION;
|
||||
ompi_err_unsupported_operation.class = MPI_ERR_UNSUPPORTED_OPERATION;
|
||||
ompi_err_unsupported_operation.cls = MPI_ERR_UNSUPPORTED_OPERATION;
|
||||
strcpy(ompi_err_unsupported_operation.errstring,
|
||||
"MPI_ERR_UNSUPPORTED_OPERATION: requested operation not suppported");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_UNSUPPORTED_OPERATION,
|
||||
@ -411,7 +411,7 @@ int ompi_mpi_errcode_init (void)
|
||||
|
||||
OBJ_CONSTRUCT(&ompi_err_win, ompi_mpi_errcode_t);
|
||||
ompi_err_win.code = MPI_ERR_WIN;
|
||||
ompi_err_win.class = MPI_ERR_WIN;
|
||||
ompi_err_win.cls = MPI_ERR_WIN;
|
||||
strcpy(ompi_err_win.errstring, "MPI_ERR_WIN:invalid window");
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, MPI_ERR_WIN, &ompi_err_win);
|
||||
|
||||
@ -430,7 +430,7 @@ int ompi_mpi_errcode_finalize(void)
|
||||
* there are some user defined error-codes, which
|
||||
* we have to free.
|
||||
*/
|
||||
errc = ompi_pointer_array_get_item(&ompi_mpi_errcodes, i);
|
||||
errc = (ompi_mpi_errcode_t *)ompi_pointer_array_get_item(&ompi_mpi_errcodes, i);
|
||||
OBJ_RELEASE (errc);
|
||||
}
|
||||
|
||||
@ -499,7 +499,7 @@ int ompi_mpi_errcode_add(int errclass )
|
||||
|
||||
newerrcode = OBJ_NEW(ompi_mpi_errcode_t);
|
||||
newerrcode->code = ompi_mpi_errcode_lastused;
|
||||
newerrcode->class = errclass;
|
||||
newerrcode->cls = errclass;
|
||||
ompi_pointer_array_set_item(&ompi_mpi_errcodes, newerrcode->code, newerrcode);
|
||||
|
||||
ompi_mpi_errcode_lastused++;
|
||||
@ -510,7 +510,7 @@ int ompi_mpi_errcode_add_string(int errcode, char *errstring, int len)
|
||||
{
|
||||
ompi_mpi_errcode_t *errcodep;
|
||||
|
||||
errcodep = ompi_pointer_array_get_item(&ompi_mpi_errcodes, errcode);
|
||||
errcodep = (ompi_mpi_errcode_t *)ompi_pointer_array_get_item(&ompi_mpi_errcodes, errcode);
|
||||
if ( NULL == errcodep ) {
|
||||
return OMPI_ERROR;
|
||||
}
|
||||
@ -526,7 +526,7 @@ int ompi_mpi_errcode_add_string(int errcode, char *errstring, int len)
|
||||
static void ompi_mpi_errcode_construct(ompi_mpi_errcode_t *errcode)
|
||||
{
|
||||
errcode->code = MPI_UNDEFINED;
|
||||
errcode->class = MPI_UNDEFINED;
|
||||
errcode->cls = MPI_UNDEFINED;
|
||||
memset ( errcode->errstring, 0, MPI_MAX_ERROR_STRING);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -19,7 +19,7 @@
|
||||
struct ompi_mpi_errcode_t {
|
||||
ompi_object_t super;
|
||||
int code;
|
||||
int class;
|
||||
int cls;
|
||||
char errstring[MPI_MAX_ERROR_STRING];
|
||||
};
|
||||
typedef struct ompi_mpi_errcode_t ompi_mpi_errcode_t;
|
||||
@ -45,8 +45,8 @@ static inline int ompi_mpi_errcode_get_class (int errcode)
|
||||
{
|
||||
ompi_mpi_errcode_t *err;
|
||||
|
||||
err = ompi_pointer_array_get_item(&ompi_mpi_errcodes, errcode);
|
||||
return err->class;
|
||||
err = (ompi_mpi_errcode_t *)ompi_pointer_array_get_item(&ompi_mpi_errcodes, errcode);
|
||||
return err->cls;
|
||||
}
|
||||
/**
|
||||
* Return the error string
|
||||
@ -55,7 +55,7 @@ static inline char* ompi_mpi_errcode_get_string (int errcode)
|
||||
{
|
||||
ompi_mpi_errcode_t *err;
|
||||
|
||||
err = ompi_pointer_array_get_item(&ompi_mpi_errcodes, errcode);
|
||||
err = (ompi_mpi_errcode_t *)ompi_pointer_array_get_item(&ompi_mpi_errcodes, errcode);
|
||||
return err->errstring;
|
||||
}
|
||||
|
||||
|
||||
@ -149,7 +149,7 @@ int ompi_file_finalize(void)
|
||||
|
||||
max = ompi_pointer_array_get_size(&ompi_file_f_to_c_table);
|
||||
for (num_unnamed = i = 0; i < max; ++i) {
|
||||
file = ompi_pointer_array_get_item(&ompi_file_f_to_c_table, i);
|
||||
file = (ompi_file_t *)ompi_pointer_array_get_item(&ompi_file_f_to_c_table, i);
|
||||
|
||||
/* If the file was closed but still exists because the user
|
||||
told us to never free handles, then do an OBJ_RELEASE it
|
||||
@ -159,7 +159,7 @@ int ompi_file_finalize(void)
|
||||
if (NULL != file && ompi_debug_no_free_handles &&
|
||||
0 == (file->f_flags & OMPI_FILE_ISCLOSED)) {
|
||||
OBJ_RELEASE(file);
|
||||
file = ompi_pointer_array_get_item(&ompi_file_f_to_c_table, i);
|
||||
file = (ompi_file_t *)ompi_pointer_array_get_item(&ompi_file_f_to_c_table, i);
|
||||
}
|
||||
|
||||
if (NULL != file) {
|
||||
|
||||
@ -45,7 +45,7 @@ ompi_group_t *ompi_group_allocate(int group_size)
|
||||
} else {
|
||||
/* allocate array of (ompi_proc_t *)'s, one for each
|
||||
* process in the group */
|
||||
new_group->grp_proc_pointers =
|
||||
new_group->grp_proc_pointers = (ompi_proc_t **)
|
||||
malloc(sizeof(ompi_proc_t *) * group_size);
|
||||
if (0 < group_size) {
|
||||
/* non-empty group */
|
||||
|
||||
@ -286,7 +286,7 @@ int ompi_info_finalize(void)
|
||||
|
||||
max = ompi_pointer_array_get_size(&ompi_info_f_to_c_table);
|
||||
for (i = 0; i < max; ++i) {
|
||||
info = ompi_pointer_array_get_item(&ompi_info_f_to_c_table, i);
|
||||
info = (ompi_info_t *)ompi_pointer_array_get_item(&ompi_info_f_to_c_table, i);
|
||||
|
||||
/* If the info was freed but still exists because the user
|
||||
told us to never free handles, then do an OBJ_RELEASE it
|
||||
@ -295,7 +295,7 @@ int ompi_info_finalize(void)
|
||||
|
||||
if (NULL != info && ompi_debug_no_free_handles && info->i_freed) {
|
||||
OBJ_RELEASE(info);
|
||||
info = ompi_pointer_array_get_item(&ompi_info_f_to_c_table, i);
|
||||
info = (ompi_info_t *)ompi_pointer_array_get_item(&ompi_info_f_to_c_table, i);
|
||||
}
|
||||
|
||||
/* If it still exists here and was never freed, then it's an
|
||||
|
||||
Загрузка…
x
Ссылка в новой задаче
Block a user