pmix_status_t pmix_bfrop_unpack_double(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
int32_t i, n;
double *desttmp = (double*) dest, tmp;
pmix_status_t ret;
char *convert;
pmix_output_verbose(20, pmix_globals.debug_output, "pmix_bfrop_unpack_double * %d\n", (int)*num_vals);
/* check to see if there's enough data in buffer */
if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(double))) {
return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
}
/* unpack the data */
for (i = 0; i < (*num_vals); ++i) {
n=1;
convert = NULL;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &convert, &n, PMIX_STRING))) {
return ret;
}
if (NULL != convert) {
tmp = strtod(convert, NULL);
memcpy(&desttmp[i], &tmp, sizeof(tmp));
free(convert);
}
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_kval(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_kval_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d kvals", *num_vals);
ptr = (pmix_kval_t*) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
PMIX_CONSTRUCT(&ptr[i], pmix_kval_t);
/* unpack the key */
m = 1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &ptr[i].key, &m, PMIX_STRING))) {
PMIX_ERROR_LOG(ret);
return ret;
}
/* allocate the space */
ptr[i].value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
/* unpack the value */
m = 1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_value(buffer, ptr[i].value, &m, PMIX_VALUE))) {
PMIX_ERROR_LOG(ret);
return ret;
}
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_pinfo(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_proc_info_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d pinfo", *num_vals);
ptr = (pmix_proc_info_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
PMIX_PROC_INFO_CONSTRUCT(&ptr[i]);
/* unpack the proc */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_proc(buffer, &ptr[i].proc, &m, PMIX_PROC))) {
return ret;
}
/* unpack the hostname */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &ptr[i].hostname, &m, PMIX_STRING))) {
return ret;
}
/* unpack the executable */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &ptr[i].executable_name, &m, PMIX_STRING))) {
return ret;
}
/* unpack pid */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_pid(buffer, &ptr[i].pid, &m, PMIX_PID))) {
return ret;
}
/* unpack state */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_pstate(buffer, &ptr[i].state, &m, PMIX_PROC_STATE))) {
return ret;
}
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_info(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_info_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
char *tmp;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d info", *num_vals);
ptr = (pmix_info_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
memset(ptr[i].key, 0, sizeof(ptr[i].key));
memset(&ptr[i].value, 0, sizeof(pmix_value_t));
/* unpack key */
m=1;
tmp = NULL;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &tmp, &m, PMIX_STRING))) {
PMIX_ERROR_LOG(ret);
return ret;
}
if (NULL == tmp) {
PMIX_ERROR_LOG(PMIX_ERROR);
return PMIX_ERROR;
}
(void)strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
free(tmp);
/* unpack the flags */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_infodirs(buffer, &ptr[i].flags, &m, PMIX_INFO_DIRECTIVES))) {
PMIX_ERROR_LOG(ret);
return ret;
}
/* unpack value - since the value structure is statically-defined
* instead of a pointer in this struct, we directly unpack it to
* avoid the malloc */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int(buffer, &ptr[i].value.type, &m, PMIX_INT))) {
PMIX_ERROR_LOG(ret);
return ret;
}
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: info type %d", ptr[i].value.type);
m=1;
if (PMIX_SUCCESS != (ret = unpack_val(buffer, &ptr[i].value))) {
PMIX_ERROR_LOG(ret);
return ret;
}
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_pdata(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_pdata_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
char *tmp;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d pdata", *num_vals);
ptr = (pmix_pdata_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
PMIX_PDATA_CONSTRUCT(&ptr[i]);
/* unpack the proc */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_proc(buffer, &ptr[i].proc, &m, PMIX_PROC))) {
return ret;
}
/* unpack key */
m=1;
tmp = NULL;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &tmp, &m, PMIX_STRING))) {
return ret;
}
if (NULL == tmp) {
return PMIX_ERROR;
}
(void)strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
free(tmp);
/* unpack value - since the value structure is statically-defined
* instead of a pointer in this struct, we directly unpack it to
* avoid the malloc */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int(buffer, &ptr[i].value.type, &m, PMIX_INT))) {
return ret;
}
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: pdata type %d", ptr[i].value.type);
m=1;
if (PMIX_SUCCESS != (ret = unpack_val(buffer, &ptr[i].value))) {
return ret;
}
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_query(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_query_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
int32_t nkeys;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d queries", *num_vals);
ptr = (pmix_query_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
PMIX_QUERY_CONSTRUCT(&ptr[i]);
/* unpack the number of keys */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int32(buffer, &nkeys, &m, PMIX_INT32))) {
return ret;
}
if (0 < nkeys) {
/* unpack the keys */
if (NULL == (ptr[i].keys = (char**)calloc(nkeys+1, sizeof(char*)))) {
return PMIX_ERR_NOMEM;
}
/* unpack keys */
m=nkeys;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, ptr[i].keys, &m, PMIX_STRING))) {
return ret;
}
}
/* unpack the number of qualifiers */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_sizet(buffer, &ptr[i].nqual, &m, PMIX_SIZE))) {
return ret;
}
if (0 < ptr[i].nqual) {
/* unpack the qualifiers */
PMIX_INFO_CREATE(ptr[i].qualifiers, ptr[i].nqual);
m = ptr[i].nqual;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_info(buffer, ptr[i].qualifiers, &m, PMIX_INFO))) {
return ret;
}
}
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_proc(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_proc_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
char *tmp;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d procs", *num_vals);
ptr = (pmix_proc_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: init proc[%d]", i);
memset(&ptr[i], 0, sizeof(pmix_proc_t));
/* unpack nspace */
m=1;
tmp = NULL;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &tmp, &m, PMIX_STRING))) {
return ret;
}
if (NULL == tmp) {
return PMIX_ERROR;
}
(void)strncpy(ptr[i].nspace, tmp, PMIX_MAX_NSLEN);
free(tmp);
/* unpack the rank */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_rank(buffer, &ptr[i].rank, &m, PMIX_PROC_RANK))) {
return ret;
}
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_app(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_app_t *ptr;
int32_t i, k, n, m;
pmix_status_t ret;
int32_t nval;
char *tmp;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d apps", *num_vals);
ptr = (pmix_app_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
/* initialize the fields */
PMIX_APP_CONSTRUCT(&ptr[i]);
/* unpack cmd */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &ptr[i].cmd, &m, PMIX_STRING))) {
return ret;
}
/* unpack argc */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int(buffer, &nval, &m, PMIX_INT32))) {
return ret;
}
/* unpack argv */
for (k=0; k < nval; k++) {
m=1;
tmp = NULL;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &tmp, &m, PMIX_STRING))) {
return ret;
}
if (NULL == tmp) {
return PMIX_ERROR;
}
pmix_argv_append_nosize(&ptr[i].argv, tmp);
free(tmp);
}
/* unpack env */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int32(buffer, &nval, &m, PMIX_INT32))) {
return ret;
}
for (k=0; k < nval; k++) {
m=1;
tmp = NULL;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &tmp, &m, PMIX_STRING))) {
return ret;
}
if (NULL == tmp) {
return PMIX_ERROR;
}
pmix_argv_append_nosize(&ptr[i].env, tmp);
free(tmp);
}
/* unpack cwd */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &ptr[i].cwd, &m, PMIX_STRING))) {
return ret;
}
/* unpack maxprocs */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int(buffer, &ptr[i].maxprocs, &m, PMIX_INT))) {
return ret;
}
/* unpack info array */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_sizet(buffer, &ptr[i].ninfo, &m, PMIX_SIZE))) {
return ret;
}
if (0 < ptr[i].ninfo) {
PMIX_INFO_CREATE(ptr[i].info, ptr[i].ninfo);
m = ptr[i].ninfo;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_info(buffer, ptr[i].info, &m, PMIX_INFO))) {
return ret;
}
}
}
return PMIX_SUCCESS;
}
int pmix_bfrop_unpack_topo(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals,
pmix_data_type_t type)
{
/* NOTE: hwloc defines topology_t as a pointer to a struct! */
hwloc_topology_t t, *tarray = (hwloc_topology_t*)dest;
int rc=PMIX_SUCCESS, i, cnt, j;
char *xmlbuffer;
struct hwloc_topology_support *support;
for (i=0, j=0; i < *num_vals; i++) {
/* unpack the xml string */
cnt=1;
xmlbuffer = NULL;
if (PMIX_SUCCESS != (rc = pmix_bfrop_unpack_string(buffer, &xmlbuffer, &cnt, PMIX_STRING))) {
goto cleanup;
}
if (NULL == xmlbuffer) {
goto cleanup;
}
/* convert the xml */
if (0 != hwloc_topology_init(&t)) {
rc = PMIX_ERROR;
goto cleanup;
}
if (0 != hwloc_topology_set_xmlbuffer(t, xmlbuffer, strlen(xmlbuffer))) {
rc = PMIX_ERROR;
free(xmlbuffer);
hwloc_topology_destroy(t);
goto cleanup;
}
/* since we are loading this from an external source, we have to
* explicitly set a flag so hwloc sets things up correctly
*/
if (0 != hwloc_topology_set_flags(t, HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM | HWLOC_TOPOLOGY_FLAG_IO_DEVICES)) {
free(xmlbuffer);
rc = PMIX_ERROR;
hwloc_topology_destroy(t);
goto cleanup;
}
/* now load the topology */
if (0 != hwloc_topology_load(t)) {
free(xmlbuffer);
rc = PMIX_ERROR;
hwloc_topology_destroy(t);
goto cleanup;
}
if (NULL != xmlbuffer) {
free(xmlbuffer);
}
/* get the available support - hwloc unfortunately does
* not include this info in its xml import!
*/
support = (struct hwloc_topology_support*)hwloc_topology_get_support(t);
cnt = sizeof(struct hwloc_topology_discovery_support);
if (PMIX_SUCCESS != (rc = pmix_bfrop_unpack_byte(buffer, support->discovery, &cnt, PMIX_BYTE))) {
goto cleanup;
}
cnt = sizeof(struct hwloc_topology_cpubind_support);
if (PMIX_SUCCESS != (rc = pmix_bfrop_unpack_byte(buffer, support->cpubind, &cnt, PMIX_BYTE))) {
goto cleanup;
}
cnt = sizeof(struct hwloc_topology_membind_support);
if (PMIX_SUCCESS != (rc = pmix_bfrop_unpack_byte(buffer, support->membind, &cnt, PMIX_BYTE))) {
goto cleanup;
}
/* pass it back */
tarray[i] = t;
/* track the number added */
j++;
}
cleanup:
*num_vals = j;
return rc;
}
