Implement support for proctable queries

Signed-off-by: Ralph Castain <[email protected]>

Author: Ralph Castain

examples/debugger.c

@@ -74,6 +74,7 @@ typedef struct {
  * info from a query */
 typedef struct {
     mylock_t lock;
+    pmix_status_t status;
     pmix_info_t *info;
     size_t ninfo;
 } myquery_data_t;
@@ -105,14 +106,14 @@ static void cbfunc(pmix_status_t status,
     myquery_data_t *mq = (myquery_data_t*)cbdata;
     size_t n;
 
+    mq->status = status;
     /* save the returned info - the PMIx library "owns" it
      * and will release it and perform other cleanup actions
      * when release_fn is called */
     if (0 < ninfo) {
         PMIX_INFO_CREATE(mq->info, ninfo);
         mq->ninfo = ninfo;
         for (n=0; n < ninfo; n++) {
-            fprintf(stderr, "Transferring %s\n", info[n].key);
             PMIX_INFO_XFER(&mq->info[n], &info[n]);
         }
     }
@@ -337,9 +338,11 @@ int main(int argc, char **argv)
     /* check to see if we are using an intermediate launcher - we only
      * support those we recognize */
     found = false;
-    for (n=0; NULL != launchers[n]; n++) {
-        if (0 == strcmp(argv[1], launchers[n])) {
-            found = true;
+    if (1 < argc) {
+        for (n=0; NULL != launchers[n]; n++) {
+            if (0 == strcmp(argv[1], launchers[n])) {
+                found = true;
+            }
         }
     }
     if (found) {
@@ -507,6 +510,61 @@ int main(int argc, char **argv)
             PMIX_INFO_FREE(info, ninfo);
             PMIX_APP_FREE(app, napps);
 
+            /* get the proctable for this nspace */
+            PMIX_QUERY_CREATE(query, 1);
+            PMIX_ARGV_APPEND(rc, query[0].keys, PMIX_QUERY_PROC_TABLE);
+            query[0].nqual = 1;
+            PMIX_INFO_CREATE(query->qualifiers, query[0].nqual);
+            PMIX_INFO_LOAD(&query->qualifiers[0], PMIX_NSPACE, clientspace, PMIX_STRING);
+
+            DEBUG_CONSTRUCT_LOCK(&myquery_data.lock);
+            myquery_data.info = NULL;
+            myquery_data.ninfo = 0;
+
+            if (PMIX_SUCCESS != (rc = PMIx_Query_info_nb(query, 1, cbfunc, (void*)&myquery_data))) {
+                fprintf(stderr, "Debugger[%s:%d] Proctable query failed: %d\n", myproc.nspace, myproc.rank, rc);
+                goto done;
+            }
+            /* wait to get a response */
+            DEBUG_WAIT_THREAD(&myquery_data.lock);
+            DEBUG_DESTRUCT_LOCK(&myquery_data.lock);
+
+            /* we should have gotten a response */
+            if (PMIX_SUCCESS != myquery_data.status) {
+                fprintf(stderr, "Debugger[%s:%d] Proctable query failed: %s\n",
+                        myproc.nspace, myproc.rank, PMIx_Error_string(myquery_data.status));
+                goto done;
+            }
+            /* there should hvae been data */
+            if (NULL == myquery_data.info || 0 == myquery_data.ninfo) {
+                fprintf(stderr, "Debugger[%s:%d] Proctable query return no results\n",
+                        myproc.nspace, myproc.rank);
+                goto done;
+            }
+            /* the query should have returned a data_array */
+            if (PMIX_DATA_ARRAY != myquery_data.info[0].value.type) {
+                fprintf(stderr, "Debugger[%s:%d] Query returned incorrect data type: %s\n", PMIx_Data_type_string(myquery_data.info[0].value.type));
+                return -1;
+            }
+            if (NULL == myquery_data.info[0].value.data.darray->array) {
+                fprintf(stderr, "Debugger[%s:%d] Query returned no proctable info\n");
+                goto done;
+            }
+            /* the data array consists of a struct:
+             *     size_t size;
+             *     void* array;
+             *
+             * In this case, the array is composed of pmix_proc_info_t structs:
+             *     pmix_proc_t proc;   // contains the nspace,rank of this proc
+             *     char* hostname;
+             *     char* executable_name;
+             *     pid_t pid;
+             *     int exit_code;
+             *     pmix_proc_state_t state;
+             */
+            fprintf(stderr, "Received %d array elements\n", (int)myquery_data.info[0].value.data.darray->size);
+            goto done;
+
             /* now launch the debugger daemons */
             if (PMIX_SUCCESS != (rc = spawn_debugger(clientspace))) {
                 goto done;

opal/class/opal_interval_tree.c

@@ -27,6 +27,8 @@
 
 #include "opal/class/opal_interval_tree.h"
 #include <limits.h>
+#include <stddef.h>
+#include <string.h>
 
 /* Private functions */
 static void opal_interval_tree_insert_node (opal_interval_tree_t *tree, opal_interval_tree_node_t *node);

opal/mca/pmix/pmix3x/pmix/include/pmix_common.h.in

@@ -573,11 +573,13 @@ typedef uint8_t pmix_proc_state_t;
 #define PMIX_PROC_STATE_ABORTED_BY_SIG          (PMIX_PROC_STATE_ERROR +  4)  /* process aborted by signal */
 #define PMIX_PROC_STATE_TERM_WO_SYNC            (PMIX_PROC_STATE_ERROR +  5)  /* process exit'd w/o calling PMIx_Finalize */
 #define PMIX_PROC_STATE_COMM_FAILED             (PMIX_PROC_STATE_ERROR +  6)  /* process communication has failed */
-#define PMIX_PROC_STATE_CALLED_ABORT            (PMIX_PROC_STATE_ERROR +  7)  /* process called "PMIx_Abort" */
-#define PMIX_PROC_STATE_MIGRATING               (PMIX_PROC_STATE_ERROR +  8)  /* process failed and is waiting for resources before restarting */
-#define PMIX_PROC_STATE_CANNOT_RESTART          (PMIX_PROC_STATE_ERROR +  9)  /* process failed and cannot be restarted */
-#define PMIX_PROC_STATE_TERM_NON_ZERO           (PMIX_PROC_STATE_ERROR + 10)  /* process exited with a non-zero status, indicating abnormal */
-#define PMIX_PROC_STATE_FAILED_TO_LAUNCH        (PMIX_PROC_STATE_ERROR + 11)  /* unable to launch process */
+#define PMIX_PROC_STATE_SENSOR_BOUND_EXCEEDED   (PMIX_PROC_STATE_ERROR +  7)  /* process exceeded a sensor limit */
+#define PMIX_PROC_STATE_CALLED_ABORT            (PMIX_PROC_STATE_ERROR +  8)  /* process called "PMIx_Abort" */
+#define PMIX_PROC_STATE_HEARTBEAT_FAILED        (PMIX_PROC_STATE_ERROR +  9)  /* process failed to send heartbeat w/in time limit */
+#define PMIX_PROC_STATE_MIGRATING               (PMIX_PROC_STATE_ERROR + 10)  /* process failed and is waiting for resources before restarting */
+#define PMIX_PROC_STATE_CANNOT_RESTART          (PMIX_PROC_STATE_ERROR + 11)  /* process failed and cannot be restarted */
+#define PMIX_PROC_STATE_TERM_NON_ZERO           (PMIX_PROC_STATE_ERROR + 12)  /* process exited with a non-zero status, indicating abnormal */
+#define PMIX_PROC_STATE_FAILED_TO_LAUNCH        (PMIX_PROC_STATE_ERROR + 13)  /* unable to launch process */
 
 
 /****    PMIX ERROR CONSTANTS    ****/
@@ -1356,16 +1358,20 @@ struct pmix_info_t {
         }                                       \
     } while (0)
 
-#define PMIX_INFO_LOAD(m, k, v, t)                      \
-    do {                                                \
-        (void)strncpy((m)->key, (k), PMIX_MAX_KEYLEN);  \
-        pmix_value_load(&((m)->value), (v), (t));       \
-    } while (0)
-#define PMIX_INFO_XFER(d, s)                                \
+#define PMIX_INFO_LOAD(m, k, v, t)                          \
     do {                                                    \
-        (void)strncpy((d)->key, (s)->key, PMIX_MAX_KEYLEN); \
-        (d)->flags = (s)->flags;                      \
-        pmix_value_xfer(&(d)->value, &(s)->value);          \
+        if (NULL != (k)) {                                  \
+            (void)strncpy((m)->key, (k), PMIX_MAX_KEYLEN);  \
+        }                                                   \
+        pmix_value_load(&((m)->value), (v), (t));           \
+    } while (0)
+#define PMIX_INFO_XFER(d, s)                                    \
+    do {                                                        \
+        if (NULL != (s)->key) {                                 \
+            (void)strncpy((d)->key, (s)->key, PMIX_MAX_KEYLEN); \
+        }                                                       \
+        (d)->flags = (s)->flags;                                \
+        pmix_value_xfer(&(d)->value, &(s)->value);              \
     } while(0)
 
 #define PMIX_INFO_REQUIRED(m)       \
@@ -1386,7 +1392,9 @@ struct pmix_info_t {
                 (r) = PMIX_ERR_NOMEM;                          \
                 break;                                         \
             }                                                  \
-            _kv->key = strdup(_info[_n].key);                  \
+            if (NULL != _info[_n].key) {                       \
+                _kv->key = strdup(_info[_n].key);              \
+            }                                                  \
             PMIX_VALUE_XFER((r), _kv->value, &_info[_n].value);\
             if (PMIX_SUCCESS != (r)) {                         \
                 PMIX_RELEASE(_kv);                             \

opal/mca/pmix/pmix3x/pmix/src/common/pmix_query.c

@@ -63,6 +63,7 @@ static void query_cbfunc(struct pmix_peer_t *peer,
     PMIX_BFROPS_UNPACK(rc, peer, buf, &results->status, &cnt, PMIX_STATUS);
     if (PMIX_SUCCESS != rc) {
         PMIX_ERROR_LOG(rc);
+        results->status = rc;
         goto complete;
     }
     if (PMIX_SUCCESS != results->status) {
@@ -74,6 +75,7 @@ static void query_cbfunc(struct pmix_peer_t *peer,
     PMIX_BFROPS_UNPACK(rc, peer, buf, &results->ninfo, &cnt, PMIX_SIZE);
     if (PMIX_SUCCESS != rc) {
         PMIX_ERROR_LOG(rc);
+        results->status = rc;
         goto complete;
     }
     if (0 < results->ninfo) {
@@ -82,6 +84,7 @@ static void query_cbfunc(struct pmix_peer_t *peer,
         PMIX_BFROPS_UNPACK(rc, peer, buf, results->info, &cnt, PMIX_INFO);
         if (PMIX_SUCCESS != rc) {
             PMIX_ERROR_LOG(rc);
+            results->status = rc;
             goto complete;
         }
     }

opal/mca/pmix/pmix3x/pmix/src/common/pmix_strings.c

@@ -71,8 +71,12 @@ PMIX_EXPORT const char* PMIx_Proc_state_string(pmix_proc_state_t state)
             return "PROC TERMINATED WITHOUT CALLING PMIx_Finalize";
         case PMIX_PROC_STATE_COMM_FAILED:
             return "PROC LOST COMMUNICATION";
+        case PMIX_PROC_STATE_SENSOR_BOUND_EXCEEDED:
+            return "PROC SENSOR BOUND EXCEEDED";
         case PMIX_PROC_STATE_CALLED_ABORT:
             return "PROC CALLED PMIx_Abort";
+        case PMIX_PROC_STATE_HEARTBEAT_FAILED:
+            return "PROC FAILED TO REPORT HEARTBEAT";
         case PMIX_PROC_STATE_MIGRATING:
             return "PROC WAITING TO MIGRATE";
         case PMIX_PROC_STATE_CANNOT_RESTART:

opal/mca/pmix/pmix3x/pmix/src/mca/bfrops/base/bfrop_base_copy.c

@@ -373,6 +373,7 @@ pmix_status_t pmix_bfrops_base_copy_pinfo(pmix_proc_info_t **dest,
     if (NULL == p) {
         return PMIX_ERR_NOMEM;
     }
+    memcpy(&p->proc, &src->proc, sizeof(pmix_proc_t));
     if (NULL != src->hostname) {
         p->hostname = strdup(src->hostname);
     }
@@ -623,7 +624,7 @@ pmix_status_t pmix_bfrops_base_copy_darray(pmix_data_array_t **dest,
             p1 = (pmix_info_t*)p->array;
             s1 = (pmix_info_t*)src->array;
             for (n=0; n < src->size; n++) {
-                PMIX_INFO_LOAD(&p1[n], s1[n].key, &s1[n].value.data.flag, s1[n].value.type);
+                PMIX_INFO_XFER(&p1[n], &s1[n]);
             }
             break;
         case PMIX_PDATA:
@@ -635,7 +636,7 @@ pmix_status_t pmix_bfrops_base_copy_darray(pmix_data_array_t **dest,
             pd = (pmix_pdata_t*)p->array;
             sd = (pmix_pdata_t*)src->array;
             for (n=0; n < src->size; n++) {
-                PMIX_PDATA_LOAD(&pd[n], &sd[n].proc, sd[n].key, &sd[n].value.data.flag, sd[n].value.type);
+                PMIX_PDATA_XFER(&pd[n], &sd[n]);
             }
             break;
         case PMIX_BUFFER: