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

Bunches of cleanup in dps:

Просмотр исходного кода 
- remove all tabs from source code (replace with spaces)
- use size of size_t and int to determine some equivalent ORTE types
  in a header file so that it's always done consistently (at compile
  time)
- be consistent about using size_t for number of elements that are
  packed
- don't assume that size_t is uint32_t (it is uint64_t on some
  platforms)
- simplify some logic
- implement packing/unpacking for INT64 and UINT64 (so that we can do
  size_t on platforms where it's 64 bits)

This commit was SVN r5172.
Этот коммит содержится в:
Jeff Squyres 2005-04-05 02:32:36 +00:00
родитель 205ed1d9d9
Коммит 447201de15
5 изменённых файлов: 276 добавлений и 239 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

1
configure.ac
Просмотреть файл

@ -184,6 +184,7 @@ fi
AC_CHECK_SIZEOF(float)
AC_CHECK_SIZEOF(double)
AC_CHECK_SIZEOF(void *)
AC_CHECK_SIZEOF(size_t)
#
# Check for type alignments

34
src/dps/dps_internal.h
Просмотреть файл

@ -33,6 +33,40 @@ extern "C" {
*/
#define ORTE_DPS_DEFAULT_PAGE_SIZE 1
/*
* ORTE type corresponding to size_t
*/
#if SIZEOF_SIZE_T == 1
#define DPS_TYPE_SIZE_T ORTE_UINT8
#elif SIZEOF_SIZE_T == 2
#define DPS_TYPE_SIZE_T ORTE_UINT16
#elif SIZEOF_SIZE_T == 4
#define DPS_TYPE_SIZE_T ORTE_UINT32
#elif SIZEOF_SIZE_T == 8
#define DPS_TYPE_SIZE_T ORTE_UINT64
#else
#error Unsupported size_t size!
#endif
/*
* ORTE type corresponding to int and unsigned int
*/
#if SIZEOF_INT == 1
#define DPS_TYPE_INT ORTE_INT8
#define DPS_TYPE_UINT ORTE_UINT8
#elif SIZEOF_INT == 2
#define DPS_TYPE_INT ORTE_INT16
#define DPS_TYPE_UINT ORTE_UINT16
#elif SIZEOF_INT == 4
#define DPS_TYPE_INT ORTE_INT32
#define DPS_TYPE_UINT ORTE_UINT32
#elif SIZEOF_INT == 8
#define DPS_TYPE_INT ORTE_INT64
#define DPS_TYPE_UINT ORTE_UINT64
#else
#error Unsupported int size!
#endif
/*
* globals needed within dps
*/

271
src/dps/dps_pack.c
Просмотреть файл

@ -49,37 +49,31 @@ int orte_dps_pack(orte_buffer_t *buffer, void *src,
int32_t op_size=0;
size_t num_bytes, hdr_bytes;
/* hdr_bytes = header for each packed type. */
/* num_bytes = packed size of data type. */
/* op_size = total size = (num_bytes+hdr_bytes) */
/* hdr_bytes = header for each packed type. */
/* num_bytes = packed size of data type. */
/* op_size = total size = (num_bytes+hdr_bytes) */
/* check for error */
if (!buffer || !src || 0 >= num_vals) { return (ORTE_ERROR); }
if (!buffer || !src || 0 >= num_vals) {
return (ORTE_ERROR);
}
dst = buffer->data_ptr; /* get location in buffer */
/* change into to fixed size type for local size */
if (ORTE_INT == type || ORTE_UINT == type) {
switch(sizeof(int)) {
case 1:
type = (type == ORTE_INT) ? ORTE_INT8 : ORTE_UINT8;
break;
case 2:
type = (type == ORTE_INT) ? ORTE_INT16 : ORTE_UINT16;
break;
case 4:
type = (type == ORTE_INT) ? ORTE_INT32 : ORTE_UINT32;
break;
case 8:
type = (type == ORTE_INT) ? ORTE_INT64 : ORTE_UINT64;
break;
default:
return ORTE_ERR_NOT_IMPLEMENTED;
}
/* check for size of generic data types so they can be properly
packed NOTE we convert the generic data type flag to a hard
type for storage to handle heterogeneity */
if (ORTE_INT == type) {
type = DPS_TYPE_INT;
} else if (ORTE_UINT == type) {
type = DPS_TYPE_UINT;
} else if (ORTE_SIZE == type) {
type = DPS_TYPE_SIZE_T;
}
/* calculate the required memory size for this operation */
if (0 == (op_size = orte_dps_memory_required(src, num_vals, type))) { /* got error */
if (0 == (op_size = orte_dps_memory_required(src, num_vals, type))) {
/* got error */
return ORTE_ERROR;
}
@ -87,42 +81,19 @@ int orte_dps_pack(orte_buffer_t *buffer, void *src,
hdr_bytes = orte_dps_memory_required(NULL, 1, ORTE_DATA_TYPE);
/* add in the space to store the number of values */
hdr_bytes += sizeof(uint32_t);
hdr_bytes += sizeof(size_t);
/* total space needed */
op_size += hdr_bytes;
/* total space needed */
op_size += hdr_bytes;
/* check to see if current buffer has enough room */
if (op_size > buffer->space) { /* need to extend the buffer */
if (ORTE_SUCCESS != (rc = orte_dps_buffer_extend(buffer, op_size))) { /* got an error */
if (ORTE_SUCCESS != (rc = orte_dps_buffer_extend(buffer, op_size))) {
/* got an error */
return rc;
}
dst = buffer->data_ptr; /* need to reset the dst since it could have moved */
}
/* check for size of generic data types so they can be properly packed
* NOTE we convert the generic data type flag to a hard type for storage
* to handle heterogeneity
*/
if (ORTE_SIZE == type) {
switch(sizeof(size_t)) {
case 1:
type = (type == ORTE_SIZE) ? ORTE_INT8 : ORTE_UINT8;
break;
case 2:
type = (type == ORTE_SIZE) ? ORTE_INT16 : ORTE_UINT16;
break;
case 4:
type = (type == ORTE_SIZE) ? ORTE_INT32 : ORTE_UINT32;
break;
case 8:
type = (type == ORTE_SIZE) ? ORTE_INT64 : ORTE_UINT64;
break;
default:
return ORTE_ERR_NOT_IMPLEMENTED;
}
/* need to reset the dst since it could have moved */
dst = buffer->data_ptr;
}
/* store the data type */
@ -135,7 +106,7 @@ int orte_dps_pack(orte_buffer_t *buffer, void *src,
/* store the number of values as uint32_t */
if (ORTE_SUCCESS != (rc = orte_dps_pack_nobuffer(dst, &num_vals, 1,
ORTE_UINT32, &num_bytes))) {
DPS_TYPE_SIZE_T, &num_bytes))) {
return rc;
}
dst = (void *)((char*)dst + num_bytes);
@ -146,15 +117,16 @@ int orte_dps_pack(orte_buffer_t *buffer, void *src,
return rc;
}
/* debugging */
if (num_bytes+sizeof(uint32_t)+orte_dps_memory_required(NULL, 1, ORTE_DATA_TYPE) != (size_t)op_size) {
fprintf(stderr,"orte_dps_pack: Ops, num_bytes %d + headers %d = %d, but op_size was %d?!\n",
(int)num_bytes, (int)hdr_bytes, (int)(num_bytes+hdr_bytes), (int)op_size);
}
/* fflush(stdout); fflush(stderr); */
/* fprintf(stderr,"packed total of %d bytes. Hdr %d datatype %d\n", op_size, hdr_bytes, num_bytes); */
/* fflush(stdout); fflush(stderr); */
#if OMPI_ENABLE_DEBUG
/* debugging */
if (num_bytes+sizeof(size_t)+orte_dps_memory_required(NULL, 1, ORTE_DATA_TYPE) != (size_t)op_size) {
fprintf(stderr,"orte_dps_pack: Ops, num_bytes %d + headers %d = %d, but op_size was %d?!\n",
(int)num_bytes, (int)hdr_bytes, (int)(num_bytes+hdr_bytes), (int)op_size);
}
/* fflush(stdout); fflush(stderr); */
/* fprintf(stderr,"packed total of %d bytes. Hdr %d datatype %d\n", op_size, hdr_bytes, num_bytes); */
/* fflush(stdout); fflush(stderr); */
#endif
/* ok, we managed to pack some more stuff, so update all ptrs/cnts */
buffer->data_ptr = (void*)((char*)dst + num_bytes);
@ -170,10 +142,10 @@ int orte_dps_pack_nobuffer(void *dst, void *src, size_t num_vals,
orte_data_type_t type, size_t *num_bytes)
{
size_t i, len, n, elementsize;
char *dptr; /* my moving destination pointer */
uint16_t tmp_16; /* temp location of converted data */
uint32_t tmp_32; /* temp location of converted data */
orte_process_name_t tmp_procname; /* temp location of converted data */
char *dptr; /* my moving destination pointer */
uint16_t tmp_16; /* temp location of converted data */
uint32_t tmp_32; /* temp location of converted data */
orte_process_name_t tmp_procname; /* temp location of converted data */
uint16_t * s16;
uint32_t * s32;
@ -185,17 +157,14 @@ int orte_dps_pack_nobuffer(void *dst, void *src, size_t num_vals,
orte_byte_object_t *sbyteptr;
orte_gpr_keyval_t **keyval;
orte_gpr_value_t **values;
orte_app_context_t **app_context;
orte_app_context_map_t **app_context_map;
orte_app_context_t **app_context;
orte_app_context_map_t **app_context_map;
orte_gpr_subscription_t **subs;
orte_gpr_notify_data_t **data;
/* initialize the number of bytes */
*num_bytes = 0;
elementsize = 1024*1024*1024; /* instant memory fault on error */
/* pack the data */
switch(type) {
@ -216,14 +185,15 @@ int orte_dps_pack_nobuffer(void *dst, void *src, size_t num_vals,
case ORTE_GPR_CMD:
case ORTE_INT16:
case ORTE_UINT16:
dptr = (char *) dst;
s16 = (uint16_t *) src;
elementsize = sizeof (uint16_t);
dptr = (char *) dst;
s16 = (uint16_t *) src;
elementsize = sizeof (uint16_t);
for (i=0; i<num_vals; i++) {
/* convert the host order to network order */
tmp_16 = htons(*s16);
memcpy (dptr, (char*) &tmp_16, elementsize);
dptr+=elementsize; s16++;
memcpy (dptr, (char*) &tmp_16, elementsize);
dptr+=elementsize;
s16++;
}
*num_bytes = num_vals * elementsize;
break;
@ -234,21 +204,37 @@ int orte_dps_pack_nobuffer(void *dst, void *src, size_t num_vals,
case ORTE_GPR_NOTIFY_ID:
case ORTE_INT32:
case ORTE_UINT32:
dptr = (char *) dst;
s32 = (uint32_t *) src;
elementsize = sizeof (uint32_t);
dptr = (char *) dst;
s32 = (uint32_t *) src;
elementsize = sizeof (uint32_t);
for (i=0; i<num_vals; i++) {
/* convert the host order to network order */
tmp_32 = htonl(*s32);
memcpy (dptr, (char*) &tmp_32, elementsize);
dptr+=elementsize; s32++;
memcpy (dptr, (char*) &tmp_32, elementsize);
dptr+=elementsize;
s32++;
}
*num_bytes = num_vals * elementsize;
break;
case ORTE_INT64:
case ORTE_UINT64:
return ORTE_ERR_NOT_IMPLEMENTED;
dptr = (char *) dst;
s32 = (uint32_t *) src;
for (i=0; i<num_vals; i++) {
/* convert the host order to network order */
tmp_32 = htonl(*s32);
memcpy (dptr, (char*) &tmp_32, sizeof(uint32_t));
dptr += sizeof(uint32_t);
s32++;
/* do it twice to get 64 bits */
tmp_32 = htonl(*s32);
memcpy (dptr, (char*) &tmp_32, sizeof(uint32_t));
dptr += sizeof(uint32_t);
s32++;
}
*num_bytes = num_vals * sizeof(uint64_t);;
break;
case ORTE_FLOAT:
@ -267,24 +253,23 @@ int orte_dps_pack_nobuffer(void *dst, void *src, size_t num_vals,
for (i=0; i<num_vals; i++) {
/* pack native bool as uint8_t */
*bool_dst = *bool_src ? (uint8_t)true : (uint8_t)false;
bool_dst++; bool_src++;
bool_dst++;
bool_src++;
}
*num_bytes = num_vals * sizeof(uint8_t);
break;
case ORTE_STRING:
str = (char **) src;
dptr = (char *) dst;
elementsize = sizeof (uint32_t);
dptr = (char *) dst;
elementsize = sizeof (uint32_t);
for (i=0; i<num_vals; i++) {
len = strlen(str[i]); /* exclude the null terminator */
tmp_32 = htonl(len);
memcpy (dptr, (char*) &tmp_32, elementsize); /* copy str len to buffer */
memcpy (dptr, (char*) &tmp_32, elementsize); /* copy str len to buffer */
dptr+=elementsize;
memcpy(dptr, str[i], len); /* copy str to buffer */
dptr+=len;
*num_bytes += len + elementsize;
}
break;
@ -292,13 +277,14 @@ int orte_dps_pack_nobuffer(void *dst, void *src, size_t num_vals,
case ORTE_NAME:
sn = (orte_process_name_t*) src;
dptr = (char *) dst;
elementsize = sizeof (orte_process_name_t);
elementsize = sizeof (orte_process_name_t);
for (i=0; i<num_vals; i++) {
tmp_procname.cellid = htonl(sn->cellid);
tmp_procname.jobid = htonl(sn->jobid);
tmp_procname.vpid = htonl(sn->vpid);
memcpy (dptr, (char*) &tmp_procname, elementsize); /* copy converted proc name to buffer */
dptr+=elementsize; sn++;
memcpy (dptr, (char*) &tmp_procname, elementsize); /* copy converted proc name to buffer */
dptr+=elementsize;
sn++;
}
*num_bytes = num_vals * sizeof(orte_process_name_t);
break;
@ -306,12 +292,12 @@ int orte_dps_pack_nobuffer(void *dst, void *src, size_t num_vals,
case ORTE_BYTE_OBJECT:
sbyteptr = (orte_byte_object_t *) src;
dbyte = (uint8_t *) dst;
elementsize = sizeof (uint32_t);
elementsize = sizeof (uint32_t);
for (i=0; i<num_vals; i++) {
/* pack number of bytes */
tmp_32 = htonl(sbyteptr->size);
memcpy (dbyte, (char*) &tmp_32, elementsize); /* copy byte count to buffer */
dbyte += elementsize;
memcpy (dbyte, (char*) &tmp_32, elementsize); /* copy byte count to buffer */
dbyte += elementsize;
*num_bytes += elementsize;
/* pack actual bytes */
@ -323,36 +309,38 @@ int orte_dps_pack_nobuffer(void *dst, void *src, size_t num_vals,
break;
case ORTE_KEYVAL:
/* array of pointers to keyval objects - need to pack the objects */
/* array of pointers to keyval objects - need to pack the
objects */
keyval = (orte_gpr_keyval_t**) src;
/* use temp count of bytes packed 'n'. Must add these to num_bytes at each stage */
/* use temp count of bytes packed 'n'. Must add these to
num_bytes at each stage */
for (i=0; i < num_vals; i++) {
/* pack the key */
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(&(keyval[i]->key)), 1, ORTE_STRING, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
/* pack the data type so we can read it for unpacking */
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst, &(keyval[i]->type), 1,
ORTE_DATA_TYPE, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
/* pack the value */
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst, &(keyval[i]->value), 1,
keyval[i]->type, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
}
break;
@ -370,51 +358,51 @@ int orte_dps_pack_nobuffer(void *dst, void *src, size_t num_vals,
*num_bytes+=n;
/* pack the segment name */
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(&(values[i]->segment)), 1, ORTE_STRING, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
/* pack the number of tokens so we can read it for unpacking */
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(&(values[i]->num_tokens)), 1, ORTE_INT32, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
/* if there are tokens, pack them */
if (0 < values[i]->num_tokens) {
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)((values[i]->tokens)), values[i]->num_tokens, ORTE_STRING, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
}
/* pack the number of keyval pairs so we can read it for unpacking */
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(&(values[i]->cnt)), 1, ORTE_INT32, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
/* pack the keyval pairs */
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)((values[i]->keyvals)), values[i]->cnt, ORTE_KEYVAL, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
}
break;
@ -422,8 +410,7 @@ int orte_dps_pack_nobuffer(void *dst, void *src, size_t num_vals,
/* array of pointers to orte_app_context objects - need to pack the objects a set of fields at a time */
app_context = (orte_app_context_t**) src;
for (i=0; i < num_vals; i++) {
n = 0; /* must always start count at zero! */
n = 0; /* must always start count at zero! */
/* pack the application index (for multiapp jobs) */
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
@ -431,68 +418,68 @@ int orte_dps_pack_nobuffer(void *dst, void *src, size_t num_vals,
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
/* pack the application name */
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(&(app_context[i]->app)), 1, ORTE_STRING, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
/* pack the number of processes */
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(&(app_context[i]->num_procs)), 1, ORTE_INT32, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
/* pack the number of entries in the argv array */
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(&(app_context[i]->argc)), 1, ORTE_INT32, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
/* if there are entries, pack the argv entries */
if (0 < app_context[i]->argc) {
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(app_context[i]->argv), app_context[i]->argc, ORTE_STRING, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
}
/* pack the number of entries in the enviro array */
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(&(app_context[i]->num_env)), 1, ORTE_INT32, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
/* if there are entries, pack the enviro entries */
if (0 < app_context[i]->num_env) {
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(app_context[i]->env), app_context[i]->num_env, ORTE_STRING, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes+=n;
*num_bytes+=n;
}
/* pack the cwd */
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(&(app_context[i]->cwd)), 1, ORTE_STRING, &n)) {
return ORTE_ERROR;
@ -502,7 +489,7 @@ int orte_dps_pack_nobuffer(void *dst, void *src, size_t num_vals,
/* Pack the map data */
n = 0;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(&(app_context[i]->num_map)), 1, ORTE_INT32, &n)) {
return ORTE_ERROR;
@ -511,37 +498,37 @@ int orte_dps_pack_nobuffer(void *dst, void *src, size_t num_vals,
*num_bytes += n;
if (app_context[i]->num_map > 0) {
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(app_context[i]->map_data), app_context[i]->num_map, ORTE_APP_CONTEXT_MAP, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes += n;
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes += n;
}
}
break;
case ORTE_APP_CONTEXT_MAP:
case ORTE_APP_CONTEXT_MAP:
app_context_map = (orte_app_context_map_t**) src;
for (i=0; i < num_vals; i++) {
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(&(app_context_map[i]->map_type)), 1, ORTE_UINT8, &n)) {
(void*)(&(app_context_map[i]->map_type)), 1, ORTE_UINT8, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes += n;
n = 0;
if (ORTE_SUCCESS != orte_dps_pack_nobuffer(dst,
(void*)(&(app_context_map[i]->map_data)), 1, ORTE_STRING, &n)) {
return ORTE_ERROR;
(void*)(&(app_context_map[i]->map_data)), 1, ORTE_STRING, &n)) {
return ORTE_ERROR;
}
dst = (void*)((char*)dst + n);
*num_bytes += n;
}
break;
break;
case ORTE_GPR_SUBSCRIPTION:
/* array of pointers to subscription objects - need to pack the objects */

15
src/dps/dps_peek.c
Просмотреть файл

@ -39,7 +39,6 @@ int orte_dps_peek(orte_buffer_t *buffer,
size_t mem_left;
size_t num_bytes, hdr_bytes;
void *src;
uint32_t * s32;
orte_data_type_t stored_type;
/* check for errors */
@ -66,17 +65,21 @@ int orte_dps_peek(orte_buffer_t *buffer,
src = (void*)((char*)src + hdr_bytes);
/* got enough left for num_vals? */
if (sizeof(uint32_t) > mem_left) { /* not enough memory */
if (sizeof(size_t) > mem_left) { /* not enough memory */
return ORTE_ERR_UNPACK_FAILURE;
}
/* unpack the number of values */
s32 = (uint32_t *) src;
num_vals = (size_t)ntohl(*s32);
if (ORTE_SUCCESS != (rc =orte_dps_unpack_nobuffer(&num_vals, src, 1,
DPS_TYPE_SIZE_T, &mem_left, &num_bytes))) {
return rc;
}
if (type != NULL)
if (type != NULL) {
*type = stored_type;
if (number != NULL)
}
if (number != NULL) {
*number = num_vals;
}
return ORTE_SUCCESS;
}

194
src/dps/dps_unpack.c
Просмотреть файл

@ -50,16 +50,15 @@ int orte_dps_unpack(orte_buffer_t *buffer, void *dst,
void *src;
char *srcptr;
orte_data_type_t stored_type;
uint32_t tmp_32;
uint32_t tmp_32;
/* check for errors */
if (buffer == NULL || dst == NULL || max_num_vals == NULL) {
return (ORTE_ERR_BAD_PARAM);
}
num_bytes = 0; /* have not unpacked any yet */
hdr_bytes = 0;
num_bytes = 0; /* have not unpacked any yet */
hdr_bytes = 0;
src = buffer->from_ptr; /* get location in buffer */
mem_left = buffer->toend; /* how much data is left in buffer */
@ -75,24 +74,16 @@ int orte_dps_unpack(orte_buffer_t *buffer, void *dst,
return rc;
}
src = (void*)((char*)src + hdr_bytes);
if(type == ORTE_INT || type == ORTE_UINT) {
switch(sizeof(int)) {
case 1:
type = (type == ORTE_INT) ? ORTE_INT8 : ORTE_UINT8;
break;
case 2:
type = (type == ORTE_INT) ? ORTE_INT16 : ORTE_UINT16;
break;
case 4:
type = (type == ORTE_INT) ? ORTE_INT32 : ORTE_UINT32;
break;
case 8:
type = (type == ORTE_INT) ? ORTE_INT64 : ORTE_UINT64;
break;
default:
return ORTE_ERR_NOT_IMPLEMENTED;
}
/* check for size of generic data types so they can be properly
packed NOTE we convert the generic data type flag to a hard
type for storage to handle heterogeneity */
if (ORTE_INT == type) {
type = DPS_TYPE_INT;
} else if (ORTE_UINT == type) {
type = DPS_TYPE_UINT;
} else if (ORTE_SIZE == type) {
type = DPS_TYPE_SIZE_T;
}
/* check for type match - for now we require this to be an exact match -
@ -104,21 +95,17 @@ int orte_dps_unpack(orte_buffer_t *buffer, void *dst,
}
/* got enough left for num_vals? */
if (sizeof(uint32_t) > mem_left) { /* not enough memory */
if (mem_left < sizeof(size_t)) { /* not enough memory */
return ORTE_ERR_UNPACK_FAILURE;
}
/* unpack the number of values */
srcptr = (char*) src;
memcpy ((char*)&tmp_32, srcptr, sizeof(uint32_t));
num_vals = (size_t)ntohl(tmp_32);
if (num_vals > *max_num_vals) { /* not enough space provided */
return ORTE_UNPACK_INADEQUATE_SPACE;
if (ORTE_SUCCESS != (rc =orte_dps_unpack_nobuffer(&num_vals, src, 1,
DPS_TYPE_SIZE_T, &mem_left, &num_bytes))) {
return rc;
}
srcptr+=sizeof(uint32_t);
src = (void *)srcptr;
mem_left -= sizeof(uint32_t); /* we do this here but this is normally a function of unpack_nobuffer */
hdr_bytes += sizeof(uint32_t);
src = (void*)((char*)src + num_bytes);
hdr_bytes += num_bytes;
/* will check to see if adequate storage in buffer prior
* to unpacking the item
@ -127,9 +114,11 @@ int orte_dps_unpack(orte_buffer_t *buffer, void *dst,
stored_type, &mem_left, &num_bytes))) {
return rc;
}
#if OMPI_ENABLE_DEBUG
/* fflush(stdout); fflush(stderr); */
/* fprintf(stderr,"unpacked total bytes %d, (hdr %d datatype %d)\n", num_bytes+hdr_bytes, hdr_bytes, num_bytes); */
/* fflush(stdout); fflush(stderr); */
#endif
/* ok, we managed to unpack some stuff, so update all ptrs/cnts */
buffer->from_ptr = (void*)((char*)src + num_bytes); /* move by data type size only as src is after the header */
@ -149,8 +138,8 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
int rc;
size_t i;
size_t n;
size_t elementsize; /* size in bytes of an unpacked element */
char* srcptr; /* temp moving source pointer */
size_t elementsize; /* size in bytes of an unpacked element */
char* srcptr; /* temp moving source pointer */
uint16_t * d16;
uint32_t * d32;
uint16_t tmp_16;
@ -163,8 +152,8 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
orte_byte_object_t* dbyteptr;
orte_gpr_keyval_t **keyval;
orte_gpr_value_t **values;
orte_app_context_t **app_context;
orte_app_context_map_t **app_context_map;
orte_app_context_t **app_context;
orte_app_context_map_t **app_context_map;
uint32_t len;
char *str;
orte_gpr_subscription_t **subs;
@ -173,7 +162,6 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
/* defaults */
rc = ORTE_SUCCESS;
*num_bytes = 0;
elementsize = 1024*1024*1024; /* instant memory fault on error */
switch(type) {
@ -201,7 +189,7 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
srcptr = (char *) src;
d16 = (uint16_t *) dst;
elementsize = sizeof (uint16_t);
elementsize = sizeof (uint16_t);
if(num_vals * elementsize > *mem_left) {
num_vals = *mem_left / elementsize;
@ -209,10 +197,10 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
}
for(i=0; i<num_vals; i++) {
memcpy ((char*)&tmp_16, srcptr, elementsize);
memcpy ((char*)&tmp_16, srcptr, elementsize);
/* convert the network order to host order */
*d16 = ntohs(tmp_16);
d16++; srcptr+=elementsize;
d16++; srcptr+=elementsize;
}
*num_bytes = num_vals * elementsize;
break;
@ -226,7 +214,7 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
srcptr = (char *) src;
d32 = (uint32_t *) dst;
elementsize = sizeof (uint32_t);
elementsize = sizeof (uint32_t);
if(num_vals * elementsize > *mem_left) {
num_vals = *mem_left / elementsize;
@ -234,19 +222,42 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
}
for(i=0; i<num_vals; i++) {
memcpy ((char*)&tmp_32, srcptr, elementsize);
memcpy ((char*)&tmp_32, srcptr, elementsize);
/* convert the network order to host order */
*d32 = ntohl(tmp_32);
d32++; srcptr+=elementsize;
d32++;
srcptr+=elementsize;
}
*num_bytes = num_vals * elementsize;
break;
case ORTE_INT64:
case ORTE_UINT64:
return ORTE_ERR_NOT_IMPLEMENTED;
srcptr = (char *) src;
d32 = (uint32_t *) dst;
if(num_vals * sizeof(uint64_t) > *mem_left) {
num_vals = *mem_left / sizeof(uint64_t);
rc = ORTE_UNPACK_READ_PAST_END_OF_BUFFER;
}
for(i=0; i<num_vals; i++) {
memcpy ((char*)&tmp_32, srcptr, sizeof(uint32_t));
/* convert the network order to host order */
*d32 = ntohl(tmp_32);
d32++;
srcptr += sizeof(uint32_t);
/* do it twice to get 64 bits */
memcpy ((char*)&tmp_32, srcptr, sizeof(uint32_t));
/* convert the network order to host order */
*d32 = ntohl(tmp_32);
d32++;
srcptr += sizeof(uint32_t);
}
*num_bytes = num_vals * sizeof(uint64_t);
break;
case ORTE_FLOAT:
case ORTE_FLOAT4:
case ORTE_FLOAT8:
@ -268,7 +279,7 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
for(i=0; i<num_vals; i++) {
/* convert packed uint8_t to native bool */
*bool_dst = (*bool_src) ? true : false;
bool_dst++; bool_src++;
bool_dst++; bool_src++;
}
*num_bytes = num_vals * sizeof(uint8_t);
break;
@ -277,19 +288,19 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
dstr = (char**)dst;
srcptr = (char *) src;
elementsize = sizeof (uint32_t);
elementsize = sizeof (uint32_t);
for(i=0; i<num_vals; i++) {
/* unpack length of string first */
/* unpack length of string first */
if(*mem_left < elementsize) {
return ORTE_UNPACK_READ_PAST_END_OF_BUFFER;
}
memcpy ((char*)&tmp_32, srcptr, elementsize);
memcpy ((char*)&tmp_32, srcptr, elementsize);
len = ntohl(tmp_32);
srcptr += elementsize;
*num_bytes += elementsize;
*mem_left -= elementsize;
/* now unpack string */
/* now unpack string */
if(*mem_left < len) {
return ORTE_UNPACK_READ_PAST_END_OF_BUFFER;
}
@ -309,10 +320,10 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
case ORTE_NAME:
dn = (orte_process_name_t*) dst;
srcptr = (char *) src;
elementsize = sizeof (orte_process_name_t);
srcptr = (char *) src;
elementsize = sizeof (orte_process_name_t);
for (i=0; i<num_vals; i++) {
memcpy ((char*) &tmp_procname, srcptr, elementsize);
memcpy ((char*) &tmp_procname, srcptr, elementsize);
dn->cellid = ntohl(tmp_procname.cellid);
dn->jobid = ntohl(tmp_procname.jobid);
dn->vpid = ntohl(tmp_procname.vpid);
@ -325,13 +336,13 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
dbyteptr = (orte_byte_object_t*)dst;
srcptr = (char*) src; /* iterate from start of buffer */
elementsize = sizeof (uint32_t);
elementsize = sizeof (uint32_t);
for(i=0; i<num_vals; i++) {
/* unpack object size in bytes first */
/* unpack object size in bytes first */
if(*mem_left < elementsize) {
return ORTE_UNPACK_READ_PAST_END_OF_BUFFER;
}
memcpy ((char*)&tmp_32, srcptr, elementsize);
memcpy ((char*)&tmp_32, srcptr, elementsize);
dbyteptr->size = ntohl(tmp_32);
srcptr += elementsize;
*num_bytes += elementsize;
@ -356,35 +367,35 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
/* unpack into an array of keyval objects */
keyval = (orte_gpr_keyval_t**) dst;
/* use temp count of unpacked 'n' which we sum to produce correct value later */
/* use temp count of unpacked 'n' which we sum to produce correct value later */
for (i=0; i < num_vals; i++) {
keyval[i] = OBJ_NEW(orte_gpr_keyval_t);
if (NULL == keyval[i]) {
return ORTE_ERR_OUT_OF_RESOURCE;
}
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(keyval[i]->key),
src, 1, ORTE_STRING, mem_left, &n))) {
return rc;
}
src = (void*)((char*)src + n);
*num_bytes+=n;
*num_bytes+=n;
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(keyval[i]->type),
src, 1, ORTE_DATA_TYPE, mem_left, &n))) {
return rc;
}
src = (void*)((char*)src + n);
*num_bytes+=n;
*num_bytes+=n;
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(keyval[i]->value),
src, 1, keyval[i]->type, mem_left, &n))) {
return rc;
}
src = (void*)((char*)src + n);
*num_bytes+=n;
*num_bytes+=n;
}
/* must return here for composite unpacks that change mem_left directly */
@ -412,22 +423,22 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
*num_bytes+=n;
/* unpack the segment name */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(values[i]->segment),
src, 1, ORTE_STRING, mem_left, &n))) {
return rc;
}
src = (void*)((char*)src + n);
*num_bytes+=n;
*num_bytes+=n;
/* get the number of tokens */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(values[i]->num_tokens),
src, 1, ORTE_INT32, mem_left, &n))) {
return rc;
}
src = (void*)((char*)src + n);
*num_bytes+=n;
*num_bytes+=n;
/* if there are tokens, allocate the required space for the char * pointers */
if (0 < values[i]->num_tokens) {
@ -437,7 +448,7 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
}
/* and unpack them */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(values[i]->tokens,
src, values[i]->num_tokens, ORTE_STRING, mem_left, &n))) {
return rc;
@ -447,13 +458,13 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
}
/* get the number of keyval pairs */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(values[i]->cnt),
src, 1, ORTE_INT32, mem_left, &n))) {
return rc;
}
src = (void*)((char*)src + n);
*num_bytes+=n;
*num_bytes+=n;
/* allocate the required space for the keyval object pointers */
if(values[i]->cnt) {
@ -463,7 +474,7 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
}
/* unpack the keyval pairs */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(values[i]->keyvals,
src, values[i]->cnt, ORTE_KEYVAL, mem_left, &n))) {
return rc;
@ -489,34 +500,34 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
}
/* get the app index number */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(app_context[i]->idx),
src, 1, ORTE_INT32, mem_left, &n))) {
return rc;
}
src = (void*)((char*)src + n);
*num_bytes+=n;
*num_bytes+=n;
/* unpack the application name */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(app_context[i]->app),
src, 1, ORTE_STRING, mem_left, &n))) {
return rc;
}
src = (void*)((char*)src + n);
*num_bytes+=n;
*num_bytes+=n;
/* get the number of processes */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(app_context[i]->num_procs),
src, 1, ORTE_INT32, mem_left, &n))) {
return rc;
}
src = (void*)((char*)src + n);
*num_bytes+=n;
*num_bytes+=n;
/* get the number of argv strings */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(app_context[i]->argc),
src, 1, ORTE_INT32, mem_left, &n))) {
return rc;
@ -533,7 +544,7 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
app_context[i]->argv[app_context[i]->argc] = NULL;
/* and unpack them */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(app_context[i]->argv,
src, app_context[i]->argc, ORTE_STRING, mem_left, &n))) {
return rc;
@ -543,13 +554,13 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
}
/* get the number of env strings */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(app_context[i]->num_env),
src, 1, ORTE_INT32, mem_left, &n))) {
return rc;
}
src = (void*)((char*)src + n);
*num_bytes+=n;
*num_bytes+=n;
/* if there are env strings, allocate the required space for the char * pointers */
if (0 < app_context[i]->num_env) {
@ -560,7 +571,7 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
app_context[i]->env[app_context[i]->num_env] = NULL;
/* and unpack them */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(app_context[i]->env,
src, app_context[i]->num_env, ORTE_STRING, mem_left, &n))) {
return rc;
@ -570,7 +581,7 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
}
/* unpack the cwd */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&app_context[i]->cwd,
src, 1, ORTE_STRING, mem_left, &n))) {
return rc;
@ -580,7 +591,7 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
/* unpack the map data */
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(app_context[i]->num_map),
src, 1, ORTE_INT32, mem_left, &n))) {
return rc;
@ -593,10 +604,10 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
if (NULL == app_context[i]->map_data) {
return ORTE_ERR_OUT_OF_RESOURCE;
}
n = 0;
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(app_context[i]->map_data,
src, app_context[i]->num_map, ORTE_APP_CONTEXT_MAP, mem_left, &n))) {
return rc;
return rc;
}
src = (void*)((char*)src + n);
*num_bytes += n;
@ -604,7 +615,8 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
}
}
/* must return here for composite unpacks that change mem_left directly */
/* must return here for composite unpacks that change
mem_left directly */
return ORTE_SUCCESS;
break;
@ -620,8 +632,8 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
return ORTE_ERR_OUT_OF_RESOURCE;
}
/* map type */
n = 0;
/* map type */
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(app_context_map[i]->map_type),
src, 1, ORTE_UINT8, mem_left, &n))) {
return rc;
@ -629,8 +641,8 @@ int orte_dps_unpack_nobuffer(void *dst, void *src, size_t num_vals,
src = (void*)((char*)src + n);
*num_bytes+=n;
/* map data */
n = 0;
/* map data */
n = 0;
if (ORTE_SUCCESS != (rc = orte_dps_unpack_nobuffer(&(app_context_map[i]->map_data),
src, 1, ORTE_STRING, mem_left, &n))) {
return rc;